CopilotKit
diff --git a/‎CHANGELOG.md‎
Lines changed: 6 additions & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎package.json‎
Lines changed: 1 addition & 1 deletion b/‎package.json‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎src/__tests__/agui-record-buffer-cap.test.ts‎
Lines changed: 186 additions & 0 deletions b/‎src/__tests__/agui-record-buffer-cap.test.ts‎
Lines changed: 186 additions & 0 deletions
diff --git a/‎src/__tests__/stream-collapse-string-cap.test.ts‎
Lines changed: 160 additions & 0 deletions b/‎src/__tests__/stream-collapse-string-cap.test.ts‎
Lines changed: 160 additions & 0 deletions
@@ -1,5 +1,11 @@
 # @copilotkit/aimock
 
+## [1.37.1] - 2026-07-16
+
+### Fixed
+
+- Capped the uncapped in-memory record buffers that could grow a string past V8's ~512 MiB max string length and throw `RangeError: Invalid string length` (the ~1/sec production crash, amplified once the real-key fixture-miss passthrough landed). The AG-UI recorder, the generic recorder, and the stream-collapse path now bound the buffer they `Buffer.concat(chunks).toString()` for fixture construction to a configurable `maxRecordBufferBytes` (default 64 MiB) clamped to a 256 MiB hard ceiling. Once the cap is crossed the recorder frees the buffer, marks the recording truncated, and skips fixture construction — the full upstream response is still relayed to the client byte-for-byte in real time, so capping never truncates what the client receives ("don't journal", not "don't answer") (#307)
+
 ## [1.37.0] - 2026-07-15
 
 ### Added
 
