fix: aimock v1.33.0 — proxy buffer cap + stabilization (#272)

Combined release **v1.33.0** — folds the proxy-buffer-cap memory-leak
fix (formerly #275) into this stabilization branch so a single version
ships both. `src/recorder.ts` auto-merged cleanly (disjoint regions);
combined test suite green (3968 pass / 0 fail).

## Added
- `--max-proxy-buffer-bytes` / `--max-proxy-buffer-frames` to bound
proxy-record buffering

## Fixed
- **Proxy memory leak:** the proxy/record path accumulated per-frame
state (`frameTimestamps`, frame buffers, `chunks`) for a stream's whole
lifetime — long-lived proxied SSE streams drove ~8.4 GB/25 h → OOM. Now
byte+frame-capped per-frame (incl. binary EventStream), cleared on trip,
with disconnect cleanup; relay preserved (fail-loud 502 above the 256
MiB hard ceiling). (was #275)
- **`Invalid string length` crash:** oversized proxied responses no
longer build a >512 MB string. (was #275)
- Sanitize `X-AIMock-Context` to prevent fixture path traversal.
- Scope one-shot error injection to compatible endpoints.
- Improve recorder fixture fidelity across providers.
- `matchesPattern` no longer mutates the caller's RegExp `lastIndex`.

## Release
Merging this PR autopublishes `@copilotkit/aimock` **v1.33.0**
(publish-release.yml: push-to-main gated by "version not yet on npm").
Supersedes #275.

## Verification
- Buffer-cap fix: 3 CR rounds to zero; local red-green (never-ending
stream heap flat after cap); staging heap bounded (oscillates+reclaims,
no OOM trajectory).
- Combined: tsc clean, full suite 3968 pass / 0 fail, build OK.

Author: jpr5

.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "source": {
         "source": "npm",
         "package": "@copilotkit/aimock",
-        "version": "^1.32.0"
+        "version": "^1.33.0"
       },
       "description": "Fixture authoring skill for @copilotkit/aimock — LLM, multimedia (image/TTS/transcription/video), MCP, A2A, AG-UI, vector, embeddings, structured output, sequential responses, streaming physics, record/replay, agent loop patterns, and debugging"
     }

.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "aimock",
-  "version": "1.32.0",
+  "version": "1.33.0",
   "description": "Fixture authoring guidance for @copilotkit/aimock — LLM, multimedia, MCP, A2A, AG-UI, vector, and service mocking",
   "author": {
     "name": "CopilotKit"

CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [1.33.0] - 2026-06-23
+
+### Added
+
+- `--max-proxy-buffer-bytes` / `--max-proxy-buffer-frames` flags to cap proxy buffering (#275)
+
+### Fixed
+
+- Proxy path no longer leaks memory on long-lived upstream streams (#275)
+- Oversized proxied responses no longer crash with `Invalid string length` (#275)
+- Sanitize `X-AIMock-Context` to prevent fixture path traversal (#272)
+- Scope one-shot error injection, improve recorder fixture fidelity, fix `matchesPattern` lastIndex (#272)
+
 ## [1.32.0] - 2026-06-22
 
 ### Added

charts/aimock/Chart.yaml

@@ -3,4 +3,4 @@ name: aimock
 description: Mock infrastructure for AI application testing (OpenAI, Anthropic, Gemini, MCP, A2A, vector)
 type: application
 version: 0.1.0
-appVersion: "1.32.0"
+appVersion: "1.33.0"

docs/error-injection/index.html

@@ -179,10 +179,11 @@ <h2>Interruption Behavior</h2>
         <div class="info-box">
           <p>
             <strong>See also: <a href="/chaos-testing">Chaos Testing</a></strong> &mdash; for
-            probabilistic failure injection. Chaos testing adds configurable error rates, random
-            latency spikes, and stream corruption that trigger based on probability rather than
-            deterministic fixture matching. Use error injection for specific, reproducible failure
-            scenarios; use chaos testing for resilience testing under unpredictable conditions.
+            probabilistic failure injection. Chaos testing adds configurable rates for dropped
+            requests (500), malformed JSON responses, and disconnects that trigger based on
+            probability rather than deterministic fixture matching. Use error injection for
+            specific, reproducible failure scenarios; use chaos testing for resilience testing under
+            unpredictable conditions.
           </p>
         </div>
       </main>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@copilotkit/aimock",
-  "version": "1.32.0",
+  "version": "1.33.0",
   "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": [

packages/aimock-pytest/README.md

@@ -73,7 +73,7 @@ aimock.reset()             # alias for reset_fixtures()
 
 ```
 --aimock-node PATH       Path to node binary
---aimock-version VER     aimock npm version (default: 1.32.0)
+--aimock-version VER     aimock npm version (default: 1.33.0)
 ```
 
 ## Environment Variables

packages/aimock-pytest/src/aimock_pytest/_version.py

@@ -8,4 +8,4 @@
 control routes ship in the next release). Keep it tracking npm releases.
 """
 
-AIMOCK_VERSION = "1.32.0"
+AIMOCK_VERSION = "1.33.0"

src/__tests__/llmock.test.ts

@@ -37,6 +37,37 @@ function post(url: string, body: object): Promise<{ status: number; data: string
   });
 }
 
+function postTo(
+  url: string,
+  path: string,
+  body: object,
+): Promise<{ status: number; data: string }> {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const payload = JSON.stringify(body);
+    const req = http.request(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port,
+        path,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => resolve({ status: res.statusCode!, data }));
+      },
+    );
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
 function chatBody(userMessage: string, stream = true) {
   return {
     model: "gpt-4",
@@ -109,6 +140,11 @@ describe("LLMock", () => {
       expect(result).toBe(mock);
     });
 
+    it("addFixturesFromJSON throws a contextful error on malformed JSON", () => {
+      mock = new LLMock();
+      expect(() => mock.addFixturesFromJSON("{ not valid json")).toThrow(/addFixturesFromJSON/);
+    });
+
     it("chaining API works across multiple calls", () => {
       mock = new LLMock();
       const result = mock
@@ -819,6 +855,34 @@ describe("LLMock", () => {
       expect(res3.status).toBe(200);
       expect(res3.data).toContain("Normal response");
     });
+
+    it("does not let an incompatible (multimedia) endpoint consume a chat-bound one-shot error", async () => {
+      mock = new LLMock();
+      mock.onMessage("hello", { content: "Hi!" });
+      mock.onImage("draw a cat", { image: { b64Json: "aW1n" } });
+      await mock.start();
+
+      // Queue a one-shot error. Conceptually intended for the chat endpoint;
+      // an error response is incompatible with the image endpoint (mirrors the
+      // router's endpoint-compat table, where only `fal` accepts errors).
+      mock.nextRequestError(503, { message: "Overloaded", type: "server_error" });
+
+      // Issue an INCOMPATIBLE image request FIRST. It must NOT consume the
+      // error: the image fixture should serve normally and the error stays
+      // pending for a compatible endpoint.
+      const img = await postTo(mock.url, "/v1/images/generations", {
+        model: "dall-e-3",
+        prompt: "draw a cat",
+      });
+      expect(img.status).toBe(200);
+      expect(img.data).toContain("aW1n");
+
+      // The one-shot error must STILL be pending → the next chat request gets it.
+      const chat = await post(mock.url, chatBody("hello"));
+      expect(chat.status).toBe(503);
+      const body = JSON.parse(chat.data);
+      expect(body.error.message).toBe("Overloaded");
+    });
   });
 
   describe("journal proxies", () => {

src/__tests__/multimedia-types.test.ts

@@ -4,6 +4,7 @@ import {
   isAudioResponse,
   isTranscriptionResponse,
   isVideoResponse,
+  matchesPattern,
 } from "../helpers.js";
 import { matchFixture } from "../router.js";
 import type { Fixture, ChatCompletionRequest, FixtureResponse } from "../types.js";
@@ -26,6 +27,11 @@ describe("multimedia type guards", () => {
     expect(isImageResponse(r)).toBe(false);
   });
 
+  test("isImageResponse rejects non-object image value", () => {
+    const r = { image: "not-an-object" } as unknown as FixtureResponse;
+    expect(isImageResponse(r)).toBe(false);
+  });
+
   test("isAudioResponse detects audio (string form)", () => {
     const r: FixtureResponse = { audio: "AAAA", format: "mp3" };
     expect(isAudioResponse(r)).toBe(true);
@@ -149,7 +155,54 @@ describe("endpoint filtering in matchFixture", () => {
       _endpointType: "image",
     };
 
-    const first = matchFixture(fixtures, imageReq, counts);
-    expect(first).toBe(fixtures[0]);
+    // Pin the FULL sequence ordering this test claims to verify. matchFixture
+    // gates a sequenced fixture on its match count equalling sequenceIndex but
+    // does not itself mutate the count — the caller (journal) increments after
+    // consuming a match, and crucially advances ALL sequenced siblings sharing
+    // the same match criteria so the group shares one logical counter. Mimic
+    // that here so each call advances to the next sequenceIndex, proving the
+    // sequence resolves 0 → 1 in order and then exhausts.
+    const advanceSequence = (matched: Fixture): void => {
+      for (const f of fixtures) {
+        if (f.match.sequenceIndex !== undefined) {
+          counts.set(f, (counts.get(f) ?? 0) + 1);
+        }
+      }
+      // (matched is part of the group; the loop above already advanced it)
+      void matched;
+    };
+    const resolve = (): Fixture | null => {
+      const f = matchFixture(fixtures, imageReq, counts);
+      if (f) advanceSequence(f);
+      return f;
+    };
+
+    expect(resolve()).toBe(fixtures[0]);
+    expect(resolve()).toBe(fixtures[1]);
+    // The sequence is exhausted: no fixture has a sequenceIndex matching the
+    // next shared count, so further requests no longer match.
+    expect(resolve()).toBeNull();
+  });
+});
+
+describe("matchesPattern", () => {
+  test("does not mutate the caller's RegExp lastIndex", () => {
+    // A global regex carries mutable `lastIndex` state. matchesPattern must
+    // not leave that state mutated, or callers reusing the same regex object
+    // (e.g. the search/rerank/moderation filter loops) get inconsistent
+    // results on subsequent uses.
+    const re = /guitar/g;
+    expect(matchesPattern("guitar", re)).toBe(true);
+    // After the call, the caller's own use of the same regex must behave as if
+    // matchesPattern never touched it.
+    expect(re.lastIndex).toBe(0);
+    expect(re.test("guitar")).toBe(true);
+  });
+
+  test("is consistent across repeated calls with the same global regex", () => {
+    const re = /g/g;
+    expect(matchesPattern("guitar", re)).toBe(true);
+    expect(matchesPattern("guitar", re)).toBe(true);
+    expect(matchesPattern("guitar", re)).toBe(true);
   });
 });