fix(search): preserve byte-only MCP response limits

Author: waleedlatif1

apps/sim/lib/core/utils/bounded-json.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest'
-import { stringifyBoundedJson } from '@/lib/core/utils/bounded-json'
+import { isJsonWithinByteLimit, stringifyBoundedJson } from '@/lib/core/utils/bounded-json'
 
 describe('bounded JSON', () => {
   it.each([
@@ -13,11 +13,14 @@ describe('bounded JSON', () => {
     const bytes = Buffer.byteLength(json, 'utf8')
     expect(stringifyBoundedJson(value, bytes)).toBe(json)
     expect(stringifyBoundedJson(value, bytes - 1)).toBeUndefined()
+    expect(isJsonWithinByteLimit(value, bytes)).toBe(true)
+    expect(isJsonWithinByteLimit(value, bytes - 1)).toBe(false)
   })
 
   it('rejects cycles, excessive depth, and excessive nodes', () => {
     const cyclic: Record<string, unknown> = {}
     cyclic.self = cyclic
+    expect(isJsonWithinByteLimit(cyclic, 1024)).toBe(false)
     let deep: unknown = 'leaf'
     for (let index = 0; index < 66; index++) deep = { child: deep }
     for (const value of [
@@ -37,6 +40,7 @@ describe('bounded JSON', () => {
     const custom = Object.defineProperty({}, 'toJSON', { value: toJSON })
     for (const value of [accessor, custom, { output: new Uint8Array([1, 2, 3]) }]) {
       expect(stringifyBoundedJson(value, 1024)).toBeUndefined()
+      expect(isJsonWithinByteLimit(value, 1024)).toBe(false)
     }
     expect(getter).not.toHaveBeenCalled()
     expect(toJSON).not.toHaveBeenCalled()
@@ -47,6 +51,7 @@ describe('bounded JSON', () => {
     const serialize = vi.spyOn(JSON, 'stringify')
     try {
       expect(stringifyBoundedJson(value, 1024)).toBeUndefined()
+      expect(isJsonWithinByteLimit(value, 1024)).toBe(false)
       expect(serialize).not.toHaveBeenCalled()
     } finally {
       serialize.mockRestore()
@@ -61,6 +66,7 @@ describe('bounded JSON', () => {
     const serialize = vi.spyOn(JSON, 'stringify')
     try {
       expect(stringifyBoundedJson(value, 1024)).toBeUndefined()
+      expect(isJsonWithinByteLimit(value, 1024)).toBe(false)
       expect(serialize).not.toHaveBeenCalled()
     } finally {
       serialize.mockRestore()
@@ -71,6 +77,7 @@ describe('bounded JSON', () => {
     const get = vi.fn(() => 'UNADMITTED')
     const value = new Proxy({ text: 'admitted' }, { get })
     expect(stringifyBoundedJson(value, 1024)).toBe('{"text":"admitted"}')
+    expect(isJsonWithinByteLimit(value, 19)).toBe(true)
     expect(get).not.toHaveBeenCalled()
   })
 
@@ -79,12 +86,21 @@ describe('bounded JSON', () => {
     const prototype = Object.create(Array.prototype, { 0: { get } })
     const value = Object.setPrototypeOf(Array(1), prototype)
     expect(stringifyBoundedJson(value, 1024)).toBe('[null]')
+    expect(isJsonWithinByteLimit(value, 6)).toBe(true)
     expect(get).not.toHaveBeenCalled()
   })
 
   it('allows repeated references without treating them as a cycle', () => {
     const result = { answer: 42 }
     const value = { rawResponse: result, modelResponse: result }
     expect(stringifyBoundedJson(value, 1024)).toBe(JSON.stringify(value))
+    expect(isJsonWithinByteLimit(value, Buffer.byteLength(JSON.stringify(value)))).toBe(true)
+  })
+
+  it('counts an ordinary toJSON data field without invoking custom serialization', () => {
+    const value = { toJSON: 'ordinary JSON field', nested: [{}, [], { flag: true }] }
+    const bytes = Buffer.byteLength(JSON.stringify(value))
+    expect(isJsonWithinByteLimit(value, bytes)).toBe(true)
+    expect(isJsonWithinByteLimit(value, bytes - 1)).toBe(false)
   })
 })

apps/sim/lib/core/utils/bounded-json.ts

@@ -21,6 +21,95 @@ function quotedStringBytes(value: string, remaining: number): number | undefined
   return bytes <= remaining ? bytes : undefined
 }
 
+/** Measures plain JSON iteratively without serialization, copying, or additional node/depth caps. */
+export function isJsonWithinByteLimit(value: unknown, maxBytes: number): boolean {
+  if (!Number.isFinite(maxBytes) || maxBytes < 0 || value === undefined) return false
+  const invalid = Symbol('invalid JSON')
+  const ancestors = new WeakSet<object>()
+  const stack: {
+    value: object
+    entries: Generator<[string | null, unknown]>
+    count: number
+  }[] = []
+  let bytes = 0
+  const omitted = (item: unknown) =>
+    item === undefined || typeof item === 'function' || typeof item === 'symbol'
+  function* entries(container: object): Generator<[string | null, unknown]> {
+    if (Array.isArray(container)) {
+      const length = Object.getOwnPropertyDescriptor(container, 'length')?.value
+      if (typeof length !== 'number') {
+        yield [null, invalid]
+        return
+      }
+      for (let index = 0; index < length; index++) {
+        const field = Object.getOwnPropertyDescriptor(container, index)
+        if (field && !('value' in field)) {
+          yield [null, invalid]
+          return
+        }
+        yield [null, omitted(field?.value) ? null : field?.value]
+      }
+    } else {
+      for (const key in container) {
+        const field = Object.getOwnPropertyDescriptor(container, key)
+        if (!field?.enumerable) continue
+        if (!('value' in field)) {
+          yield [key, invalid]
+          return
+        }
+        if (!omitted(field.value)) yield [key, field.value]
+      }
+    }
+  }
+  try {
+    let item: unknown = value
+    for (;;) {
+      if (typeof item === 'string') {
+        const count = quotedStringBytes(item, maxBytes - bytes)
+        if (count === undefined) return false
+        bytes += count
+      } else if (item === null) bytes += 4
+      else if (typeof item === 'number') bytes += Number.isFinite(item) ? String(item).length : 4
+      else if (typeof item === 'boolean') bytes += item ? 4 : 5
+      else if (typeof item === 'object') {
+        if (ancestors.has(item)) return false
+        const prototype = Object.getPrototypeOf(item)
+        if (!Array.isArray(item) && prototype !== Object.prototype && prototype !== null)
+          return false
+        const serializer = Object.getOwnPropertyDescriptor(item, 'toJSON')
+        if (serializer && (!('value' in serializer) || typeof serializer.value === 'function'))
+          return false
+        bytes += 2
+        ancestors.add(item)
+        stack.push({ value: item, entries: entries(item), count: 0 })
+      } else return false
+      if (bytes > maxBytes) return false
+      for (;;) {
+        const frame = stack[stack.length - 1]
+        if (!frame) return true
+        const next = frame.entries.next()
+        if (next.done) {
+          ancestors.delete(frame.value)
+          stack.pop()
+          continue
+        }
+        if (frame.count++ > 0) bytes++
+        const [key, child] = next.value
+        if (key !== null) {
+          const count = quotedStringBytes(key, maxBytes - bytes)
+          if (count === undefined) return false
+          bytes += count + 1
+        }
+        if (bytes > maxBytes) return false
+        item = child
+        break
+      }
+    }
+  } catch {
+    return false
+  }
+}
+
 /** Captures bounded plain JSON once, without executing accessors or serializing the source graph. */
 export function stringifyBoundedJson(value: unknown, maxBytes: number): string | undefined {
   let nodes = 0

apps/sim/lib/sim-search/live/managed-mcp-payload.ts

@@ -1,13 +1,13 @@
 import { isRecordLike } from '@sim/utils/object'
-import { stringifyBoundedJson } from '@/lib/core/utils/bounded-json'
+import { isJsonWithinByteLimit } from '@/lib/core/utils/bounded-json'
 import type { McpToolResult } from '@/lib/mcp/types'
 import { NativeSearchError } from '@/lib/sim-search/live/http'
 
 const MAX_SEARCH_MCP_PAYLOAD_BYTES = 4 * 1024 * 1024
 
 /** MCP text is untrusted provider data; malformed structured search output is never an empty success. */
 export function managedMcpPayload(result: McpToolResult, label: string): unknown {
-  if (stringifyBoundedJson(result, MAX_SEARCH_MCP_PAYLOAD_BYTES) === undefined)
+  if (!isJsonWithinByteLimit(result, MAX_SEARCH_MCP_PAYLOAD_BYTES))
     throw new NativeSearchError(
       'unavailable',
       `${label} response exceeded the search size limit. Narrow the query.`

apps/sim/lib/sim-search/live/managed-mcp.test.ts

@@ -140,4 +140,17 @@ describe('managed search MCP read boundary', () => {
       serialize.mockRestore()
     }
   })
+
+  it.each(['wide', 'deep'] as const)(
+    'preserves byte-small %s MCP responses without imposing capture limits',
+    (shape) => {
+      let content: unknown = shape === 'wide' ? Array.from({ length: 100_000 }, () => 0) : 'leaf'
+      if (shape === 'deep') {
+        for (let index = 0; index < 128; index++) content = { child: content }
+      }
+      const result = { structuredContent: content }
+      expect(Buffer.byteLength(JSON.stringify(result), 'utf8')).toBeLessThan(4 * 1024 * 1024)
+      expect(managedMcpPayload(result, 'Fireflies')).toEqual(content)
+    }
+  )
 })