@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/aimock",
-  "version": "1.37.0",
+  "version": "1.37.1",
   "description": "Mock infrastructure for AI application testing — LLM APIs, image generation, image editing, text-to-speech, transcription, audio translation, audio generation, video generation, embeddings, MCP tools, A2A agents, AG-UI event streams, vector databases, search, rerank, and moderation. One package, one port, zero dependencies.",
   "license": "MIT",
   "keywords": [
 
@@ -0,0 +1,186 @@
+import { describe, it, expect, afterEach, vi } from "vitest";
+import * as http from "node:http";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { AGUIMock } from "../agui-mock.js";
+import { setAGUIRecordBufferCeilingForTests } from "../agui-recorder.js";
+import { Logger } from "../logger.js";
+
+// ---------------------------------------------------------------------------
+// AG-UI record-buffer cap.
+//
+// The AG-UI recorder tees every upstream SSE chunk to the client AND buffers a
+// copy so it can `Buffer.concat(chunks).toString()` + parse the events into a
+// fixture once the stream ends. With no cap, a large upstream response builds a
+// string past V8's ~512 MiB max string length and throws
+// `RangeError: Invalid string length` (the ~1/sec prod crash). These tests
+// exercise the REAL proxyAndRecordAGUI/teeUpstreamStream path via a raw local
+// upstream streaming a large SSE body, with a low test-only cap so the run
+// stays fast: the client must still receive every relayed byte, the server must
+// not crash, and recording must be skipped (no fixture written).
+// ---------------------------------------------------------------------------
+
+let upstream: http.Server | undefined;
+let agui: AGUIMock | undefined;
+let tmpDir: string | undefined;
+
+afterEach(async () => {
+  if (agui) {
+    try {
+      await agui.stop();
+    } catch {
+      /* already stopped */
+    }
+    agui = undefined;
+  }
+  if (upstream) {
+    await new Promise<void>((resolve) => upstream!.close(() => resolve()));
+    upstream = undefined;
+  }
+  if (tmpDir) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  }
+  setAGUIRecordBufferCeilingForTests(undefined);
+  vi.restoreAllMocks();
+});
+
+/**
+ * A raw upstream that streams `totalBytes` of valid AG-UI SSE frames in
+ * `chunkBytes`-sized frames, then closes. Each frame is a TEXT_MESSAGE_CONTENT
+ * event so the recorder's SSE parser exercises normally under the cap.
+ */
+function createLargeAguiUpstream(totalBytes: number, chunkBytes: number): Promise<string> {
+  return new Promise((resolve) => {
+    upstream = http.createServer((_req, res) => {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      });
+      let sent = 0;
+      const writeNext = () => {
+        if (res.writableEnded || res.destroyed) return;
+        if (sent >= totalBytes) {
+          res.end();
+          return;
+        }
+        const payload = JSON.stringify({
+          type: "TEXT_MESSAGE_CONTENT",
+          messageId: "m1",
+          delta: "x".repeat(Math.max(1, chunkBytes)),
+        });
+        const frame = `data: ${payload}\n\n`;
+        sent += Buffer.byteLength(frame);
+        if (res.write(frame)) {
+          setImmediate(writeNext);
+        } else {
+          res.once("drain", writeNext);
+        }
+      };
+      writeNext();
+    });
+    upstream.listen(0, "127.0.0.1", () => {
+      const { port } = upstream!.address() as { port: number };
+      resolve(`http://127.0.0.1:${port}`);
+    });
+  });
+}
+
+/** Stream a POST and count relayed bytes without buffering a huge string. */
+function postStreaming(url: string): Promise<{ status: number; bytesReceived: number }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify({
+      threadId: "t1",
+      runId: "r1",
+      messages: [{ id: "u1", role: "user", content: "stream me a lot" }],
+      tools: [],
+      context: [],
+      state: {},
+      forwardedProps: {},
+    });
+    const parsed = new URL(url);
+    const req = http.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path: parsed.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data),
+        },
+      },
+      (res) => {
+        let bytesReceived = 0;
+        res.on("data", (c: Buffer) => {
+          bytesReceived += c.length;
+        });
+        res.on("end", () => resolve({ status: res.statusCode ?? 0, bytesReceived }));
+        res.on("error", reject);
+      },
+    );
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+describe("AG-UI record-buffer cap", () => {
+  it("relays the full streamed body, does not throw, and skips recording when over the cap", async () => {
+    // 4 MB total, ~4 KB frames, with a low 256 KB test-only ceiling so the
+    // buffer must truncate well before the full body accumulates. The client
+    // must still receive every relayed byte.
+    const TOTAL = 4 * 1024 * 1024;
+    const CHUNK = 4 * 1024;
+    setAGUIRecordBufferCeilingForTests(256 * 1024);
+
+    const upstreamUrl = await createLargeAguiUpstream(TOTAL, CHUNK);
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agui-bufcap-"));
+
+    const warnings: string[] = [];
+    vi.spyOn(Logger.prototype, "warn").mockImplementation((...args: unknown[]) => {
+      warnings.push(args.map(String).join(" "));
+    });
+
+    agui = new AGUIMock({ port: 0, logLevel: "warn" });
+    agui.enableRecording({ upstream: upstreamUrl, proxyOnly: false, fixturePath: tmpDir });
+    await agui.start();
+
+    const resp = await postStreaming(agui.url);
+
+    // Client correctness: full relay regardless of the cap. If the server had
+    // crashed with Invalid string length the relay would have been cut short.
+    expect(resp.status).toBe(200);
+    expect(resp.bytesReceived).toBeGreaterThanOrEqual(TOTAL);
+
+    // The record-buffer cap tripped and recording was skipped.
+    expect(warnings.some((w) => /record buffer cap/i.test(w))).toBe(true);
+
+    // No fixture written (the partial buffer was dropped, not journaled).
+    const files = fs.readdirSync(tmpDir).filter((f) => f.endsWith(".json"));
+    expect(files).toHaveLength(0);
+  });
+
+  it("records normally when the response stays under the cap", async () => {
+    const TOTAL = 32 * 1024;
+    const CHUNK = 4 * 1024;
+    setAGUIRecordBufferCeilingForTests(4 * 1024 * 1024);
+
+    const upstreamUrl = await createLargeAguiUpstream(TOTAL, CHUNK);
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agui-bufcap-ok-"));
+
+    agui = new AGUIMock({ port: 0 });
+    agui.enableRecording({ upstream: upstreamUrl, proxyOnly: false, fixturePath: tmpDir });
+    await agui.start();
+
+    const resp = await postStreaming(agui.url);
+    expect(resp.status).toBe(200);
+    expect(resp.bytesReceived).toBeGreaterThanOrEqual(TOTAL);
+
+    // Under the cap → a fixture IS written.
+    const files = fs.readdirSync(tmpDir).filter((f) => f.endsWith(".json"));
+    expect(files.length).toBeGreaterThan(0);
+  });
+});
@@ -0,0 +1,160 @@
+import { describe, it, expect, afterEach } from "vitest";
+import {
+  collapseOpenAISSE,
+  collapseAnthropicSSE,
+  collapseGeminiSSE,
+  collapseCohereSSE,
+  collapseOllamaNDJSON,
+  collapseGeminiInteractionsSSE,
+  collapseBedrockEventStream,
+  setCollapseStringLimitForTests,
+  MAX_COLLAPSE_STRING_LENGTH,
+} from "../stream-collapse.js";
+
+// ---------------------------------------------------------------------------
+// Accumulated-string cap on the stream collapsers.
+//
+// Each collapser accumulates per-channel strings (`content`, `reasoning`, a
+// tool call's `arguments`, `audioB64`, ...) from stream fragments with `+=`.
+// With no cap a large upstream response builds a string past V8's ~512 MiB max
+// string length and throws `RangeError: Invalid string length` — the ~1/sec
+// prod crash, caught at server.ts:1230. These tests use a tiny test-only limit
+// so they exercise the REAL accumulator/guard code without allocating 512 MiB:
+// the collapser must NOT throw, must clamp `content` at the ceiling, and must
+// stamp `truncated: true` so the recorder skips journaling a partial fixture.
+// ---------------------------------------------------------------------------
+
+afterEach(() => {
+  setCollapseStringLimitForTests(undefined);
+});
+
+/** Build an OpenAI SSE body whose accumulated `content` is `totalChars` long. */
+function openAiSseBody(totalChars: number, perFrame: number): string {
+  const frames: string[] = [];
+  let emitted = 0;
+  while (emitted < totalChars) {
+    const n = Math.min(perFrame, totalChars - emitted);
+    frames.push(
+      `data: ${JSON.stringify({ choices: [{ delta: { content: "a".repeat(n) } }] })}\n\n`,
+    );
+    emitted += n;
+  }
+  frames.push("data: [DONE]\n\n");
+  return frames.join("");
+}
+
+describe("stream-collapse accumulated-string cap", () => {
+  it("has a real ceiling comfortably below V8's max string length", () => {
+    // V8 max string length on 64-bit is 2^29 - 1 (~536.87M). The ceiling must
+    // be strictly below it so an accumulator clamped at the ceiling can never
+    // reach the throwing boundary.
+    expect(MAX_COLLAPSE_STRING_LENGTH).toBeLessThan(2 ** 29 - 1);
+    expect(MAX_COLLAPSE_STRING_LENGTH).toBeGreaterThan(0);
+  });
+
+  it("clamps OpenAI content at the ceiling, marks truncated, and never throws", () => {
+    setCollapseStringLimitForTests(1000);
+    // 5000 chars of content across 100-char frames — 5x over the 1000 ceiling.
+    const body = openAiSseBody(5000, 100);
+
+    let result: ReturnType<typeof collapseOpenAISSE> | undefined;
+    expect(() => {
+      result = collapseOpenAISSE(body);
+    }).not.toThrow();
+
+    // content clamped at (or below) the ceiling — never past it.
+    expect(result!.content!.length).toBeLessThanOrEqual(1000);
+    // The over-ceiling input is flagged so the recorder skips journaling.
+    expect(result!.truncated).toBe(true);
+  });
+
+  it("does not truncate when content stays under the ceiling", () => {
+    setCollapseStringLimitForTests(1_000_000);
+    const body = openAiSseBody(500, 100);
+    const result = collapseOpenAISSE(body);
+    expect(result.content).toBe("a".repeat(500));
+    expect(result.truncated).toBeUndefined();
+  });
+
+  it("caps Anthropic content and marks truncated without throwing", () => {
+    setCollapseStringLimitForTests(1000);
+    const frames: string[] = [];
+    for (let i = 0; i < 50; i++) {
+      frames.push(
+        `event: content_block_delta\ndata: ${JSON.stringify({
+          delta: { type: "text_delta", text: "b".repeat(100) },
+        })}\n\n`,
+      );
+    }
+    const body = frames.join("");
+    let result: ReturnType<typeof collapseAnthropicSSE> | undefined;
+    expect(() => {
+      result = collapseAnthropicSSE(body);
+    }).not.toThrow();
+    expect(result!.content!.length).toBeLessThanOrEqual(1000);
+    expect(result!.truncated).toBe(true);
+  });
+
+  it("caps Gemini, Cohere, Ollama, and Gemini-Interactions without throwing", () => {
+    setCollapseStringLimitForTests(500);
+
+    const gemini = collapseGeminiSSE(
+      Array.from(
+        { length: 20 },
+        () =>
+          `data: ${JSON.stringify({
+            candidates: [{ content: { parts: [{ text: "g".repeat(100) }] } }],
+          })}\n\n`,
+      ).join(""),
+    );
+    expect(gemini.content!.length).toBeLessThanOrEqual(500);
+    expect(gemini.truncated).toBe(true);
+
+    const cohere = collapseCohereSSE(
+      Array.from(
+        { length: 20 },
+        () =>
+          `event: content-delta\ndata: ${JSON.stringify({
+            delta: { message: { content: { text: "c".repeat(100) } } },
+          })}\n\n`,
+      ).join(""),
+    );
+    expect(cohere.content!.length).toBeLessThanOrEqual(500);
+    expect(cohere.truncated).toBe(true);
+
+    const ollama = collapseOllamaNDJSON(
+      Array.from(
+        { length: 20 },
+        () => `${JSON.stringify({ message: { content: "o".repeat(100) } })}\n`,
+      ).join(""),
+    );
+    expect(ollama.content!.length).toBeLessThanOrEqual(500);
+    expect(ollama.truncated).toBe(true);
+
+    const geminiInteractions = collapseGeminiInteractionsSSE(
+      Array.from(
+        { length: 20 },
+        () =>
+          `data: ${JSON.stringify({
+            event_type: "step.delta",
+            index: 0,
+            delta: { type: "text", text: "i".repeat(100) },
+          })}\n\n`,
+      ).join(""),
+    );
+    expect(geminiInteractions.content!.length).toBeLessThanOrEqual(500);
+    expect(geminiInteractions.truncated).toBe(true);
+  });
+
+  it("caps Bedrock EventStream input by byte length and marks truncated", () => {
+    setCollapseStringLimitForTests(64);
+    // A raw buffer over the (byte) ceiling — even garbage bytes must be bounded
+    // and flagged truncated rather than fed unbounded into the accumulators.
+    const big = Buffer.alloc(4096, 0x41); // 4 KiB of 'A'
+    let result: ReturnType<typeof collapseBedrockEventStream> | undefined;
+    expect(() => {
+      result = collapseBedrockEventStream(big);
+    }).not.toThrow();
+    expect(result!.truncated).toBe(true);
+  });
+});
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@copilotkit/aimock",`
`3`		`- "version": "1.37.0",`
	`3`	`+ "version": "1.37.1",`
`4`	`4`	`"description": "Mock infrastructure for AI application testing — LLM APIs, image generation, image editing, text-to-speech, transcription, audio translation, audio generation, video generation, embeddings, MCP tools, A2A agents, AG-UI event streams, vector databases, search, rerank, and moderation. One package, one port, zero dependencies.",`
`5`	`5`	`"license": "MIT",`
`6`	`6`	`"keywords": [`