Merge branch 'staging' into fix/loading-followups2

Author: waleedlatif1

apps/docs/openapi-v2-files-audit.json

@@ -1036,9 +1036,9 @@
             "name": "resourceType",
             "in": "query",
             "required": false,
-            "description": "Filter by exact resource type.",
+            "description": "Filter by resource type. Accepts a comma-separated set; members are trimmed and deduplicated, and member order affects neither the result nor the cursor.",
             "schema": {
-              "description": "Filter by exact resource type.",
+              "description": "Filter by resource type. Accepts a comma-separated set; members are trimmed and deduplicated, and member order affects neither the result nor the cursor.",
               "type": "string"
             }
           },

apps/docs/openapi-v2-knowledge.json

@@ -2743,9 +2743,22 @@
           },
           "operator": {
             "default": "eq",
-            "description": "Comparison operator; valid operators depend on the field type.",
+            "description": "Comparison operator; valid operators depend on the field type. Text tags accept eq, neq, contains, not_contains, starts_with, ends_with; number and date tags accept eq, neq, gt, gte, lt, lte, between; boolean tags accept eq, neq. An operator the tag's field type does not implement is rejected, never ignored.",
             "examples": ["eq"],
-            "type": "string"
+            "type": "string",
+            "enum": [
+              "eq",
+              "neq",
+              "contains",
+              "not_contains",
+              "starts_with",
+              "ends_with",
+              "gt",
+              "gte",
+              "lt",
+              "lte",
+              "between"
+            ]
           },
           "value": {
             "anyOf": [
@@ -2763,7 +2776,7 @@
             "examples": ["billing"]
           },
           "valueTo": {
-            "description": "Upper bound for the `between` operator.",
+            "description": "Upper bound for the `between` operator, and required whenever that operator is used.",
             "anyOf": [
               {
                 "type": "string"
@@ -2775,6 +2788,7 @@
           }
         },
         "required": ["tagName", "value"],
+        "additionalProperties": false,
         "title": "Knowledge search tag filter",
         "description": "A structured tag filter applied to knowledge search."
       },

apps/docs/openapi-v2-logs.json

@@ -133,20 +133,24 @@
             "name": "minCost",
             "in": "query",
             "required": false,
-            "description": "Minimum execution cost in USD.",
+            "description": "Minimum execution cost in USD, from 0 to 1000000. A run is never charged a negative amount, so a negative bound is rejected rather than treated as a filter that matches every run.",
             "schema": {
               "type": "number",
-              "description": "Minimum execution cost in USD."
+              "minimum": 0,
+              "maximum": 1000000,
+              "description": "Minimum execution cost in USD, from 0 to 1000000. A run is never charged a negative amount, so a negative bound is rejected rather than treated as a filter that matches every run."
             }
           },
           {
             "name": "maxCost",
             "in": "query",
             "required": false,
-            "description": "Maximum execution cost in USD.",
+            "description": "Maximum execution cost in USD, from 0 to 1000000. A run is never charged a negative amount, so a negative bound is rejected rather than treated as a filter that matches every run.",
             "schema": {
               "type": "number",
-              "description": "Maximum execution cost in USD."
+              "minimum": 0,
+              "maximum": 1000000,
+              "description": "Maximum execution cost in USD, from 0 to 1000000. A run is never charged a negative amount, so a negative bound is rejected rather than treated as a filter that matches every run."
             }
           },
           {

apps/realtime/src/handlers/file-doc-store.test.ts

@@ -20,8 +20,10 @@ interface Backing {
   readerClosed: boolean
   /** Failed reads served, so a test can prove the loop is not spinning at the read cadence. */
   reads: number
-  /** When each read was attempted, so a test can assert the BACKOFF rather than a count in a window. */
-  readTimes: number[]
+  /** When each FAILED read was attempted, so a test can measure one backoff interval exactly. */
+  failedReadTimes: number[]
+  /** Reads that returned (the idle steady state) — the event that ends a failure streak. */
+  idleReads: number
   /** `connect()` calls, so a test can prove a closed reader is re-opened rather than abandoned. */
   connects: number
 }
@@ -66,8 +68,8 @@ function makeClient(): any {
     },
     xRead: async (streams: { key: string; id: string }[]) => {
       b().reads++
-      b().readTimes.push(Date.now())
       if (b().readerClosed) {
+        b().failedReadTimes.push(Date.now())
         client.isOpen = false
         throw new Error('The client is closed')
       }
@@ -77,8 +79,12 @@ function makeClient(): any {
         const after = (b().streams.get(key) ?? []).filter((e) => seqOf(e.id) > seqOf(id))
         if (after.length) res.push({ name: key, messages: after.map((e) => ({ ...e })) })
       }
-      if (res.length) return res
+      if (res.length) {
+        b().idleReads++
+        return res
+      }
       await sleep(5)
+      b().idleReads++
       return null
     },
     set: async (key: string, val: string, opts?: { NX?: boolean }) => {
@@ -155,7 +161,8 @@ describe('FileDocStore', () => {
       failXAdd: 0,
       readerClosed: false,
       reads: 0,
-      readTimes: [],
+      failedReadTimes: [],
+      idleReads: 0,
       connects: 0,
     }
     stores = []
@@ -201,42 +208,46 @@ describe('FileDocStore', () => {
     const doc = new Y.Doc()
     await store.attachRoom(NAME, doc)
 
-    // Build a streak of two failures. Waited for rather than slept through: on a loaded machine a
-    // fixed window can pass with fewer failures than the streak this test needs.
+    // Build a streak of two failures (the retries back off ~0.5s, then ~1s).
     state.backing!.readerClosed = true
-    const beforeStreak = state.backing!.reads
-    await vi.waitFor(() => expect(state.backing!.reads).toBeGreaterThanOrEqual(beforeStreak + 2), {
-      timeout: 5000,
-      interval: 25,
-    })
+    await vi.waitFor(
+      () => expect(state.backing!.failedReadTimes.length).toBeGreaterThanOrEqual(2),
+      {
+        timeout: 5000,
+        interval: 25,
+      }
+    )
 
-    // Redis comes back. Wait for a read to actually LAND — `xRead` only throws while the reader is
-    // closed, so the next one to arrive is the idle read whose return ends the streak. Sleeping a
-    // fixed 1s instead lets a slow machine finish the window with the pending backoff still
-    // outstanding, leaving the streak alive and the assertion below measuring a delay this test
-    // never meant to produce.
+    // Redis comes back. Wait for a read to actually RETURN — waiting a fixed span instead is a race:
+    // the pending backoff can outlast it, no idle read lands, and the streak survives into the phase
+    // below, which then measures the wrong backoff and fails. That is an event, so wait on the event.
     state.backing!.readerClosed = false
-    const beforeIdle = state.backing!.reads
-    await vi.waitFor(() => expect(state.backing!.reads).toBeGreaterThan(beforeIdle), {
+    const idleBefore = state.backing!.idleReads
+    await vi.waitFor(() => expect(state.backing!.idleReads).toBeGreaterThan(idleBefore), {
       timeout: 5000,
       interval: 25,
     })
 
     // A fresh blip must retry at the START of the backoff curve, not partway up it. Assert the DELAY
     // itself: counting attempts inside a fixed window cannot tell the two apart, because the jittered
     // delay for a carried streak (1.6–2.4s) overlaps any window wide enough to catch a reset one.
+    // Measure FAILURE to FAILURE so the sample is exactly one backoff — a straggler successful read
+    // landing just after the flag flips would otherwise become the first sample and pass trivially.
     state.backing!.readerClosed = true
-    state.backing!.readTimes.length = 0
-    await vi.waitFor(() => expect(state.backing!.readTimes.length).toBeGreaterThanOrEqual(2), {
-      timeout: 5000,
-      interval: 50,
-    })
-    const [first, second] = state.backing!.readTimes
+    state.backing!.failedReadTimes.length = 0
+    await vi.waitFor(
+      () => expect(state.backing!.failedReadTimes.length).toBeGreaterThanOrEqual(2),
+      {
+        timeout: 6000,
+        interval: 25,
+      }
+    )
+    const [first, second] = state.backing!.failedReadTimes
 
-    // Streak reset ⇒ the first delay is 500ms ±20% ⇒ 400–600ms. Streak carried over ⇒ it is the third
-    // delay, 2000ms ±20% ⇒ 1600–2400ms. Disjoint ranges, so this cannot pass on the wrong one without
-    // the machine stalling the shorter sleep by 65%.
-    expect(second - first).toBeLessThan(1000)
+    // Streak reset ⇒ the first delay is 500ms ±20% ⇒ at most 600ms. Streak carried over ⇒ it is the
+    // third delay, 2000ms ±20% ⇒ at least 1600ms. The bound sits between them with room on both
+    // sides, so a loaded machine stretching the short sleep does not flip the verdict.
+    expect(second - first).toBeLessThan(1200)
     doc.destroy()
   })
 

apps/sim/app/api/v2/audit-logs/route.test.ts

@@ -179,6 +179,55 @@ describe('v2 audit-log routes', () => {
     })
   })
 
+  /**
+   * `resourceType` is split into an `inArray` downstream, so its spelling is a
+   * set the query acts on rather than the exact string the caller sent. The
+   * cursor must bind the members, not the text.
+   */
+  it.each([
+    ['reordered', 'workflow,file'],
+    ['respaced', 'file,%20workflow'],
+    ['repeated', 'file,workflow,file'],
+  ])('resumes a cursor whose resourceType set is %s', async (_label, respelled) => {
+    const minted = await listLogs(
+      new NextRequest(
+        'http://localhost:3000/api/v2/audit-logs?organizationId=org-1&resourceType=file,workflow'
+      )
+    )
+    const { nextCursor } = await minted.json()
+    expect(nextCursor).toEqual(expect.any(String))
+
+    mocks.list.mockClear()
+    const resumed = await listLogs(
+      new NextRequest(
+        `http://localhost:3000/api/v2/audit-logs?organizationId=org-1&resourceType=${respelled}&cursor=${encodeURIComponent(nextCursor)}`
+      )
+    )
+
+    expect(resumed.status).toBe(200)
+    expect(mocks.list).toHaveBeenCalled()
+  })
+
+  it('still refuses a cursor replayed under a different resourceType set', async () => {
+    const minted = await listLogs(
+      new NextRequest(
+        'http://localhost:3000/api/v2/audit-logs?organizationId=org-1&resourceType=file,workflow'
+      )
+    )
+    const { nextCursor } = await minted.json()
+
+    mocks.list.mockClear()
+    const replayed = await listLogs(
+      new NextRequest(
+        `http://localhost:3000/api/v2/audit-logs?organizationId=org-1&resourceType=file,knowledge&cursor=${encodeURIComponent(nextCursor)}`
+      )
+    )
+
+    expect(replayed.status).toBe(400)
+    expect((await replayed.json()).error.message).toBe(REFILTERED_CURSOR_MESSAGE)
+    expect(mocks.list).not.toHaveBeenCalled()
+  })
+
   it('projects typed admin-policy failures without leaking internals', async () => {
     mocks.list.mockRejectedValueOnce(new OrchestrationError('forbidden', 'Admin required'))
 

apps/sim/app/api/v2/audit-logs/route.ts

@@ -1,5 +1,5 @@
 import { v2ListAuditLogsContract } from '@/lib/api/contracts/v2/audit-logs'
-import { cursorScopeKey, instantScopePart } from '@/lib/api/cursor-binding'
+import { cursorScopeKey, instantScopePart, unorderedScopePart } from '@/lib/api/cursor-binding'
 import {
   defineV2JsonRoute,
   v2ApiKeyAuth,
@@ -27,7 +27,7 @@ function auditLogCursorFilters(query: {
     organizationId: query.organizationId,
     includeDeparted: query.includeDeparted,
     action: query.action,
-    resourceType: query.resourceType,
+    resourceType: unorderedScopePart(query.resourceType),
     resourceId: query.resourceId,
     workspaceId: query.workspaceId,
     actorEmail: query.actorEmail,

apps/sim/app/api/v2/uploads/[uploadId]/parts/[partNumber]/route.ts

@@ -12,12 +12,7 @@ import {
   type UploadSessionRecord,
   verifyUploadSessionToken,
 } from '@/lib/uploads/upload-session/service'
-import {
-  v2Error,
-  v2HttpError,
-  v2UploadDataPlaneError,
-  v2ValidationError,
-} from '@/app/api/v2/lib/response'
+import { v2Error, v2HttpError, v2UploadDataPlaneError } from '@/app/api/v2/lib/response'
 
 interface LocalPartRouteParams {
   params: Promise<{ uploadId: string; partNumber: string }>

apps/sim/app/api/v2/uploads/[uploadId]/route.ts

@@ -8,12 +8,7 @@ import {
   getOwnedUploadSession,
   uploadSessionObjectMetadata,
 } from '@/lib/uploads/upload-session/service'
-import {
-  v2Error,
-  v2HttpError,
-  v2UploadDataPlaneError,
-  v2ValidationError,
-} from '@/app/api/v2/lib/response'
+import { v2Error, v2HttpError, v2UploadDataPlaneError } from '@/app/api/v2/lib/response'
 
 interface LocalPutRouteParams {
   params: Promise<{ uploadId: string }>

apps/sim/app/api/v2/workflows/[id]/runs/route.test.ts

@@ -28,7 +28,7 @@ vi.mock('@/lib/workflows/application/list-workflow-runs', () => ({
   },
 }))
 
-import { REFILTERED_CURSOR_MESSAGE } from '@/lib/api/cursor-binding'
+import { REFILTERED_CURSOR_MESSAGE, UNREADABLE_CURSOR_MESSAGE } from '@/lib/api/cursor-binding'
 import { NoWorkspaceAccessError, PersonalApiKeysDisabledError } from '@/lib/core/application'
 import { GET } from '@/app/api/v2/workflows/[id]/runs/route'
 
@@ -170,6 +170,35 @@ describe('GET /api/v2/workflows/[id]/runs', () => {
     expect(mocks.listRuns).not.toHaveBeenCalled()
   })
 
+  /**
+   * This list orders by the single `order` param — its query schema is
+   * `.strict()` and declares no `sortBy` — so the sort-mismatch wording would
+   * answer one 400 with advice that earns a second.
+   */
+  it('names a cursor with unusable keys unreadable rather than blaming sortBy', async () => {
+    mocks.listRuns.mockResolvedValueOnce({
+      data: EXECUTIONS,
+      nextCursor: { startedAt: EXECUTIONS[1].startedAt, rowId: 'row-1' },
+      workflowId: 'workflow-1',
+      order: 'desc',
+    })
+
+    const { nextCursor } = await (await callGet()).json()
+    const payload = JSON.parse(Buffer.from(nextCursor, 'base64').toString())
+    const tampered = Buffer.from(
+      JSON.stringify({ ...payload, keys: ['not-a-date', 'row-1'] })
+    ).toString('base64')
+
+    mocks.listRuns.mockClear()
+    const response = await callGet(`?cursor=${encodeURIComponent(tampered)}`)
+
+    expect(response.status).toBe(400)
+    const { error } = await response.json()
+    expect(error.message).toBe(UNREADABLE_CURSOR_MESSAGE)
+    expect(error.message).not.toMatch(/sortBy/)
+    expect(mocks.listRuns).not.toHaveBeenCalled()
+  })
+
   it('rejects an invalid cursor after API-key admission without calling the use case', async () => {
     const response = await callGet('?cursor=not-a-cursor')
 

apps/sim/app/api/v2/workflows/[id]/runs/route.ts

@@ -3,8 +3,11 @@ import {
   v2ListWorkflowRunsContract,
   v2WorkflowRunListStatusValueSchema,
 } from '@/lib/api/contracts/v2/workflows'
-import { cursorScopeKey, instantScopePart } from '@/lib/api/cursor-binding'
-import { INVALID_CURSOR_MESSAGE } from '@/lib/api/list-query'
+import {
+  cursorScopeKey,
+  instantScopePart,
+  UNREADABLE_CURSOR_MESSAGE,
+} from '@/lib/api/cursor-binding'
 import { defineV2JsonRoute, v2ApiKeyAuth, v2RateLimits } from '@/lib/api/server/routes'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { v2WorkflowErrorPolicies } from '@/lib/workflows/api'
@@ -53,7 +56,7 @@ export const GET = defineV2JsonRoute({
         Number.isNaN(cursorDate.getTime()) ||
         typeof cursorRowId !== 'string')
     ) {
-      throw new OrchestrationError('validation', INVALID_CURSOR_MESSAGE)
+      throw new OrchestrationError('validation', UNREADABLE_CURSOR_MESSAGE)
     }
 
     return {