@copilotkit/aimock 1.46.0 → 1.47.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "source": {
         "source": "npm",
         "package": "@copilotkit/aimock",
-        "version": "^1.46.0"
+        "version": "^1.47.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"
     }

package/.claude-plugin/plugin.json

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

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 # @copilotkit/aimock
 
-## [Unreleased]
+## [1.47.0] - 2026-10-26
+
+### Added
+
+- Fixture `citations` serve sources on Responses, Chat Completions, Claude and Gemini (#550, #578)
+- Fixture `files` serve generated images on Gemini and OpenAI Responses (#550, #578)
+- Raw passthrough fixtures send provider SSE events or JSON exactly as written (#580)
+- Opt-in `nonStreamingTimingAllProviders` delays non-streaming replies on every provider (#579)
+
+### Fixed
+
+- Client disconnects stop and journal every LLM reply; Docker image on Node 22.23.4 (#579, #576)
 
 ## [1.46.0] - 2026-10-20
 

package/README.md

@@ -91,13 +91,16 @@ Run them all on one port with `npx @copilotkit/aimock --config aimock.json`, or
 - **[Native model catalogs and token counts](https://aimock.copilotkit.dev/claude-messages#model-catalog)** — Anthropic `GET /v1/models` (selected by `anthropic-version`, or `x-api-key` without `Authorization`; the list route needs `policy.modelCatalog: "native"` and otherwise stays the OpenAI list) and Gemini `GET /v1beta/models` list and detail routes with provider paging, built from fixture model IDs with synthetic metadata; `POST /v1/messages/count_tokens` and Gemini `:countTokens` return a deterministic estimate of about 1 token per 4 characters of messages (plus tool definitions), minimum 1. These routes never proxy or record
 - **Context-Based Fixture Routing** — `X-AIMock-Context` header scopes fixtures per integration; fixtures with `match.context` only match requests carrying that context, fixtures without it remain shared
 - **[Drift Detection](https://aimock.copilotkit.dev/drift-detection)** — Daily CI validation against real APIs
-- **[Streaming Physics](https://aimock.copilotkit.dev/streaming-physics)** — Configurable `ttft`, `tps`, and `jitter`
+- **[Streaming Physics](https://aimock.copilotkit.dev/streaming-physics)** — Configurable `ttft`, `tps`, and `jitter`; opt in with `nonStreamingTimingAllProviders: true` to give non-streaming replies the same timing on every LLM provider
+- **[Client Disconnects](https://aimock.copilotkit.dev/error-injection#client-disconnects)** — When the client hangs up, every LLM provider (HTTP and WebSocket) stops sending and journals the request as `interrupted`, so you can test cancel and abort paths
 - **[WebSocket APIs](https://aimock.copilotkit.dev/websocket)** — OpenAI Realtime (GA protocol with models: gpt-realtime, gpt-realtime-2, gpt-realtime-1.5, gpt-realtime-mini; transcription/translation via gpt-4o-transcribe, gpt-4o-mini-transcribe, whisper-1; image input; commentary phase), Responses WS, Gemini Live
 - **[GPT-Live](https://aimock.copilotkit.dev/websocket#openai-live)** — Mock, record, and replay primary WebSocket sessions at `/v1/live/sessions` in client and managed modes, with fixture-backed audio and backend tool continuation. Saved fixtures replay offline; aimock does not synthesize speech. This voice surface is separate from OpenAI text-model family support; WebRTC/SDP and sideband connections are outside this scope.
 - **[Prometheus Metrics](https://aimock.copilotkit.dev/metrics)** — Request counts, latencies, fixture match rates
 - **[Docker + Helm](https://aimock.copilotkit.dev/docker)** — Container image and Helm chart for CI/CD
 - **[Vitest & Jest Plugins](https://aimock.copilotkit.dev/test-plugins)** — Zero-config `useAimock()` with auto lifecycle and env patching
 - **[Response Overrides](https://aimock.copilotkit.dev/fixtures)** — Control `id`, `model`, `usage`, `finishReason` in fixture responses
+- **[Citations and Generated Files](https://aimock.copilotkit.dev/fixtures#citations-and-files)** — Fixture `citations` serve source citations on OpenAI Responses (URL and file), Chat Completions, Claude and Gemini; fixture `files` serve generated images on the Responses API and Gemini. Each uses the provider's own format, streaming and non-streaming
+- **[Raw Passthrough](https://aimock.copilotkit.dev/raw-passthrough)** — A `raw` fixture sends provider SSE events or JSON exactly as written on any HTTP LLM wire, for fields aimock does not model yet; timing, chaos and disconnects still apply
 - **[Ordered Blocks](https://aimock.copilotkit.dev/fixtures#ordered-blocks)** — A `blocks` array streams text and tool calls in any order (tool-first or interleaved); blocks-only fixtures are first-class, and the recorder captures order from genuinely tool-first/interleaved streams
 - **[Namespaced and Custom Tool Calls](https://aimock.copilotkit.dev/responses-api#namespaced-and-custom-tool-calls)** — Responses API fixtures can return namespaced function calls and custom tool calls (`custom_tool_call`) over HTTP streaming, non-streaming and WebSocket, and can match on `toolNamespace`. This lets you script OpenAI Codex CLI's namespaced MCP and sub-agent tools and its freeform `apply_patch` tool (with the `responsesTools: "extended"` server option)
 - **[Streaming Usage Chunks](https://aimock.copilotkit.dev/streaming-physics)** — `stream_options.include_usage` support emits a final chunk with token counts, matching OpenAI's streaming usage protocol

package/dist/aws-event-stream.cjs

@@ -1,5 +1,5 @@
 const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-const require_sse_writer = require('./sse-writer.cjs');
+const require_frame_loop = require('./response/frame-loop.cjs');
 let node_zlib = require("node:zlib");
 
 //#region src/aws-event-stream.ts
@@ -87,32 +87,29 @@ function encodeEventStreamMessage(eventType, jsonPayload) {
 */
 async function writeEventStream(res, events, options) {
 	const opts = options ?? {};
-	const latency = opts.latency ?? 0;
-	const profile = opts.streamingProfile;
-	const { recordedTimings, replaySpeed } = opts;
-	const signal = opts.signal;
-	const onChunkSent = opts.onChunkSent;
-	if (res.writableEnded) return true;
-	res.setHeader("Content-Type", "application/vnd.amazon.eventstream");
-	res.setHeader("Transfer-Encoding", "chunked");
-	let chunkIndex = 0;
-	for (const event of events) {
-		const chunkDelay = require_sse_writer.calculateDelay(chunkIndex, profile, latency, recordedTimings, replaySpeed);
-		if (chunkDelay > 0) await require_sse_writer.delay(chunkDelay, signal);
-		if (signal?.aborted) return false;
-		if (res.writableEnded) return true;
-		const frame = encodeEventStreamMessage(event.eventType, event.payload);
-		res.write(frame);
-		onChunkSent?.();
-		if (signal?.aborted) return false;
-		chunkIndex++;
-	}
-	if (!res.writableEnded) res.end();
-	return true;
+	return require_frame_loop.runFrameLoop(require_frame_loop.httpSink(res), events, eventStreamCodec(), {
+		latency: opts.latency,
+		streamingProfile: opts.streamingProfile,
+		recordedTimings: opts.recordedTimings,
+		replaySpeed: opts.replaySpeed
+	}, {
+		signal: events.length > 0 ? opts.signal : void 0,
+		onChunkSent: opts.onChunkSent
+	});
+}
+function eventStreamCodec(encode) {
+	return {
+		headers: {
+			"Content-Type": "application/vnd.amazon.eventstream",
+			"Transfer-Encoding": "chunked"
+		},
+		encode: encode ?? ((event) => encodeEventStreamMessage(event.eventType, event.payload))
+	};
 }
 
 //#endregion
 exports.encodeEventStreamFrame = encodeEventStreamFrame;
 exports.encodeEventStreamMessage = encodeEventStreamMessage;
+exports.eventStreamCodec = eventStreamCodec;
 exports.writeEventStream = writeEventStream;
 //# sourceMappingURL=aws-event-stream.cjs.map

package/dist/aws-event-stream.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"aws-event-stream.cjs","names":["calculateDelay","delay"],"sources":["../src/aws-event-stream.ts"],"sourcesContent":["/**\n * AWS Event Stream binary frame encoder.\n *\n * Implements the AWS binary event stream framing protocol used by Bedrock's\n * streaming (invoke-with-response-stream) endpoint. Each frame carries a set of\n * string headers and a raw-bytes payload, wrapped in a prelude with CRC32\n * checksums for integrity.\n *\n * Binary frame layout:\n *   [total_length: 4B uint32-BE]\n *   [headers_length: 4B uint32-BE]\n *   [prelude_crc32: 4B CRC32 of first 8 bytes]\n *   [headers: variable]\n *   [payload: variable, raw JSON bytes]\n *   [message_crc32: 4B CRC32 of entire frame minus last 4 bytes]\n */\n\nimport { crc32 } from \"node:zlib\";\nimport type * as http from \"node:http\";\nimport type { StreamingProfile, RecordedTimings } from \"./types.js\";\nimport { delay, calculateDelay } from \"./sse-writer.js\";\n\n// ─── Header encoding ────────────────────────────────────────────────────────\n\nfunction encodeHeaders(headers: Record<string, string>): Buffer {\n  const parts: Buffer[] = [];\n  for (const [name, value] of Object.entries(headers)) {\n    const nameBytes = Buffer.from(name, \"utf8\");\n    const valueBytes = Buffer.from(value, \"utf8\");\n\n    // name_length (1 byte) + name + type (1 byte, 7 = STRING) +\n    // value_length (2 bytes BE) + value\n    const header = Buffer.alloc(1 + nameBytes.length + 1 + 2 + valueBytes.length);\n    let offset = 0;\n    header.writeUInt8(nameBytes.length, offset);\n    offset += 1;\n    nameBytes.copy(header, offset);\n    offset += nameBytes.length;\n    header.writeUInt8(7, offset); // STRING type\n    offset += 1;\n    header.writeUInt16BE(valueBytes.length, offset);\n    offset += 2;\n    valueBytes.copy(header, offset);\n\n    parts.push(header);\n  }\n  return Buffer.concat(parts);\n}\n\n// ─── Frame encoding ─────────────────────────────────────────────────────────\n\n/**\n * Encode a single AWS Event Stream binary frame with the given headers and\n * payload buffer.\n */\nexport function encodeEventStreamFrame(headers: Record<string, string>, payload: Buffer): Buffer {\n  const headersBuffer = encodeHeaders(headers);\n  const headersLength = headersBuffer.length;\n\n  // prelude (8) + prelude_crc (4) + headers + payload + message_crc (4)\n  const totalLength = 4 + 4 + 4 + headersLength + payload.length + 4;\n\n  const frame = Buffer.alloc(totalLength);\n  let offset = 0;\n\n  // Prelude\n  frame.writeUInt32BE(totalLength, offset);\n  offset += 4;\n  frame.writeUInt32BE(headersLength, offset);\n  offset += 4;\n\n  // Prelude CRC32 (covers first 8 bytes)\n  const preludeCrc = crc32(frame.subarray(0, 8));\n  frame.writeUInt32BE(preludeCrc >>> 0, offset);\n  offset += 4;\n\n  // Headers\n  headersBuffer.copy(frame, offset);\n  offset += headersLength;\n\n  // Payload\n  payload.copy(frame, offset);\n  offset += payload.length;\n\n  // Message CRC32 (covers entire frame minus last 4 bytes)\n  const messageCrc = crc32(frame.subarray(0, totalLength - 4));\n  frame.writeUInt32BE(messageCrc >>> 0, offset);\n\n  return frame;\n}\n\n// ─── Convenience wrappers ───────────────────────────────────────────────────\n\n/**\n * Encode an event-stream message with standard AWS headers for a JSON event.\n *\n * Sets `:content-type` = `application/json`, `:event-type` = eventType,\n * `:message-type` = `event`.\n */\nexport function encodeEventStreamMessage(eventType: string, jsonPayload: object): Buffer {\n  const headers: Record<string, string> = {\n    \":content-type\": \"application/json\",\n    \":event-type\": eventType,\n    \":message-type\": \"event\",\n  };\n  const payload = Buffer.from(JSON.stringify(jsonPayload), \"utf8\");\n  return encodeEventStreamFrame(headers, payload);\n}\n\n/**\n * Write a sequence of event-stream frames to an HTTP response with optional\n * timing control. Mirrors the writeSSEStream pattern from sse-writer.ts.\n *\n * Returns `true` when all events are written (including when the response\n * was already ended before writing began), or `false` if interrupted by\n * the provided abort signal.\n */\nexport async function writeEventStream(\n  res: http.ServerResponse,\n  events: Array<{ eventType: string; payload: object }>,\n  options?: {\n    latency?: number;\n    streamingProfile?: StreamingProfile;\n    recordedTimings?: RecordedTimings;\n    replaySpeed?: number;\n    signal?: AbortSignal;\n    onChunkSent?: () => void;\n  },\n): Promise<boolean> {\n  const opts = options ?? {};\n  const latency = opts.latency ?? 0;\n  const profile = opts.streamingProfile;\n  const { recordedTimings, replaySpeed } = opts;\n  const signal = opts.signal;\n  const onChunkSent = opts.onChunkSent;\n\n  if (res.writableEnded) return true;\n  res.setHeader(\"Content-Type\", \"application/vnd.amazon.eventstream\");\n  res.setHeader(\"Transfer-Encoding\", \"chunked\");\n\n  let chunkIndex = 0;\n  for (const event of events) {\n    const chunkDelay = calculateDelay(chunkIndex, profile, latency, recordedTimings, replaySpeed);\n    if (chunkDelay > 0) {\n      await delay(chunkDelay, signal);\n    }\n    if (signal?.aborted) return false;\n    if (res.writableEnded) return true;\n\n    const frame = encodeEventStreamMessage(event.eventType, event.payload);\n    res.write(frame);\n    onChunkSent?.();\n    if (signal?.aborted) return false;\n    chunkIndex++;\n  }\n\n  if (!res.writableEnded) {\n    res.end();\n  }\n  return true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,SAAS,cAAc,SAAyC;CAC9D,MAAM,QAAkB,EAAE;AAC1B,MAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,QAAQ,EAAE;EACnD,MAAM,YAAY,OAAO,KAAK,MAAM,OAAO;EAC3C,MAAM,aAAa,OAAO,KAAK,OAAO,OAAO;EAI7C,MAAM,SAAS,OAAO,MAAM,IAAI,UAAU,SAAS,IAAI,IAAI,WAAW,OAAO;EAC7E,IAAI,SAAS;AACb,SAAO,WAAW,UAAU,QAAQ,OAAO;AAC3C,YAAU;AACV,YAAU,KAAK,QAAQ,OAAO;AAC9B,YAAU,UAAU;AACpB,SAAO,WAAW,GAAG,OAAO;AAC5B,YAAU;AACV,SAAO,cAAc,WAAW,QAAQ,OAAO;AAC/C,YAAU;AACV,aAAW,KAAK,QAAQ,OAAO;AAE/B,QAAM,KAAK,OAAO;;AAEpB,QAAO,OAAO,OAAO,MAAM;;;;;;AAS7B,SAAgB,uBAAuB,SAAiC,SAAyB;CAC/F,MAAM,gBAAgB,cAAc,QAAQ;CAC5C,MAAM,gBAAgB,cAAc;CAGpC,MAAM,cAAc,KAAY,gBAAgB,QAAQ,SAAS;CAEjE,MAAM,QAAQ,OAAO,MAAM,YAAY;CACvC,IAAI,SAAS;AAGb,OAAM,cAAc,aAAa,OAAO;AACxC,WAAU;AACV,OAAM,cAAc,eAAe,OAAO;AAC1C,WAAU;CAGV,MAAM,kCAAmB,MAAM,SAAS,GAAG,EAAE,CAAC;AAC9C,OAAM,cAAc,eAAe,GAAG,OAAO;AAC7C,WAAU;AAGV,eAAc,KAAK,OAAO,OAAO;AACjC,WAAU;AAGV,SAAQ,KAAK,OAAO,OAAO;AAC3B,WAAU,QAAQ;CAGlB,MAAM,kCAAmB,MAAM,SAAS,GAAG,cAAc,EAAE,CAAC;AAC5D,OAAM,cAAc,eAAe,GAAG,OAAO;AAE7C,QAAO;;;;;;;;AAWT,SAAgB,yBAAyB,WAAmB,aAA6B;AAOvF,QAAO,uBANiC;EACtC,iBAAiB;EACjB,eAAe;EACf,iBAAiB;EAClB,EACe,OAAO,KAAK,KAAK,UAAU,YAAY,EAAE,OAAO,CACjB;;;;;;;;;;AAWjD,eAAsB,iBACpB,KACA,QACA,SAQkB;CAClB,MAAM,OAAO,WAAW,EAAE;CAC1B,MAAM,UAAU,KAAK,WAAW;CAChC,MAAM,UAAU,KAAK;CACrB,MAAM,EAAE,iBAAiB,gBAAgB;CACzC,MAAM,SAAS,KAAK;CACpB,MAAM,cAAc,KAAK;AAEzB,KAAI,IAAI,cAAe,QAAO;AAC9B,KAAI,UAAU,gBAAgB,qCAAqC;AACnE,KAAI,UAAU,qBAAqB,UAAU;CAE7C,IAAI,aAAa;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,aAAaA,kCAAe,YAAY,SAAS,SAAS,iBAAiB,YAAY;AAC7F,MAAI,aAAa,EACf,OAAMC,yBAAM,YAAY,OAAO;AAEjC,MAAI,QAAQ,QAAS,QAAO;AAC5B,MAAI,IAAI,cAAe,QAAO;EAE9B,MAAM,QAAQ,yBAAyB,MAAM,WAAW,MAAM,QAAQ;AACtE,MAAI,MAAM,MAAM;AAChB,iBAAe;AACf,MAAI,QAAQ,QAAS,QAAO;AAC5B;;AAGF,KAAI,CAAC,IAAI,cACP,KAAI,KAAK;AAEX,QAAO"}
+{"version":3,"file":"aws-event-stream.cjs","names":["runFrameLoop","httpSink"],"sources":["../src/aws-event-stream.ts"],"sourcesContent":["/**\n * AWS Event Stream binary frame encoder.\n *\n * Implements the AWS binary event stream framing protocol used by Bedrock's\n * streaming (invoke-with-response-stream) endpoint. Each frame carries a set of\n * string headers and a raw-bytes payload, wrapped in a prelude with CRC32\n * checksums for integrity.\n *\n * Binary frame layout:\n *   [total_length: 4B uint32-BE]\n *   [headers_length: 4B uint32-BE]\n *   [prelude_crc32: 4B CRC32 of first 8 bytes]\n *   [headers: variable]\n *   [payload: variable, raw JSON bytes]\n *   [message_crc32: 4B CRC32 of entire frame minus last 4 bytes]\n */\n\nimport { crc32 } from \"node:zlib\";\nimport type * as http from \"node:http\";\nimport type { StreamingProfile, RecordedTimings } from \"./types.js\";\nimport { httpSink, runFrameLoop, type FrameCodec } from \"./response/frame-loop.js\";\n\n// ─── Header encoding ────────────────────────────────────────────────────────\n\nfunction encodeHeaders(headers: Record<string, string>): Buffer {\n  const parts: Buffer[] = [];\n  for (const [name, value] of Object.entries(headers)) {\n    const nameBytes = Buffer.from(name, \"utf8\");\n    const valueBytes = Buffer.from(value, \"utf8\");\n\n    // name_length (1 byte) + name + type (1 byte, 7 = STRING) +\n    // value_length (2 bytes BE) + value\n    const header = Buffer.alloc(1 + nameBytes.length + 1 + 2 + valueBytes.length);\n    let offset = 0;\n    header.writeUInt8(nameBytes.length, offset);\n    offset += 1;\n    nameBytes.copy(header, offset);\n    offset += nameBytes.length;\n    header.writeUInt8(7, offset); // STRING type\n    offset += 1;\n    header.writeUInt16BE(valueBytes.length, offset);\n    offset += 2;\n    valueBytes.copy(header, offset);\n\n    parts.push(header);\n  }\n  return Buffer.concat(parts);\n}\n\n// ─── Frame encoding ─────────────────────────────────────────────────────────\n\n/**\n * Encode a single AWS Event Stream binary frame with the given headers and\n * payload buffer.\n */\nexport function encodeEventStreamFrame(headers: Record<string, string>, payload: Buffer): Buffer {\n  const headersBuffer = encodeHeaders(headers);\n  const headersLength = headersBuffer.length;\n\n  // prelude (8) + prelude_crc (4) + headers + payload + message_crc (4)\n  const totalLength = 4 + 4 + 4 + headersLength + payload.length + 4;\n\n  const frame = Buffer.alloc(totalLength);\n  let offset = 0;\n\n  // Prelude\n  frame.writeUInt32BE(totalLength, offset);\n  offset += 4;\n  frame.writeUInt32BE(headersLength, offset);\n  offset += 4;\n\n  // Prelude CRC32 (covers first 8 bytes)\n  const preludeCrc = crc32(frame.subarray(0, 8));\n  frame.writeUInt32BE(preludeCrc >>> 0, offset);\n  offset += 4;\n\n  // Headers\n  headersBuffer.copy(frame, offset);\n  offset += headersLength;\n\n  // Payload\n  payload.copy(frame, offset);\n  offset += payload.length;\n\n  // Message CRC32 (covers entire frame minus last 4 bytes)\n  const messageCrc = crc32(frame.subarray(0, totalLength - 4));\n  frame.writeUInt32BE(messageCrc >>> 0, offset);\n\n  return frame;\n}\n\n// ─── Convenience wrappers ───────────────────────────────────────────────────\n\n/**\n * Encode an event-stream message with standard AWS headers for a JSON event.\n *\n * Sets `:content-type` = `application/json`, `:event-type` = eventType,\n * `:message-type` = `event`.\n */\nexport function encodeEventStreamMessage(eventType: string, jsonPayload: object): Buffer {\n  const headers: Record<string, string> = {\n    \":content-type\": \"application/json\",\n    \":event-type\": eventType,\n    \":message-type\": \"event\",\n  };\n  const payload = Buffer.from(JSON.stringify(jsonPayload), \"utf8\");\n  return encodeEventStreamFrame(headers, payload);\n}\n\n/**\n * Write a sequence of event-stream frames to an HTTP response with optional\n * timing control. Mirrors the writeSSEStream pattern from sse-writer.ts.\n *\n * Returns `true` when all events are written (including when the response\n * was already ended before writing began), or `false` if interrupted by\n * the provided abort signal.\n */\nexport async function writeEventStream(\n  res: http.ServerResponse,\n  events: Array<{ eventType: string; payload: object }>,\n  options?: {\n    latency?: number;\n    streamingProfile?: StreamingProfile;\n    recordedTimings?: RecordedTimings;\n    replaySpeed?: number;\n    signal?: AbortSignal;\n    onChunkSent?: () => void;\n  },\n): Promise<boolean> {\n  const opts = options ?? {};\n  // Base contract (public API): with no frames, an aborted signal does not\n  // stop the writer; it still finishes the stream (any trailer, then end())\n  // and returns true. The frame loop returns false there, so pass it no\n  // signal when there are no frames (it reads the signal only per frame and\n  // after the loop).\n  return runFrameLoop(\n    httpSink(res),\n    events,\n    eventStreamCodec(),\n    {\n      latency: opts.latency,\n      streamingProfile: opts.streamingProfile,\n      recordedTimings: opts.recordedTimings,\n      replaySpeed: opts.replaySpeed,\n    },\n    { signal: events.length > 0 ? opts.signal : undefined, onChunkSent: opts.onChunkSent },\n  );\n}\n\n// Internal (not part of the public API): the AWS binary event-stream codec.\n// Each event becomes one complete frame, encoded by encodeEventStreamMessage\n// unless an `encode` argument replaces it. There is no prelude or trailer.\n// These are line comments, not JSDoc, so the bundled .d.ts does not attach\n// them to a public declaration.\nexport function eventStreamCodec<F extends { eventType: string; payload: object }>(\n  encode?: (event: F) => Buffer,\n): FrameCodec<F> {\n  return {\n    headers: {\n      \"Content-Type\": \"application/vnd.amazon.eventstream\",\n      \"Transfer-Encoding\": \"chunked\",\n    },\n    encode: encode ?? ((event) => encodeEventStreamMessage(event.eventType, event.payload)),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAwBA,SAAS,cAAc,SAAyC;CAC9D,MAAM,QAAkB,EAAE;AAC1B,MAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,QAAQ,EAAE;EACnD,MAAM,YAAY,OAAO,KAAK,MAAM,OAAO;EAC3C,MAAM,aAAa,OAAO,KAAK,OAAO,OAAO;EAI7C,MAAM,SAAS,OAAO,MAAM,IAAI,UAAU,SAAS,IAAI,IAAI,WAAW,OAAO;EAC7E,IAAI,SAAS;AACb,SAAO,WAAW,UAAU,QAAQ,OAAO;AAC3C,YAAU;AACV,YAAU,KAAK,QAAQ,OAAO;AAC9B,YAAU,UAAU;AACpB,SAAO,WAAW,GAAG,OAAO;AAC5B,YAAU;AACV,SAAO,cAAc,WAAW,QAAQ,OAAO;AAC/C,YAAU;AACV,aAAW,KAAK,QAAQ,OAAO;AAE/B,QAAM,KAAK,OAAO;;AAEpB,QAAO,OAAO,OAAO,MAAM;;;;;;AAS7B,SAAgB,uBAAuB,SAAiC,SAAyB;CAC/F,MAAM,gBAAgB,cAAc,QAAQ;CAC5C,MAAM,gBAAgB,cAAc;CAGpC,MAAM,cAAc,KAAY,gBAAgB,QAAQ,SAAS;CAEjE,MAAM,QAAQ,OAAO,MAAM,YAAY;CACvC,IAAI,SAAS;AAGb,OAAM,cAAc,aAAa,OAAO;AACxC,WAAU;AACV,OAAM,cAAc,eAAe,OAAO;AAC1C,WAAU;CAGV,MAAM,kCAAmB,MAAM,SAAS,GAAG,EAAE,CAAC;AAC9C,OAAM,cAAc,eAAe,GAAG,OAAO;AAC7C,WAAU;AAGV,eAAc,KAAK,OAAO,OAAO;AACjC,WAAU;AAGV,SAAQ,KAAK,OAAO,OAAO;AAC3B,WAAU,QAAQ;CAGlB,MAAM,kCAAmB,MAAM,SAAS,GAAG,cAAc,EAAE,CAAC;AAC5D,OAAM,cAAc,eAAe,GAAG,OAAO;AAE7C,QAAO;;;;;;;;AAWT,SAAgB,yBAAyB,WAAmB,aAA6B;AAOvF,QAAO,uBANiC;EACtC,iBAAiB;EACjB,eAAe;EACf,iBAAiB;EAClB,EACe,OAAO,KAAK,KAAK,UAAU,YAAY,EAAE,OAAO,CACjB;;;;;;;;;;AAWjD,eAAsB,iBACpB,KACA,QACA,SAQkB;CAClB,MAAM,OAAO,WAAW,EAAE;AAM1B,QAAOA,gCACLC,4BAAS,IAAI,EACb,QACA,kBAAkB,EAClB;EACE,SAAS,KAAK;EACd,kBAAkB,KAAK;EACvB,iBAAiB,KAAK;EACtB,aAAa,KAAK;EACnB,EACD;EAAE,QAAQ,OAAO,SAAS,IAAI,KAAK,SAAS;EAAW,aAAa,KAAK;EAAa,CACvF;;AAQH,SAAgB,iBACd,QACe;AACf,QAAO;EACL,SAAS;GACP,gBAAgB;GAChB,qBAAqB;GACtB;EACD,QAAQ,YAAY,UAAU,yBAAyB,MAAM,WAAW,MAAM,QAAQ;EACvF"}

package/dist/aws-event-stream.d.cts

@@ -34,7 +34,6 @@ declare function writeEventStream(res: http$1.ServerResponse, events: Array<{
   signal?: AbortSignal;
   onChunkSent?: () => void;
 }): Promise<boolean>;
-//# sourceMappingURL=aws-event-stream.d.ts.map
 //#endregion
 export { encodeEventStreamFrame, encodeEventStreamMessage, writeEventStream };
 //# sourceMappingURL=aws-event-stream.d.cts.map

package/dist/aws-event-stream.d.ts

@@ -34,7 +34,6 @@ declare function writeEventStream(res: http$1.ServerResponse, events: Array<{
   signal?: AbortSignal;
   onChunkSent?: () => void;
 }): Promise<boolean>;
-//# sourceMappingURL=aws-event-stream.d.ts.map
 //#endregion
 export { encodeEventStreamFrame, encodeEventStreamMessage, writeEventStream };
 //# sourceMappingURL=aws-event-stream.d.ts.map

package/dist/aws-event-stream.js

@@ -1,4 +1,4 @@
-import { calculateDelay, delay } from "./sse-writer.js";
+import { httpSink, runFrameLoop } from "./response/frame-loop.js";
 import { crc32 } from "node:zlib";
 
 //#region src/aws-event-stream.ts
@@ -86,30 +86,26 @@ function encodeEventStreamMessage(eventType, jsonPayload) {
 */
 async function writeEventStream(res, events, options) {
 	const opts = options ?? {};
-	const latency = opts.latency ?? 0;
-	const profile = opts.streamingProfile;
-	const { recordedTimings, replaySpeed } = opts;
-	const signal = opts.signal;
-	const onChunkSent = opts.onChunkSent;
-	if (res.writableEnded) return true;
-	res.setHeader("Content-Type", "application/vnd.amazon.eventstream");
-	res.setHeader("Transfer-Encoding", "chunked");
-	let chunkIndex = 0;
-	for (const event of events) {
-		const chunkDelay = calculateDelay(chunkIndex, profile, latency, recordedTimings, replaySpeed);
-		if (chunkDelay > 0) await delay(chunkDelay, signal);
-		if (signal?.aborted) return false;
-		if (res.writableEnded) return true;
-		const frame = encodeEventStreamMessage(event.eventType, event.payload);
-		res.write(frame);
-		onChunkSent?.();
-		if (signal?.aborted) return false;
-		chunkIndex++;
-	}
-	if (!res.writableEnded) res.end();
-	return true;
+	return runFrameLoop(httpSink(res), events, eventStreamCodec(), {
+		latency: opts.latency,
+		streamingProfile: opts.streamingProfile,
+		recordedTimings: opts.recordedTimings,
+		replaySpeed: opts.replaySpeed
+	}, {
+		signal: events.length > 0 ? opts.signal : void 0,
+		onChunkSent: opts.onChunkSent
+	});
+}
+function eventStreamCodec(encode) {
+	return {
+		headers: {
+			"Content-Type": "application/vnd.amazon.eventstream",
+			"Transfer-Encoding": "chunked"
+		},
+		encode: encode ?? ((event) => encodeEventStreamMessage(event.eventType, event.payload))
+	};
 }
 
 //#endregion
-export { encodeEventStreamFrame, encodeEventStreamMessage, writeEventStream };
+export { encodeEventStreamFrame, encodeEventStreamMessage, eventStreamCodec, writeEventStream };
 //# sourceMappingURL=aws-event-stream.js.map

package/dist/aws-event-stream.js.map

@@ -1 +1 @@
-{"version":3,"file":"aws-event-stream.js","names":[],"sources":["../src/aws-event-stream.ts"],"sourcesContent":["/**\n * AWS Event Stream binary frame encoder.\n *\n * Implements the AWS binary event stream framing protocol used by Bedrock's\n * streaming (invoke-with-response-stream) endpoint. Each frame carries a set of\n * string headers and a raw-bytes payload, wrapped in a prelude with CRC32\n * checksums for integrity.\n *\n * Binary frame layout:\n *   [total_length: 4B uint32-BE]\n *   [headers_length: 4B uint32-BE]\n *   [prelude_crc32: 4B CRC32 of first 8 bytes]\n *   [headers: variable]\n *   [payload: variable, raw JSON bytes]\n *   [message_crc32: 4B CRC32 of entire frame minus last 4 bytes]\n */\n\nimport { crc32 } from \"node:zlib\";\nimport type * as http from \"node:http\";\nimport type { StreamingProfile, RecordedTimings } from \"./types.js\";\nimport { delay, calculateDelay } from \"./sse-writer.js\";\n\n// ─── Header encoding ────────────────────────────────────────────────────────\n\nfunction encodeHeaders(headers: Record<string, string>): Buffer {\n  const parts: Buffer[] = [];\n  for (const [name, value] of Object.entries(headers)) {\n    const nameBytes = Buffer.from(name, \"utf8\");\n    const valueBytes = Buffer.from(value, \"utf8\");\n\n    // name_length (1 byte) + name + type (1 byte, 7 = STRING) +\n    // value_length (2 bytes BE) + value\n    const header = Buffer.alloc(1 + nameBytes.length + 1 + 2 + valueBytes.length);\n    let offset = 0;\n    header.writeUInt8(nameBytes.length, offset);\n    offset += 1;\n    nameBytes.copy(header, offset);\n    offset += nameBytes.length;\n    header.writeUInt8(7, offset); // STRING type\n    offset += 1;\n    header.writeUInt16BE(valueBytes.length, offset);\n    offset += 2;\n    valueBytes.copy(header, offset);\n\n    parts.push(header);\n  }\n  return Buffer.concat(parts);\n}\n\n// ─── Frame encoding ─────────────────────────────────────────────────────────\n\n/**\n * Encode a single AWS Event Stream binary frame with the given headers and\n * payload buffer.\n */\nexport function encodeEventStreamFrame(headers: Record<string, string>, payload: Buffer): Buffer {\n  const headersBuffer = encodeHeaders(headers);\n  const headersLength = headersBuffer.length;\n\n  // prelude (8) + prelude_crc (4) + headers + payload + message_crc (4)\n  const totalLength = 4 + 4 + 4 + headersLength + payload.length + 4;\n\n  const frame = Buffer.alloc(totalLength);\n  let offset = 0;\n\n  // Prelude\n  frame.writeUInt32BE(totalLength, offset);\n  offset += 4;\n  frame.writeUInt32BE(headersLength, offset);\n  offset += 4;\n\n  // Prelude CRC32 (covers first 8 bytes)\n  const preludeCrc = crc32(frame.subarray(0, 8));\n  frame.writeUInt32BE(preludeCrc >>> 0, offset);\n  offset += 4;\n\n  // Headers\n  headersBuffer.copy(frame, offset);\n  offset += headersLength;\n\n  // Payload\n  payload.copy(frame, offset);\n  offset += payload.length;\n\n  // Message CRC32 (covers entire frame minus last 4 bytes)\n  const messageCrc = crc32(frame.subarray(0, totalLength - 4));\n  frame.writeUInt32BE(messageCrc >>> 0, offset);\n\n  return frame;\n}\n\n// ─── Convenience wrappers ───────────────────────────────────────────────────\n\n/**\n * Encode an event-stream message with standard AWS headers for a JSON event.\n *\n * Sets `:content-type` = `application/json`, `:event-type` = eventType,\n * `:message-type` = `event`.\n */\nexport function encodeEventStreamMessage(eventType: string, jsonPayload: object): Buffer {\n  const headers: Record<string, string> = {\n    \":content-type\": \"application/json\",\n    \":event-type\": eventType,\n    \":message-type\": \"event\",\n  };\n  const payload = Buffer.from(JSON.stringify(jsonPayload), \"utf8\");\n  return encodeEventStreamFrame(headers, payload);\n}\n\n/**\n * Write a sequence of event-stream frames to an HTTP response with optional\n * timing control. Mirrors the writeSSEStream pattern from sse-writer.ts.\n *\n * Returns `true` when all events are written (including when the response\n * was already ended before writing began), or `false` if interrupted by\n * the provided abort signal.\n */\nexport async function writeEventStream(\n  res: http.ServerResponse,\n  events: Array<{ eventType: string; payload: object }>,\n  options?: {\n    latency?: number;\n    streamingProfile?: StreamingProfile;\n    recordedTimings?: RecordedTimings;\n    replaySpeed?: number;\n    signal?: AbortSignal;\n    onChunkSent?: () => void;\n  },\n): Promise<boolean> {\n  const opts = options ?? {};\n  const latency = opts.latency ?? 0;\n  const profile = opts.streamingProfile;\n  const { recordedTimings, replaySpeed } = opts;\n  const signal = opts.signal;\n  const onChunkSent = opts.onChunkSent;\n\n  if (res.writableEnded) return true;\n  res.setHeader(\"Content-Type\", \"application/vnd.amazon.eventstream\");\n  res.setHeader(\"Transfer-Encoding\", \"chunked\");\n\n  let chunkIndex = 0;\n  for (const event of events) {\n    const chunkDelay = calculateDelay(chunkIndex, profile, latency, recordedTimings, replaySpeed);\n    if (chunkDelay > 0) {\n      await delay(chunkDelay, signal);\n    }\n    if (signal?.aborted) return false;\n    if (res.writableEnded) return true;\n\n    const frame = encodeEventStreamMessage(event.eventType, event.payload);\n    res.write(frame);\n    onChunkSent?.();\n    if (signal?.aborted) return false;\n    chunkIndex++;\n  }\n\n  if (!res.writableEnded) {\n    res.end();\n  }\n  return true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwBA,SAAS,cAAc,SAAyC;CAC9D,MAAM,QAAkB,EAAE;AAC1B,MAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,QAAQ,EAAE;EACnD,MAAM,YAAY,OAAO,KAAK,MAAM,OAAO;EAC3C,MAAM,aAAa,OAAO,KAAK,OAAO,OAAO;EAI7C,MAAM,SAAS,OAAO,MAAM,IAAI,UAAU,SAAS,IAAI,IAAI,WAAW,OAAO;EAC7E,IAAI,SAAS;AACb,SAAO,WAAW,UAAU,QAAQ,OAAO;AAC3C,YAAU;AACV,YAAU,KAAK,QAAQ,OAAO;AAC9B,YAAU,UAAU;AACpB,SAAO,WAAW,GAAG,OAAO;AAC5B,YAAU;AACV,SAAO,cAAc,WAAW,QAAQ,OAAO;AAC/C,YAAU;AACV,aAAW,KAAK,QAAQ,OAAO;AAE/B,QAAM,KAAK,OAAO;;AAEpB,QAAO,OAAO,OAAO,MAAM;;;;;;AAS7B,SAAgB,uBAAuB,SAAiC,SAAyB;CAC/F,MAAM,gBAAgB,cAAc,QAAQ;CAC5C,MAAM,gBAAgB,cAAc;CAGpC,MAAM,cAAc,KAAY,gBAAgB,QAAQ,SAAS;CAEjE,MAAM,QAAQ,OAAO,MAAM,YAAY;CACvC,IAAI,SAAS;AAGb,OAAM,cAAc,aAAa,OAAO;AACxC,WAAU;AACV,OAAM,cAAc,eAAe,OAAO;AAC1C,WAAU;CAGV,MAAM,aAAa,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAC9C,OAAM,cAAc,eAAe,GAAG,OAAO;AAC7C,WAAU;AAGV,eAAc,KAAK,OAAO,OAAO;AACjC,WAAU;AAGV,SAAQ,KAAK,OAAO,OAAO;AAC3B,WAAU,QAAQ;CAGlB,MAAM,aAAa,MAAM,MAAM,SAAS,GAAG,cAAc,EAAE,CAAC;AAC5D,OAAM,cAAc,eAAe,GAAG,OAAO;AAE7C,QAAO;;;;;;;;AAWT,SAAgB,yBAAyB,WAAmB,aAA6B;AAOvF,QAAO,uBANiC;EACtC,iBAAiB;EACjB,eAAe;EACf,iBAAiB;EAClB,EACe,OAAO,KAAK,KAAK,UAAU,YAAY,EAAE,OAAO,CACjB;;;;;;;;;;AAWjD,eAAsB,iBACpB,KACA,QACA,SAQkB;CAClB,MAAM,OAAO,WAAW,EAAE;CAC1B,MAAM,UAAU,KAAK,WAAW;CAChC,MAAM,UAAU,KAAK;CACrB,MAAM,EAAE,iBAAiB,gBAAgB;CACzC,MAAM,SAAS,KAAK;CACpB,MAAM,cAAc,KAAK;AAEzB,KAAI,IAAI,cAAe,QAAO;AAC9B,KAAI,UAAU,gBAAgB,qCAAqC;AACnE,KAAI,UAAU,qBAAqB,UAAU;CAE7C,IAAI,aAAa;AACjB,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,aAAa,eAAe,YAAY,SAAS,SAAS,iBAAiB,YAAY;AAC7F,MAAI,aAAa,EACf,OAAM,MAAM,YAAY,OAAO;AAEjC,MAAI,QAAQ,QAAS,QAAO;AAC5B,MAAI,IAAI,cAAe,QAAO;EAE9B,MAAM,QAAQ,yBAAyB,MAAM,WAAW,MAAM,QAAQ;AACtE,MAAI,MAAM,MAAM;AAChB,iBAAe;AACf,MAAI,QAAQ,QAAS,QAAO;AAC5B;;AAGF,KAAI,CAAC,IAAI,cACP,KAAI,KAAK;AAEX,QAAO"}
+{"version":3,"file":"aws-event-stream.js","names":[],"sources":["../src/aws-event-stream.ts"],"sourcesContent":["/**\n * AWS Event Stream binary frame encoder.\n *\n * Implements the AWS binary event stream framing protocol used by Bedrock's\n * streaming (invoke-with-response-stream) endpoint. Each frame carries a set of\n * string headers and a raw-bytes payload, wrapped in a prelude with CRC32\n * checksums for integrity.\n *\n * Binary frame layout:\n *   [total_length: 4B uint32-BE]\n *   [headers_length: 4B uint32-BE]\n *   [prelude_crc32: 4B CRC32 of first 8 bytes]\n *   [headers: variable]\n *   [payload: variable, raw JSON bytes]\n *   [message_crc32: 4B CRC32 of entire frame minus last 4 bytes]\n */\n\nimport { crc32 } from \"node:zlib\";\nimport type * as http from \"node:http\";\nimport type { StreamingProfile, RecordedTimings } from \"./types.js\";\nimport { httpSink, runFrameLoop, type FrameCodec } from \"./response/frame-loop.js\";\n\n// ─── Header encoding ────────────────────────────────────────────────────────\n\nfunction encodeHeaders(headers: Record<string, string>): Buffer {\n  const parts: Buffer[] = [];\n  for (const [name, value] of Object.entries(headers)) {\n    const nameBytes = Buffer.from(name, \"utf8\");\n    const valueBytes = Buffer.from(value, \"utf8\");\n\n    // name_length (1 byte) + name + type (1 byte, 7 = STRING) +\n    // value_length (2 bytes BE) + value\n    const header = Buffer.alloc(1 + nameBytes.length + 1 + 2 + valueBytes.length);\n    let offset = 0;\n    header.writeUInt8(nameBytes.length, offset);\n    offset += 1;\n    nameBytes.copy(header, offset);\n    offset += nameBytes.length;\n    header.writeUInt8(7, offset); // STRING type\n    offset += 1;\n    header.writeUInt16BE(valueBytes.length, offset);\n    offset += 2;\n    valueBytes.copy(header, offset);\n\n    parts.push(header);\n  }\n  return Buffer.concat(parts);\n}\n\n// ─── Frame encoding ─────────────────────────────────────────────────────────\n\n/**\n * Encode a single AWS Event Stream binary frame with the given headers and\n * payload buffer.\n */\nexport function encodeEventStreamFrame(headers: Record<string, string>, payload: Buffer): Buffer {\n  const headersBuffer = encodeHeaders(headers);\n  const headersLength = headersBuffer.length;\n\n  // prelude (8) + prelude_crc (4) + headers + payload + message_crc (4)\n  const totalLength = 4 + 4 + 4 + headersLength + payload.length + 4;\n\n  const frame = Buffer.alloc(totalLength);\n  let offset = 0;\n\n  // Prelude\n  frame.writeUInt32BE(totalLength, offset);\n  offset += 4;\n  frame.writeUInt32BE(headersLength, offset);\n  offset += 4;\n\n  // Prelude CRC32 (covers first 8 bytes)\n  const preludeCrc = crc32(frame.subarray(0, 8));\n  frame.writeUInt32BE(preludeCrc >>> 0, offset);\n  offset += 4;\n\n  // Headers\n  headersBuffer.copy(frame, offset);\n  offset += headersLength;\n\n  // Payload\n  payload.copy(frame, offset);\n  offset += payload.length;\n\n  // Message CRC32 (covers entire frame minus last 4 bytes)\n  const messageCrc = crc32(frame.subarray(0, totalLength - 4));\n  frame.writeUInt32BE(messageCrc >>> 0, offset);\n\n  return frame;\n}\n\n// ─── Convenience wrappers ───────────────────────────────────────────────────\n\n/**\n * Encode an event-stream message with standard AWS headers for a JSON event.\n *\n * Sets `:content-type` = `application/json`, `:event-type` = eventType,\n * `:message-type` = `event`.\n */\nexport function encodeEventStreamMessage(eventType: string, jsonPayload: object): Buffer {\n  const headers: Record<string, string> = {\n    \":content-type\": \"application/json\",\n    \":event-type\": eventType,\n    \":message-type\": \"event\",\n  };\n  const payload = Buffer.from(JSON.stringify(jsonPayload), \"utf8\");\n  return encodeEventStreamFrame(headers, payload);\n}\n\n/**\n * Write a sequence of event-stream frames to an HTTP response with optional\n * timing control. Mirrors the writeSSEStream pattern from sse-writer.ts.\n *\n * Returns `true` when all events are written (including when the response\n * was already ended before writing began), or `false` if interrupted by\n * the provided abort signal.\n */\nexport async function writeEventStream(\n  res: http.ServerResponse,\n  events: Array<{ eventType: string; payload: object }>,\n  options?: {\n    latency?: number;\n    streamingProfile?: StreamingProfile;\n    recordedTimings?: RecordedTimings;\n    replaySpeed?: number;\n    signal?: AbortSignal;\n    onChunkSent?: () => void;\n  },\n): Promise<boolean> {\n  const opts = options ?? {};\n  // Base contract (public API): with no frames, an aborted signal does not\n  // stop the writer; it still finishes the stream (any trailer, then end())\n  // and returns true. The frame loop returns false there, so pass it no\n  // signal when there are no frames (it reads the signal only per frame and\n  // after the loop).\n  return runFrameLoop(\n    httpSink(res),\n    events,\n    eventStreamCodec(),\n    {\n      latency: opts.latency,\n      streamingProfile: opts.streamingProfile,\n      recordedTimings: opts.recordedTimings,\n      replaySpeed: opts.replaySpeed,\n    },\n    { signal: events.length > 0 ? opts.signal : undefined, onChunkSent: opts.onChunkSent },\n  );\n}\n\n// Internal (not part of the public API): the AWS binary event-stream codec.\n// Each event becomes one complete frame, encoded by encodeEventStreamMessage\n// unless an `encode` argument replaces it. There is no prelude or trailer.\n// These are line comments, not JSDoc, so the bundled .d.ts does not attach\n// them to a public declaration.\nexport function eventStreamCodec<F extends { eventType: string; payload: object }>(\n  encode?: (event: F) => Buffer,\n): FrameCodec<F> {\n  return {\n    headers: {\n      \"Content-Type\": \"application/vnd.amazon.eventstream\",\n      \"Transfer-Encoding\": \"chunked\",\n    },\n    encode: encode ?? ((event) => encodeEventStreamMessage(event.eventType, event.payload)),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAwBA,SAAS,cAAc,SAAyC;CAC9D,MAAM,QAAkB,EAAE;AAC1B,MAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,QAAQ,EAAE;EACnD,MAAM,YAAY,OAAO,KAAK,MAAM,OAAO;EAC3C,MAAM,aAAa,OAAO,KAAK,OAAO,OAAO;EAI7C,MAAM,SAAS,OAAO,MAAM,IAAI,UAAU,SAAS,IAAI,IAAI,WAAW,OAAO;EAC7E,IAAI,SAAS;AACb,SAAO,WAAW,UAAU,QAAQ,OAAO;AAC3C,YAAU;AACV,YAAU,KAAK,QAAQ,OAAO;AAC9B,YAAU,UAAU;AACpB,SAAO,WAAW,GAAG,OAAO;AAC5B,YAAU;AACV,SAAO,cAAc,WAAW,QAAQ,OAAO;AAC/C,YAAU;AACV,aAAW,KAAK,QAAQ,OAAO;AAE/B,QAAM,KAAK,OAAO;;AAEpB,QAAO,OAAO,OAAO,MAAM;;;;;;AAS7B,SAAgB,uBAAuB,SAAiC,SAAyB;CAC/F,MAAM,gBAAgB,cAAc,QAAQ;CAC5C,MAAM,gBAAgB,cAAc;CAGpC,MAAM,cAAc,KAAY,gBAAgB,QAAQ,SAAS;CAEjE,MAAM,QAAQ,OAAO,MAAM,YAAY;CACvC,IAAI,SAAS;AAGb,OAAM,cAAc,aAAa,OAAO;AACxC,WAAU;AACV,OAAM,cAAc,eAAe,OAAO;AAC1C,WAAU;CAGV,MAAM,aAAa,MAAM,MAAM,SAAS,GAAG,EAAE,CAAC;AAC9C,OAAM,cAAc,eAAe,GAAG,OAAO;AAC7C,WAAU;AAGV,eAAc,KAAK,OAAO,OAAO;AACjC,WAAU;AAGV,SAAQ,KAAK,OAAO,OAAO;AAC3B,WAAU,QAAQ;CAGlB,MAAM,aAAa,MAAM,MAAM,SAAS,GAAG,cAAc,EAAE,CAAC;AAC5D,OAAM,cAAc,eAAe,GAAG,OAAO;AAE7C,QAAO;;;;;;;;AAWT,SAAgB,yBAAyB,WAAmB,aAA6B;AAOvF,QAAO,uBANiC;EACtC,iBAAiB;EACjB,eAAe;EACf,iBAAiB;EAClB,EACe,OAAO,KAAK,KAAK,UAAU,YAAY,EAAE,OAAO,CACjB;;;;;;;;;;AAWjD,eAAsB,iBACpB,KACA,QACA,SAQkB;CAClB,MAAM,OAAO,WAAW,EAAE;AAM1B,QAAO,aACL,SAAS,IAAI,EACb,QACA,kBAAkB,EAClB;EACE,SAAS,KAAK;EACd,kBAAkB,KAAK;EACvB,iBAAiB,KAAK;EACtB,aAAa,KAAK;EACnB,EACD;EAAE,QAAQ,OAAO,SAAS,IAAI,KAAK,SAAS;EAAW,aAAa,KAAK;EAAa,CACvF;;AAQH,SAAgB,iBACd,QACe;AACf,QAAO;EACL,SAAS;GACP,gBAAgB;GAChB,qBAAqB;GACtB;EACD,QAAQ,YAAY,UAAU,yBAAyB,MAAM,WAAW,MAAM,QAAQ;EACvF"}

package/dist/bedrock-converse.cjs

@@ -6,9 +6,12 @@ const require_chaos = require('./chaos.cjs');
 const require_misbehavior = require('./misbehavior.cjs');
 const require_router = require('./router.cjs');
 const require_recorder = require('./recorder.cjs');
-const require_interruption = require('./interruption.cjs');
-const require_finish = require('./response/finish.cjs');
+const require_timing = require('./response/timing.cjs');
+const require_deliver = require('./response/deliver.cjs');
+const require_proxy = require('./response/proxy.cjs');
 const require_aws_event_stream = require('./aws-event-stream.cjs');
+const require_raw = require('./response/raw.cjs');
+const require_finish = require('./response/finish.cjs');
 const require_converse = require('./response/usage/codecs/converse.cjs');
 
 //#region src/bedrock-converse.ts
@@ -685,7 +688,10 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 	completionReq._endpointType = "chat";
 	completionReq._context = require_helpers.getContext(req);
 	const testId = require_helpers.getTestId(req);
-	const { fixture, skippedBySequenceOrTurn } = require_router.matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, require_router.recordMatchOptions(!!defaults.record, defaults.logger));
+	const { fixture, skippedBySequenceOrTurn } = require_router.matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, {
+		...require_router.recordMatchOptions(!!defaults.record, defaults.logger),
+		wire: "bedrock-converse"
+	});
 	if (fixture) logger.debug(`Fixture matched: ${JSON.stringify(fixture.match).slice(0, 120)}`);
 	else logger.debug(`No fixture matched for request`);
 	if (fixture) journal.incrementFixtureMatchCount(fixture, fixtures, testId);
@@ -718,7 +724,7 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 			return;
 		}
 		if (defaults.record) {
-			const outcome = await require_recorder.proxyAndRecord(req, res, completionReq, "bedrock", urlPath, fixtures, defaults, raw);
+			const { outcome, clientHungUp } = await require_proxy.withHangUpDetection(req, res, () => require_recorder.proxyAndRecord(req, res, completionReq, "bedrock", urlPath, fixtures, defaults, raw));
 			if (outcome === "handled_by_hook") return;
 			if (outcome !== "not_configured") {
 				journal.add({
@@ -729,7 +735,8 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 					response: {
 						status: res.statusCode ?? 200,
 						fixture: null,
-						source: "proxy"
+						source: "proxy",
+						...require_proxy.proxyInterruption(res, clientHungUp)
 					}
 				});
 				return;
@@ -796,11 +803,19 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 		}).body);
 		return;
 	}
+	const jsonOpts = (payloadLength, duplicateId = false) => ({
+		surface: "other",
+		payloadLength,
+		chunkSize: Math.max(1, fixture.chunkSize ?? defaults.chunkSize),
+		recordedTimings: fixture.recordedTimings,
+		duplicateId,
+		replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed
+	});
 	if (misbehavior.kind === "applied") {
 		const prepared = prepareConverseMisbehavior(misbehavior, completionReq, false, defaults, req.headers);
 		misbehavior = prepared.plan;
 		const body = buildConverseMisbehaviorResponse(prepared);
-		addResponseEntry({
+		await require_deliver.deliverJson(res, addResponseEntry({
 			method: req.method ?? "POST",
 			path: urlPath,
 			headers: require_helpers.flattenHeaders(req.headers),
@@ -809,9 +824,24 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 				status: 200,
 				fixture
 			}
+		}), fixture, () => body, jsonOpts(require_timing.misbehaviorPayloadLength(prepared.plan, prepared.plan.reasoning === void 0 ? prepared.reasoning : void 0), !!prepared.plan.duplicateId));
+		return;
+	}
+	if (require_helpers.isRawResponse(response)) {
+		await require_raw.serveRawResponse({
+			wire: "bedrock-converse",
+			stream: false,
+			req,
+			res,
+			fixture,
+			response,
+			body: completionReq,
+			journal,
+			defaults,
+			testId,
+			misbehaviorSummary: misbehavior.summary,
+			errorWire: "bedrock-converse"
 		});
-		res.writeHead(200, { "Content-Type": "application/json" });
-		res.end(JSON.stringify(body));
 		return;
 	}
 	if (require_helpers.isErrorResponse(response)) {
@@ -836,7 +866,7 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Bedrock Converse API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, completionReq.model, require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression, logger);
-		addResponseEntry({
+		const journalEntry = addResponseEntry({
 			method: req.method ?? "POST",
 			path: urlPath,
 			headers: require_helpers.flattenHeaders(req.headers),
@@ -847,16 +877,14 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 			}
 		});
 		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, "Bedrock Converse");
-		const body = buildConverseContentWithToolCallsResponse(response.content ?? "", functionToolCalls, logger, effReasoning, overrides, response.blocks);
-		res.writeHead(200, { "Content-Type": "application/json" });
-		res.end(JSON.stringify(body));
+		await require_deliver.deliverJson(res, journalEntry, fixture, () => buildConverseContentWithToolCallsResponse(response.content ?? "", functionToolCalls, logger, effReasoning, overrides, response.blocks), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
 		return;
 	}
 	if (require_helpers.isTextResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Bedrock Converse API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, completionReq.model, require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression, logger);
-		addResponseEntry({
+		await require_deliver.deliverJson(res, addResponseEntry({
 			method: req.method ?? "POST",
 			path: urlPath,
 			headers: require_helpers.flattenHeaders(req.headers),
@@ -865,17 +893,14 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 				status: 200,
 				fixture
 			}
-		});
-		const body = buildConverseTextResponse(response.content, effReasoning, overrides);
-		res.writeHead(200, { "Content-Type": "application/json" });
-		res.end(JSON.stringify(body));
+		}), fixture, () => buildConverseTextResponse(response.content, effReasoning, overrides), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
 		return;
 	}
 	if (require_helpers.isToolCallResponse(response)) {
 		if (response.webSearches?.length) logger.warn("webSearches in fixture response are not supported for Bedrock Converse API — ignoring");
 		const overrides = require_helpers.extractOverrides(response);
 		const effReasoning = require_helpers.resolveReasoningForModel(response.reasoning, completionReq.model, require_policy.resolveRequestDecisions(defaults.strict, req.headers).reasoningSuppression, logger);
-		addResponseEntry({
+		const journalEntry = addResponseEntry({
 			method: req.method ?? "POST",
 			path: urlPath,
 			headers: require_helpers.flattenHeaders(req.headers),
@@ -885,9 +910,8 @@ async function handleConverse(req, res, raw, modelId, fixtures, journal, default
 				fixture
 			}
 		});
-		const body = buildConverseToolCallResponse(require_helpers.requireEmittedFunctionToolCalls(response, "Bedrock Converse"), logger, effReasoning, overrides);
-		res.writeHead(200, { "Content-Type": "application/json" });
-		res.end(JSON.stringify(body));
+		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, "Bedrock Converse");
+		await require_deliver.deliverJson(res, journalEntry, fixture, () => buildConverseToolCallResponse(functionToolCalls, logger, effReasoning, overrides), jsonOpts(require_timing.servedPayloadLength(response, effReasoning)));
 		return;
 	}
 	addResponseEntry({
@@ -970,7 +994,10 @@ async function handleConverseStream(req, res, raw, modelId, fixtures, journal, d
 	completionReq._endpointType = "chat";
 	completionReq._context = require_helpers.getContext(req);
 	const testId = require_helpers.getTestId(req);
-	const { fixture, skippedBySequenceOrTurn } = require_router.matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, require_router.recordMatchOptions(!!defaults.record, defaults.logger));
+	const { fixture, skippedBySequenceOrTurn } = require_router.matchFixtureDiagnostic(fixtures, completionReq, journal.getFixtureMatchCountsForTest(testId), defaults.requestTransform, {
+		...require_router.recordMatchOptions(!!defaults.record, defaults.logger),
+		wire: "bedrock-converse"
+	});
 	if (fixture) logger.debug(`Fixture matched: ${JSON.stringify(fixture.match).slice(0, 120)}`);
 	else logger.debug(`No fixture matched for request`);
 	if (fixture) journal.incrementFixtureMatchCount(fixture, fixtures, testId);
@@ -1003,7 +1030,7 @@ async function handleConverseStream(req, res, raw, modelId, fixtures, journal, d
 			return;
 		}
 		if (defaults.record) {
-			const outcome = await require_recorder.proxyAndRecord(req, res, completionReq, "bedrock", urlPath, fixtures, defaults, raw);
+			const { outcome, clientHungUp } = await require_proxy.withHangUpDetection(req, res, () => require_recorder.proxyAndRecord(req, res, completionReq, "bedrock", urlPath, fixtures, defaults, raw));
 			if (outcome === "handled_by_hook") return;
 			if (outcome !== "not_configured") {
 				journal.add({
@@ -1014,7 +1041,8 @@ async function handleConverseStream(req, res, raw, modelId, fixtures, journal, d
 					response: {
 						status: res.statusCode ?? 200,
 						fixture: null,
-						source: "proxy"
+						source: "proxy",
+						...require_proxy.proxyInterruption(res, clientHungUp)
 					}
 				});
 				return;
@@ -1081,13 +1109,18 @@ async function handleConverseStream(req, res, raw, modelId, fixtures, journal, d
 		}).body);
 		return;
 	}
-	const latency = fixture.latency ?? defaults.latency;
 	const chunkSize = Math.max(1, fixture.chunkSize ?? defaults.chunkSize);
+	const streamTiming = {
+		latency: fixture.latency ?? defaults.latency,
+		streamingProfile: fixture.streamingProfile,
+		recordedTimings: fixture.recordedTimings,
+		replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed
+	};
 	if (misbehavior.kind === "applied") {
 		const prepared = prepareConverseMisbehavior(misbehavior, completionReq, true, defaults, req.headers);
 		misbehavior = prepared.plan;
 		const events = buildConverseMisbehaviorEvents(prepared, chunkSize);
-		const entry = addResponseEntry({
+		await require_deliver.deliverStream(res, addResponseEntry({
 			method: req.method ?? "POST",
 			path: urlPath,
 			headers: require_helpers.flattenHeaders(req.headers),
@@ -1096,21 +1129,24 @@ async function handleConverseStream(req, res, raw, modelId, fixtures, journal, d
 				status: 200,
 				fixture
 			}
+		}), fixture, require_aws_event_stream.eventStreamCodec(), events, streamTiming);
+		return;
+	}
+	if (require_helpers.isRawResponse(response)) {
+		await require_raw.serveRawResponse({
+			wire: "bedrock-converse",
+			stream: true,
+			req,
+			res,
+			fixture,
+			response,
+			body: completionReq,
+			journal,
+			defaults,
+			testId,
+			misbehaviorSummary: misbehavior.summary,
+			errorWire: "bedrock-converse"
 		});
-		const interruption = require_interruption.createInterruptionSignal(fixture);
-		if (!await require_aws_event_stream.writeEventStream(res, events, {
-			latency,
-			streamingProfile: fixture.streamingProfile,
-			recordedTimings: fixture.recordedTimings,
-			replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
-			signal: interruption?.signal,
-			onChunkSent: interruption?.tick
-		})) {
-			if (!res.writableEnded) res.destroy();
-			entry.response.interrupted = true;
-			entry.response.interruptReason = interruption?.reason();
-		}
-		interruption?.cleanup();
 		return;
 	}
 	if (require_helpers.isErrorResponse(response)) {
@@ -1147,20 +1183,7 @@ async function handleConverseStream(req, res, raw, modelId, fixtures, journal, d
 		});
 		const functionToolCalls = require_helpers.requireEmittedFunctionToolCalls(response, "Bedrock Converse");
 		const events = buildBedrockStreamContentWithToolCallsEvents(response.content ?? "", functionToolCalls, chunkSize, logger, effReasoning, overrides, response.blocks);
-		const interruption = require_interruption.createInterruptionSignal(fixture);
-		if (!await require_aws_event_stream.writeEventStream(res, events, {
-			latency,
-			streamingProfile: fixture.streamingProfile,
-			recordedTimings: fixture.recordedTimings,
-			replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
-			signal: interruption?.signal,
-			onChunkSent: interruption?.tick
-		})) {
-			if (!res.writableEnded) res.destroy();
-			journalEntry.response.interrupted = true;
-			journalEntry.response.interruptReason = interruption?.reason();
-		}
-		interruption?.cleanup();
+		await require_deliver.deliverStream(res, journalEntry, fixture, require_aws_event_stream.eventStreamCodec(), events, streamTiming);
 		return;
 	}
 	if (require_helpers.isTextResponse(response)) {
@@ -1178,20 +1201,7 @@ async function handleConverseStream(req, res, raw, modelId, fixtures, journal, d
 			}
 		});
 		const events = buildBedrockStreamTextEvents(response.content, chunkSize, effReasoning, overrides);
-		const interruption = require_interruption.createInterruptionSignal(fixture);
-		if (!await require_aws_event_stream.writeEventStream(res, events, {
-			latency,
-			streamingProfile: fixture.streamingProfile,
-			recordedTimings: fixture.recordedTimings,
-			replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
-			signal: interruption?.signal,
-			onChunkSent: interruption?.tick
-		})) {
-			if (!res.writableEnded) res.destroy();
-			journalEntry.response.interrupted = true;
-			journalEntry.response.interruptReason = interruption?.reason();
-		}
-		interruption?.cleanup();
+		await require_deliver.deliverStream(res, journalEntry, fixture, require_aws_event_stream.eventStreamCodec(), events, streamTiming);
 		return;
 	}
 	if (require_helpers.isToolCallResponse(response)) {
@@ -1209,20 +1219,7 @@ async function handleConverseStream(req, res, raw, modelId, fixtures, journal, d
 			}
 		});
 		const events = buildBedrockStreamToolCallEvents(require_helpers.requireEmittedFunctionToolCalls(response, "Bedrock Converse"), chunkSize, logger, effReasoning, overrides);
-		const interruption = require_interruption.createInterruptionSignal(fixture);
-		if (!await require_aws_event_stream.writeEventStream(res, events, {
-			latency,
-			streamingProfile: fixture.streamingProfile,
-			recordedTimings: fixture.recordedTimings,
-			replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
-			signal: interruption?.signal,
-			onChunkSent: interruption?.tick
-		})) {
-			if (!res.writableEnded) res.destroy();
-			journalEntry.response.interrupted = true;
-			journalEntry.response.interruptReason = interruption?.reason();
-		}
-		interruption?.cleanup();
+		await require_deliver.deliverStream(res, journalEntry, fixture, require_aws_event_stream.eventStreamCodec(), events, streamTiming);
 		return;
 	}
 	addResponseEntry({