fix(managed-agent): stop gate lookup scanning the full tool history

The id filter keeps the collected array tiny, so `maxItems` never trips and
the walk continued to the end of a session's tool history even after every
blocking id had been found. `listPaginated` now takes a `stopWhen` predicate
and the gate lookup ends as soon as it has all the ids it came for.

Also makes a blocked-but-unnamed session observable: when a session reports
`requires_action` with no blocking event ids, `requiresAction` stays true —
reporting false would tell a workflow the session is fine while it is parked
indefinitely — and the dead end is logged and documented instead.

Author: waleedlatif1

apps/docs/content/docs/en/integrations/managed_agent.mdx

@@ -124,7 +124,7 @@ Read a Managed Agent session: status, stop reason, token usage, metadata, and an
 | `sessionId` | string | The session that was read. |
 | `status` | string | Session status — 'idle', 'running', 'rescheduling', or 'terminated'. |
 | `stopReason` | string | Why the session last stopped, e.g. 'end_turn' or 'requires_action'. |
-| `requiresAction` | boolean | True when the session is waiting on a tool confirmation or custom tool result. |
+| `requiresAction` | boolean | True when the session is waiting on a tool confirmation or custom tool result. If this is true while pendingTools is empty, the session is blocked but the API named no blocking events — surface it rather than treating the session as done. |
 | `pendingTools` | json | Blocking tool calls — \[\{id, eventType, kind, name, input\}\]. Route by kind: 'confirmation' ids go to Respond To Tool Confirmation, 'custom_tool_result' ids go to Respond To Custom Tool. |
 | `metadata` | json | Session metadata. |
 | `title` | string | Session title. |

apps/sim/lib/managed-agents/session-client.test.ts

@@ -528,6 +528,28 @@ describe('resolvePendingToolGates', () => {
     expect(gates[0]?.name).toBe('target')
   })
 
+  it('stops paging as soon as every wanted id is found', async () => {
+    // The filter keeps `collected` tiny, so no cap can ever trip — without an
+    // explicit stop the walk runs to the end of the tool history for nothing.
+    let page = 0
+    const spy = vi.fn(async () => {
+      page += 1
+      return Response.json({
+        data: [{ id: page === 1 ? 'want' : `other${page}`, type: 'agent.tool_use', name: 'x' }],
+        next_page: `c${page}`, // never null: only the stop condition ends this
+      })
+    }) as unknown as typeof fetch
+    global.fetch = spy
+
+    const gates = await resolvePendingToolGates({
+      apiKey: 'sk-ant-fake',
+      sessionId: 'sesn_1',
+      eventIds: ['want'],
+    })
+    expect(gates).toHaveLength(1)
+    expect((spy as unknown as ReturnType<typeof vi.fn>).mock.calls).toHaveLength(1)
+  })
+
   it('short-circuits with no ids', async () => {
     const spy = vi.fn() as unknown as typeof fetch
     global.fetch = spy

apps/sim/lib/managed-agents/session-client.ts

@@ -408,6 +408,10 @@ export async function resolvePendingToolGates(
       // cap would drop. Filtering instead bounds memory to the id count while
       // staying correct however the API orders its pages.
       filter: (event) => Boolean(event.id && wanted.has(event.id)),
+      // Every wanted id is found at most once, so once the count matches there
+      // is nothing left to look for. Without this the filtered total never
+      // reaches any cap and the walk runs to the end of the tool history.
+      stopWhen: (found) => found.length >= wanted.size,
     })
   } catch {
     // Enrichment is best-effort — fall through to bare ids below.
@@ -503,6 +507,13 @@ async function listPaginated<T>(
      * entries on a chronological endpoint.
      */
     filter?: (item: T) => boolean
+    /**
+     * Checked after each page against everything collected so far. Lets a
+     * filtered read stop as soon as it has what it came for — otherwise
+     * `maxItems` never trips (the filtered total stays small) and the walk runs
+     * to the end of the history for nothing.
+     */
+    stopWhen?: (collected: T[]) => boolean
   }
 ): Promise<T[]> {
   const collected: T[] = []
@@ -528,6 +539,7 @@ async function listPaginated<T>(
     const body = (await resp.json()) as AnthropicListPage<T>
     const items = Array.isArray(body.data) ? body.data : []
     collected.push(...(input.filter ? items.filter(input.filter) : items))
+    if (input.stopWhen?.(collected)) break
     // Paging continues on the RAW page, not the filtered result: a page whose
     // every item was filtered out is not the end of the list.
     if (!body.next_page || items.length === 0) break

apps/sim/tools/managed_agent/get_session.ts

@@ -1,3 +1,4 @@
+import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
 import { resolvePendingToolGates, retrieveSession } from '@/lib/managed-agents/session-client'
 import {
@@ -14,6 +15,8 @@ import type {
 } from '@/tools/managed_agent/types'
 import type { ToolConfig } from '@/tools/types'
 
+const logger = createLogger('ManagedAgentGetSession')
+
 /** `stop_reason.type` meaning the session is parked awaiting a client response. */
 const REQUIRES_ACTION = 'requires_action'
 
@@ -79,6 +82,17 @@ export const managedAgentGetSessionTool: ToolConfig<
             })
           : []
 
+      // A blocked session that names no blocking events is an anomaly: it waits
+      // indefinitely, but nothing here can say for what. `requiresAction` stays
+      // true because that is the truth — reporting false would tell a workflow
+      // the session is fine while it is parked forever — so log it instead, so
+      // the dead end is visible rather than silent.
+      if (requiresAction && pendingTools.length === 0) {
+        logger.warn('Managed Agent session requires action but reported no blocking event ids', {
+          sessionId: target.sessionId,
+        })
+      }
+
       return {
         success: true,
         output: {
@@ -119,7 +133,8 @@ export const managedAgentGetSessionTool: ToolConfig<
     },
     requiresAction: {
       type: 'boolean',
-      description: 'True when the session is waiting on a tool confirmation or custom tool result.',
+      description:
+        'True when the session is waiting on a tool confirmation or custom tool result. If this is true while pendingTools is empty, the session is blocked but the API named no blocking events — surface it rather than treating the session as done.',
     },
     pendingTools: {
       type: 'json',