fix(managed-agent): correct truncation flag, gate lookup, custom tool result

- `truncated` was true whenever the history size equalled the limit, even
  though nothing was dropped. Event reads now report the untrimmed total and
  the flag compares against that.
- Pending-gate enrichment capped its read, which keeps the OLDEST events in
  page order — the opposite of where blocking gates live. It now filters to
  the ids being looked up as pages arrive, which is both correct regardless
  of page order and bounded by the id count. Paging continues on the raw
  page so a fully-filtered page is not mistaken for the end of the list.
- Respond To Custom Tool applied one result to every id, so multiple pending
  tools would all receive the same output. It now answers a single call per
  invocation.

Author: waleedlatif1

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

@@ -216,7 +216,7 @@ Return the result of a custom tool a Managed Agent session is waiting on so it c
 
 | Parameter | Type | Required | Description |
 | --------- | ---- | -------- | ----------- |
-| `customToolUseIds` | array | Yes | Custom tool-use EVENT ids, from Get Session pendingTools\[\].id where kind is 'custom_tool_result'. |
+| `customToolUseId` | string | Yes | The custom tool-use EVENT id being answered, from Get Session pendingTools\[\].id where kind is 'custom_tool_result'. |
 | `result` | string | Yes | The tool's output, returned to the agent as text. |
 | `isError` | boolean | No | Mark the result as a failure so the agent can adjust its approach. |
 
@@ -225,7 +225,7 @@ Return the result of a custom tool a Managed Agent session is waiting on so it c
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `sessionId` | string | The session that was answered. |
-| `answeredToolUseIds` | json | The custom tool-use event ids that were answered. |
+| `answeredToolUseId` | string | The custom tool-use event id that was answered. |
 
 ### `managed_agent_archive_session`
 

apps/sim/blocks/blocks/managed_agent.test.ts

@@ -160,8 +160,8 @@ describe('Managed Agent block — per-operation field visibility', () => {
     // not share inputs — otherwise a workflow can silently answer the wrong way.
     expect(isVisible('toolUseIds', { operation: 'respond_tool_confirmation' })).toBe(true)
     expect(isVisible('toolUseIds', { operation: 'respond_custom_tool' })).toBe(false)
-    expect(isVisible('customToolUseIds', { operation: 'respond_custom_tool' })).toBe(true)
-    expect(isVisible('customToolUseIds', { operation: 'respond_tool_confirmation' })).toBe(false)
+    expect(isVisible('customToolUseId', { operation: 'respond_custom_tool' })).toBe(true)
+    expect(isVisible('customToolUseId', { operation: 'respond_tool_confirmation' })).toBe(false)
     expect(isVisible('result', { operation: 'respond_custom_tool' })).toBe(true)
     expect(isVisible('decision', { operation: 'respond_custom_tool' })).toBe(false)
   })

apps/sim/blocks/blocks/managed_agent.ts

