fix(managed-agent): stop fractional event limits reading unbounded

A limit below 1 passed the positivity check and then floored to 0, which
made `slice(-0)` hand back the ENTIRE history flagged as complete — the
opposite of the requested bound. The limit is now floored before it is
validated, so anything that does not resolve to a positive integer falls
back to the default.

Also hardened the library: a zero or negative cap short-circuits to an
empty result instead of falling through to `slice(-0)`, so no future
caller can hit the same trap.

Author: waleedlatif1

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

@@ -608,6 +608,27 @@ describe('listSessionEvents — bounded reads', () => {
     expect(capped.total).toBe(300)
   })
 
+  it('never returns the whole history for a zero or negative cap', async () => {
+    // `slice(-0)` is `slice(0)` — the entire array — so a zero cap must
+    // short-circuit rather than silently become an unbounded read.
+    global.fetch = pagedFetch(1)
+    const zero = await listSessionEventsPage({
+      apiKey: 'sk-ant-fake',
+      sessionId: 'sesn_1',
+      maxItems: 0,
+    })
+    expect(zero.events).toHaveLength(0)
+    expect(zero.total).toBe(100)
+
+    global.fetch = pagedFetch(1)
+    const negative = await listSessionEventsPage({
+      apiKey: 'sk-ant-fake',
+      sessionId: 'sesn_1',
+      maxItems: -5,
+    })
+    expect(negative.events).toHaveLength(0)
+  })
+
   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.ts

@@ -606,12 +606,14 @@ export async function listSessionEventsPage(
   )
   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 {
-    events: maxItems !== undefined && total > maxItems ? ordered.slice(-maxItems) : ordered,
-    total,
+  if (maxItems === undefined || Number.isNaN(maxItems) || total <= maxItems) {
+    return { events: ordered, total }
   }
+  // Slice AFTER ordering so the cap is "the newest N", independent of the order
+  // the API returned pages in. A zero or negative cap short-circuits because
+  // `slice(-0)` is `slice(0)` — it would hand back the ENTIRE history for what
+  // the caller asked to be the tightest possible bound.
+  return { events: maxItems <= 0 ? [] : ordered.slice(-maxItems), total }
 }
 
 /** Epoch millis for a `processed_at`, or +Infinity when absent/queued/unparseable (sorts last). */

apps/sim/tools/managed_agent/list_events.test.ts

@@ -0,0 +1,62 @@
+/**
+ * @vitest-environment node
+ */
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { managedAgentListEventsTool } from '@/tools/managed_agent/list_events'
+
+const originalFetch = global.fetch
+afterEach(() => {
+  global.fetch = originalFetch
+})
+
+/** One page of `count` events, no next page. */
+const historyOf = (count: number) =>
+  vi.fn(async () =>
+    Response.json({
+      data: Array.from({ length: count }, (_, i) => ({
+        id: `e${i}`,
+        type: 'agent.message',
+        processed_at: new Date(Date.UTC(2026, 0, 1) + i * 1000).toISOString(),
+        content: [{ type: 'text', text: `m${i}` }],
+      })),
+      next_page: null,
+    })
+  ) as unknown as typeof fetch
+
+const run = (limit: unknown) =>
+  managedAgentListEventsTool.directExecution!(
+    { credential: 'c', accessToken: 'sk-ant-fake', sessionId: 'sesn_1', limit } as never,
+    undefined
+  )
+
+describe('managed_agent_list_events — limit handling', () => {
+  it.each([0.5, 0, -1, Number.NaN, 'abc', null, undefined])(
+    'falls back to the 500 default for the invalid limit %p rather than reading unbounded',
+    async (limit) => {
+      global.fetch = historyOf(600)
+      const res = (await run(limit)) as { output: { count: number; truncated: boolean } }
+      expect(res.output.count).toBe(500)
+      expect(res.output.truncated).toBe(true)
+    }
+  )
+
+  it('honors a valid limit and keeps the newest events', async () => {
+    global.fetch = historyOf(50)
+    const res = (await run(10)) as {
+      output: { count: number; truncated: boolean; assistantText: string }
+    }
+    expect(res.output.count).toBe(10)
+    expect(res.output.truncated).toBe(true)
+    // Newest ten are m40..m49, concatenated in chronological order.
+    expect(res.output.assistantText).toBe(
+      Array.from({ length: 10 }, (_, i) => `m${40 + i}`).join('')
+    )
+  })
+
+  it('reports a complete history as not truncated even at exactly the limit', async () => {
+    global.fetch = historyOf(10)
+    const res = (await run(10)) as { output: { count: number; truncated: boolean } }
+    expect(res.output.count).toBe(10)
+    expect(res.output.truncated).toBe(false)
+  })
+})

apps/sim/tools/managed_agent/list_events.ts

@@ -79,11 +79,12 @@ export const managedAgentListEventsTool: ToolConfig<
     }
 
     const types = normalizeStringList(params.eventTypes)
-    // A non-numeric or non-positive limit falls back to the default rather than
-    // silently becoming an unbounded (or empty) read.
-    const requested = Number(params.limit)
-    const maxItems =
-      Number.isFinite(requested) && requested > 0 ? Math.floor(requested) : DEFAULT_EVENT_LIMIT
+    // Floor BEFORE the positivity check: a fractional limit like 0.5 would pass
+    // `> 0` and then floor to 0, which reads as "no cap" downstream and returns
+    // the whole history. Anything that does not floor to a positive integer
+    // falls back to the default rather than silently becoming unbounded.
+    const requested = Math.floor(Number(params.limit))
+    const maxItems = Number.isFinite(requested) && requested > 0 ? requested : DEFAULT_EVENT_LIMIT
 
     try {
       const { events, total } = await listSessionEventsPage({