@@ -7,6 +7,7 @@ import {
   buildSessionCreatePayload,
   deleteSession,
   listSessionEvents,
+  listSessionEventsPage,
   parseSessionSnapshot,
   resolvePendingToolGates,
   sendCustomToolResults,
@@ -480,6 +481,53 @@ describe('resolvePendingToolGates', () => {
     expect(gates[0]).toEqual({ id: 'sevt_1' })
   })
 
+  it('finds a gate that lives past the first page', async () => {
+    // Gates are the most RECENT tool calls. A read that capped instead of
+    // filtering would keep page 1 and miss exactly the events that matter.
+    let page = 0
+    global.fetch = vi.fn(async () => {
+      const offset = page * 100
+      page += 1
+      const data = Array.from({ length: 100 }, (_, i) => ({
+        id: `t${offset + i}`,
+        type: 'agent.tool_use',
+        name: `tool_${offset + i}`,
+      }))
+      return Response.json({ data, next_page: page < 4 ? `c${page}` : null })
+    }) as unknown as typeof fetch
+
+    const gates = await resolvePendingToolGates({
+      apiKey: 'sk-ant-fake',
+      sessionId: 'sesn_1',
+      eventIds: ['t399'],
+    })
+    expect(gates).toEqual([
+      { id: 't399', eventType: 'agent.tool_use', kind: 'confirmation', name: 'tool_399' },
+    ])
+  })
+
+  it('keeps paging when an entire page filters out', async () => {
+    let page = 0
+    const spy = vi.fn(async () => {
+      page += 1
+      // Page 1 holds nothing wanted; the target is only on page 2.
+      const data =
+        page === 1
+          ? [{ id: 'other', type: 'agent.tool_use', name: 'noise' }]
+          : [{ id: 'want', type: 'agent.tool_use', name: 'target' }]
+      return Response.json({ data, next_page: page < 2 ? 'c1' : null })
+    }) as unknown as typeof fetch
+    global.fetch = spy
+
+    const gates = await resolvePendingToolGates({
+      apiKey: 'sk-ant-fake',
+      sessionId: 'sesn_1',
+      eventIds: ['want'],
+    })
+    expect((spy as unknown as ReturnType<typeof vi.fn>).mock.calls).toHaveLength(2)
+    expect(gates[0]?.name).toBe('target')
+  })
+
   it('short-circuits with no ids', async () => {
     const spy = vi.fn() as unknown as typeof fetch
     global.fetch = spy
@@ -538,6 +586,28 @@ describe('listSessionEvents — bounded reads', () => {
     expect(events.at(-1)?.id).toBe('e299')
   })
 
+  it('reports the untrimmed total so a full history is not mistaken for a tail', async () => {
+    // A history of exactly `maxItems` dropped nothing — `total === events.length`
+    // is what lets the caller tell that apart from a genuinely capped read.
+    global.fetch = pagedFetch(3)
+    const exact = await listSessionEventsPage({
+      apiKey: 'sk-ant-fake',
+      sessionId: 'sesn_1',
+      maxItems: 300,
+    })
+    expect(exact.events).toHaveLength(300)
+    expect(exact.total).toBe(300)
+
+    global.fetch = pagedFetch(3)
+    const capped = await listSessionEventsPage({
+      apiKey: 'sk-ant-fake',
+      sessionId: 'sesn_1',
+      maxItems: 120,
+    })
+    expect(capped.events).toHaveLength(120)
+    expect(capped.total).toBe(300)
+  })
+
   it('returns the whole history when uncapped', async () => {
     global.fetch = pagedFetch(3)
     const events = await listSessionEvents({ apiKey: 'sk-ant-fake', sessionId: 'sesn_1' })

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

@@ -375,9 +375,6 @@ function gateKindFor(eventType: string | undefined): PendingToolGateKind | undef
   return undefined
 }
 
-/** Upper bound on tool-use events scanned when naming pending gates. */
-const MAX_GATE_LOOKUP_EVENTS = 2000
-
 /** Event types that can block a session pending a client response. */
 const TOOL_USE_EVENT_TYPES = [
   'agent.tool_use',
@@ -405,10 +402,12 @@ export async function resolvePendingToolGates(
       ...(input.signal ? { signal: input.signal } : {}),
       path: `/v1/sessions/${input.sessionId}/events`,
       searchParams: TOOL_USE_EVENT_TYPES.map((type): [string, string] => ['types[]', type]),
-      // Bounded: this only needs to find a handful of ids, and an unbounded read
-      // of a long session's tool history is a needless memory cost. An id that
-      // falls outside the window still comes back unenriched, which is usable.
-      maxItems: MAX_GATE_LOOKUP_EVENTS,
+      // Keep only the events actually being looked up rather than capping the
+      // read. A cap would retain the OLDEST page-order events, and blocking
+      // gates are by definition the most recent tool calls — exactly the ones a
+      // 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)),
     })
   } catch {
     // Enrichment is best-effort — fall through to bare ids below.
@@ -497,6 +496,13 @@ async function listPaginated<T>(
     maxItems?: number
     /** Extra repeatable query pairs (e.g. `types[]` filters). */
     searchParams?: Array<[string, string]>
+    /**
+     * Applied per item as pages arrive, so only matches are retained. Use this
+     * instead of `maxItems` when the caller needs specific items rather than a
+     * prefix — a cap keeps whatever the API returned first, which is the oldest
+     * entries on a chronological endpoint.
+     */
+    filter?: (item: T) => boolean
   }
 ): Promise<T[]> {
   const collected: T[] = []
@@ -521,7 +527,9 @@ async function listPaginated<T>(
     }
     const body = (await resp.json()) as AnthropicListPage<T>
     const items = Array.isArray(body.data) ? body.data : []
-    collected.push(...items)
+    collected.push(...(input.filter ? items.filter(input.filter) : items))
+    // 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
     page = body.next_page
   }
@@ -556,6 +564,28 @@ export async function listSessionEvents(
     maxItems?: number
   }
 ): Promise<AnthropicSessionEvent[]> {
+  return (await listSessionEventsPage(input)).events
+}
+
+/** An event read plus the size of the history it was taken from. */
+export interface SessionEventPage {
+  events: AnthropicSessionEvent[]
+  /**
+   * How many events the session actually has, before any cap. Compare against
+   * `events.length` to tell a capped read from a complete one — a history that
+   * happens to be exactly `maxItems` long has dropped nothing.
+   */
+  total: number
+}
+
+/**
+ * Same read as {@link listSessionEvents}, but also reports the untrimmed
+ * history size so callers can distinguish "this is a tail" from "this is
+ * everything, and it happens to be exactly the cap".
+ */
+export async function listSessionEventsPage(
+  input: SessionAuth & { sessionId: string; types?: string[]; maxItems?: number }
+): Promise<SessionEventPage> {
   const types = (input.types ?? []).filter((type) => type.trim().length > 0)
   const events = await listPaginated<AnthropicSessionEvent>({
     apiKey: input.apiKey,
@@ -574,10 +604,14 @@ export async function listSessionEvents(
   const ordered = events.sort(
     (a, b) => parseProcessedAt(a.processed_at) - parseProcessedAt(b.processed_at)
   )
+  const total = ordered.length
   const maxItems = input.maxItems
   // Slice AFTER ordering so the cap is "the newest N", independent of the order
   // the API returned pages in.
-  return maxItems !== undefined && ordered.length > maxItems ? ordered.slice(-maxItems) : ordered
+  return {
+    events: maxItems !== undefined && total > maxItems ? ordered.slice(-maxItems) : ordered,
+    total,
+  }
 }
 
 /** Epoch millis for a `processed_at`, or +Infinity when absent/queued/unparseable (sorts last). */

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

@@ -1,5 +1,5 @@
 import { getErrorMessage } from '@sim/utils/errors'
-import { listSessionEvents } from '@/lib/managed-agents/session-client'
+import { listSessionEventsPage } from '@/lib/managed-agents/session-client'
 import { normalizeStringList } from '@/tools/managed_agent/normalizers'
 import {
   ACCESS_TOKEN_PARAM,
@@ -86,7 +86,7 @@ export const managedAgentListEventsTool: ToolConfig<
       Number.isFinite(requested) && requested > 0 ? Math.floor(requested) : DEFAULT_EVENT_LIMIT
 
     try {
-      const events = await listSessionEvents({
+      const { events, total } = await listSessionEventsPage({
         apiKey: target.apiKey,
         sessionId: target.sessionId,
         maxItems,
@@ -111,9 +111,10 @@ export const managedAgentListEventsTool: ToolConfig<
           events,
           count: events.length,
           assistantText,
-          // Signals that older events were dropped, so a caller reading history
-          // knows this is a tail rather than the whole session.
-          truncated: events.length >= maxItems,
+          // Compared against the untrimmed history size, not the limit: a
+          // session holding exactly `maxItems` events dropped nothing and must
+          // not be reported as a partial read.
+          truncated: total > events.length,
         },
       }
     } catch (error) {

apps/sim/tools/managed_agent/list_events.ts

@@ -1,6 +1,6 @@
 import { getErrorMessage } from '@sim/utils/errors'
 import { sendCustomToolResults } from '@/lib/managed-agents/session-client'
-import { isTruthyAck, normalizeStringList } from '@/tools/managed_agent/normalizers'
+import { isTruthyAck } from '@/tools/managed_agent/normalizers'
 import {
   ACCESS_TOKEN_PARAM,
   CREDENTIAL_PARAM,
@@ -22,6 +22,11 @@ import type { ToolConfig } from '@/tools/types'
  * A permission confirmation does NOT unblock these — that is a different event
  * for a different kind of gate. `managed_agent_get_session` labels each pending
  * gate with `kind`, so a workflow can route to the right operation.
+ *
+ * Deliberately answers ONE call per invocation. Each pending custom tool has
+ * its own output, so accepting a list here would force every one of them to
+ * share a single result — silently wrong whenever more than one is pending.
+ * Answer several by iterating this operation over `pendingTools`.
  */
 export const managedAgentRespondCustomToolTool: ToolConfig<
   ManagedAgentCustomToolResultParams,
@@ -37,12 +42,12 @@ export const managedAgentRespondCustomToolTool: ToolConfig<
     credential: CREDENTIAL_PARAM,
     accessToken: ACCESS_TOKEN_PARAM,
     sessionId: SESSION_ID_PARAM,
-    customToolUseIds: {
-      type: 'array',
+    customToolUseId: {
+      type: 'string',
       required: true,
       visibility: 'user-or-llm',
       description:
-        "Custom tool-use EVENT ids, from Get Session pendingTools[].id where kind is 'custom_tool_result'.",
+        "The custom tool-use EVENT id being answered, from Get Session pendingTools[].id where kind is 'custom_tool_result'.",
     },
     result: {
       type: 'string',
@@ -61,41 +66,37 @@ export const managedAgentRespondCustomToolTool: ToolConfig<
   request: UNUSED_REQUEST,
 
   directExecution: async (params, signal): Promise<ManagedAgentCustomToolResultResponse> => {
-    const emptyOutput = { sessionId: '', answeredToolUseIds: [] as string[] }
+    const emptyOutput = { sessionId: '', answeredToolUseId: '' }
     const target = resolveSessionTarget(params)
     if (!target.ok) {
       return { success: false, output: emptyOutput, error: target.error }
     }
 
-    const customToolUseIds = normalizeStringList(params.customToolUseIds)
-    if (customToolUseIds.length === 0) {
+    const customToolUseId = params.customToolUseId?.trim()
+    if (!customToolUseId) {
       return {
         success: false,
         output: { ...emptyOutput, sessionId: target.sessionId },
         error:
-          'At least one custom tool-use event id is required. Read them from Get Session pendingTools[].id.',
+          'A custom tool-use event id is required. Read it from Get Session pendingTools[].id.',
       }
     }
 
     // The result may legitimately be empty (a tool that returns nothing), so
-    // only the id list is required — an absent result is sent as an empty string.
+    // only the id is required — an absent result is sent as an empty string.
     const result = (params.result ?? '').toString()
     const isError = isTruthyAck(params.isError)
 
     try {
       await sendCustomToolResults({
         apiKey: target.apiKey,
         sessionId: target.sessionId,
-        results: customToolUseIds.map((customToolUseId) => ({
-          customToolUseId,
-          content: result,
-          isError,
-        })),
+        results: [{ customToolUseId, content: result, isError }],
         ...(signal ? { signal } : {}),
       })
       return {
         success: true,
-        output: { sessionId: target.sessionId, answeredToolUseIds: customToolUseIds },
+        output: { sessionId: target.sessionId, answeredToolUseId: customToolUseId },
       }
     } catch (error) {
       return {
@@ -108,9 +109,9 @@ export const managedAgentRespondCustomToolTool: ToolConfig<
 
   outputs: {
     sessionId: { type: 'string', description: 'The session that was answered.' },
-    answeredToolUseIds: {
-      type: 'json',
-      description: 'The custom tool-use event ids that were answered.',
+    answeredToolUseId: {
+      type: 'string',
+      description: 'The custom tool-use event id that was answered.',
     },
   },
 }

apps/sim/tools/managed_agent/respond_custom_tool.ts

@@ -146,16 +146,16 @@ export interface ManagedAgentToolConfirmationResponse extends ToolResponse {
 }
 
 export interface ManagedAgentCustomToolResultParams extends ManagedAgentSessionOpParams {
-  /** Blocking custom tool-use EVENT ids (array, JSON string, or comma list). */
-  customToolUseIds?: unknown
+  /** The blocking custom tool-use EVENT id being answered. */
+  customToolUseId?: string
   /** The tool's output, returned to the agent. */
   result?: string
   /** Marks the result as a failure. */
   isError?: boolean | string
 }
 
 export interface ManagedAgentCustomToolResultResponse extends ToolResponse {
-  output: { sessionId: string; answeredToolUseIds: string[] }
+  output: { sessionId: string; answeredToolUseId: string }
 }
 
 export interface ManagedAgentArchiveSessionParams extends ManagedAgentSessionOpParams {}