@copilotkit/aimock 1.45.1 → 1.47.0

package/dist/response/raw.js

@@ -0,0 +1,227 @@
+import { renderError } from "./errors.js";
+import { flattenHeaders } from "../helpers.js";
+import { checkRawResponse } from "../raw-validation.js";
+import { sseCodec, writeErrorResponse } from "../sse-writer.js";
+import { recordMisbehaviorOutcome } from "../misbehavior.js";
+import { rawFixtureContext } from "../fixture-loader.js";
+import { deliverJson, deliverStream } from "./deliver.js";
+import { encodeEventStreamMessage, eventStreamCodec } from "../aws-event-stream.js";
+import { serializeOpenRouterError } from "../openrouter-chat.js";
+import { ndjsonCodec } from "../ndjson-writer.js";
+
+//#region src/response/raw.ts
+/**
+* The default headers of the typed stream on `wire`, read from the typed
+* codec: SSE and NDJSON add `Cache-Control: no-cache` and
+* `Connection: keep-alive`, the AWS event stream `Transfer-Encoding: chunked`.
+*/
+function rawStreamHeaders(wire) {
+	switch (wire) {
+		case "openai-responses":
+		case "openai-chat":
+		case "anthropic":
+		case "gemini":
+		case "gemini-interactions":
+		case "cohere": return sseCodec({ done: false }).headers;
+		case "ollama":
+		case "ollama-generate": return ndjsonCodec().headers;
+		case "bedrock-invoke":
+		case "bedrock-converse": return eventStreamCodec().headers;
+	}
+}
+/** The non-streaming JSON default, as `deliverJson` sends it. */
+const JSON_HEADERS = { "Content-Type": "application/json" };
+/**
+* `defaults` with each `authored` header laid over it. Header names are
+* case-insensitive: an authored header replaces the default of the same name
+* in any letter case and takes the default's spelling, so a later spread over
+* the same defaults (as `deliverJson` does) still has one key per name.
+*/
+function overrideHeaders(defaults, authored) {
+	const merged = { ...defaults };
+	const spelling = new Map(Object.keys(defaults).map((name) => [name.toLowerCase(), name]));
+	for (const [name, value] of Object.entries(authored ?? {})) merged[spelling.get(name.toLowerCase()) ?? name] = value;
+	return merged;
+}
+/** One raw event, framed for `wire`. Events are checked before framing (raw-validation.ts). */
+function encodeRawFrame(wire, event) {
+	const json = JSON.stringify(event);
+	switch (wire) {
+		case "openai-responses":
+		case "anthropic":
+		case "cohere": return `event: ${String(event.type)}\ndata: ${json}\n\n`;
+		case "openai-chat":
+		case "gemini":
+		case "gemini-interactions": return `data: ${json}\n\n`;
+		case "ollama":
+		case "ollama-generate": return `${json}\n`;
+		case "bedrock-invoke": return encodeEventStreamMessage("chunk", { bytes: Buffer.from(json, "utf8").toString("base64") });
+		case "bedrock-converse": {
+			const [eventType] = Object.keys(event);
+			const payload = event[eventType];
+			if (payload === null || typeof payload !== "object" || Array.isArray(payload)) throw new Error(`raw framing internal error: bedrock-converse event "${eventType}" has no object payload`);
+			return encodeEventStreamMessage(eventType, payload);
+		}
+	}
+}
+/**
+* Bytes written after the last frame, if any. Only `openai-chat` has a
+* terminal (`data: [DONE]`), sent unless `raw.done === false` and never after
+* an interrupted stream.
+*/
+function rawTrailer(wire, raw, aborted) {
+	if (wire === "openai-chat" && !aborted && raw.done !== false) return "data: [DONE]\n\n";
+}
+/** The error code for a request the raw fixture has no body for. */
+const RAW_MODE_UNAVAILABLE = "aimock_raw_mode_unavailable";
+/** The error code for a raw fixture that fails its checks or targets another wire. */
+const RAW_FIXTURE_INVALID = "aimock_raw_fixture_invalid";
+/**
+* The raw events as a frame codec for the shared frame loop. Its headers are
+* the typed stream's defaults for `wire` with `raw.headers` laid over them.
+*/
+function rawCodec(wire, raw) {
+	return {
+		headers: overrideHeaders(rawStreamHeaders(wire), raw.headers),
+		encode: (event) => encodeRawFrame(wire, event),
+		trailer: (aborted) => {
+			const trailer = rawTrailer(wire, raw, aborted);
+			return trailer === void 0 ? [] : [trailer];
+		}
+	};
+}
+/**
+* The error body for a raw 500, in the dialect of the handler's misbehavior
+* errors. Dialects with no code slot (Gemini, Ollama, OpenRouter) carry the
+* code as a message prefix.
+*/
+function renderRawError(ctx, code, message) {
+	if (ctx.openRouter) return { body: serializeOpenRouterError(500, `${code}: ${message}`) };
+	switch (ctx.errorWire) {
+		case "openai": return renderError("openai", "misbehavior", {
+			message,
+			type: "server_error",
+			...ctx.wire === "openai-chat" ? {
+				param: null,
+				includeParam: true
+			} : {},
+			code
+		});
+		case "messages": return renderError("messages", "misbehavior", {
+			type: "api_error",
+			code,
+			message
+		});
+		case "gemini": return renderError("gemini", "misbehavior", {
+			bodyCode: 500,
+			message: `${code}: ${message}`,
+			status: "INTERNAL"
+		});
+		case "bedrock":
+		case "bedrock-converse": return renderError(ctx.errorWire, "misbehavior", {
+			type: "InternalServerException",
+			code,
+			message
+		});
+		default: return renderError(ctx.errorWire, "misbehavior", {
+			code,
+			message
+		});
+	}
+}
+/**
+* Serve a raw passthrough fixture on the handler's wire: check it, journal it,
+* and send its events or JSON through the shared delivery layer. A fixture
+* that fails a check, targets another wire, or has no body for the requested
+* mode gets a 500 in the handler's misbehavior error dialect, and an error log
+* line. A reply with status 400 or more is never delayed, streaming or not,
+* and one with `json` answers in JSON even to a streaming request.
+*/
+async function serveRawResponse(ctx) {
+	const { wire, stream, req, res, fixture, journal, defaults, testId } = ctx;
+	const raw = ctx.response.raw;
+	const journalBase = {
+		method: req.method ?? "POST",
+		path: req.url ?? "/",
+		headers: flattenHeaders(req.headers),
+		body: ctx.body
+	};
+	const record = (entry) => recordMisbehaviorOutcome({
+		entry,
+		summary: ctx.misbehaviorSummary,
+		defaults,
+		testId
+	});
+	const status = raw.status ?? 200;
+	const errorReply = status >= 400;
+	const servesStream = stream && !(errorReply && raw.json !== void 0);
+	let failure;
+	const problems = checkRawResponse(raw, rawFixtureContext(fixture, ctx.response)).filter((finding) => finding.severity === "error");
+	if (problems.length > 0) failure = {
+		code: RAW_FIXTURE_INVALID,
+		message: `invalid raw fixture: ${problems.map((p) => p.message).join("; ")}`
+	};
+	else if (raw.wire !== wire) failure = {
+		code: RAW_FIXTURE_INVALID,
+		message: `raw fixture is for ${raw.wire}, not ${wire}`
+	};
+	else if (servesStream ? raw.events === void 0 : raw.json === void 0) failure = {
+		code: RAW_MODE_UNAVAILABLE,
+		message: `raw fixture has no "${servesStream ? "events" : "json"}" body for a ${servesStream ? "streaming" : "non-streaming"} request on ${wire}`
+	};
+	if (failure) {
+		defaults.logger.error(`${journalBase.method} ${journalBase.path}: ${failure.message}`);
+		const entry = journal.add({
+			...journalBase,
+			response: {
+				status: 500,
+				fixture
+			}
+		});
+		entry.response.error = failure.message;
+		record(entry);
+		const rendered = renderRawError(ctx, failure.code, failure.message);
+		for (const [name, value] of Object.entries(rendered.headers ?? {})) res.setHeader(name, value);
+		writeErrorResponse(res, 500, rendered.body);
+		return;
+	}
+	const entry = journal.add({
+		...journalBase,
+		response: {
+			status,
+			fixture
+		}
+	});
+	record(entry);
+	if (servesStream) {
+		const events = raw.events;
+		if (events === void 0) throw new Error(`raw serve internal error: a streamed reply on ${wire} has no events`);
+		await deliverStream(res, entry, fixture, rawCodec(wire, raw), events, errorReply ? { latency: 0 } : {
+			latency: fixture.latency ?? defaults.latency,
+			streamingProfile: fixture.streamingProfile,
+			recordedTimings: fixture.recordedTimings,
+			replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed
+		}, { status: raw.status });
+		return;
+	}
+	const json = raw.json;
+	if (json === void 0) throw new Error(`raw serve internal error: a JSON reply on ${wire} has no json`);
+	const servedLength = JSON.stringify(json).length;
+	await deliverJson(res, entry, errorReply ? {
+		...fixture,
+		nonStreamingTiming: false,
+		nonStreamingTimingAllProviders: false
+	} : fixture, () => json, {
+		surface: wire === "openai-chat" ? "openai-chat" : "other",
+		status: raw.status,
+		payloadLength: servedLength,
+		chunkSize: Math.max(1, fixture.chunkSize ?? defaults.chunkSize),
+		recordedTimings: fixture.recordedTimings,
+		replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,
+		headers: overrideHeaders(JSON_HEADERS, raw.headers)
+	});
+}
+
+//#endregion
+export { RAW_MODE_UNAVAILABLE, serveRawResponse };
+//# sourceMappingURL=raw.js.map

package/dist/response/raw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"raw.js","names":[],"sources":["../../src/response/raw.ts"],"sourcesContent":["/**\n * @internal Raw passthrough fixtures (#549): per-wire framing and serving.\n *\n * A raw fixture supplies event objects; aimock adds only the named wire's\n * framing, using exactly the bytes the typed handlers write for that wire:\n *\n * - named SSE (`openai-responses`, `anthropic`, `cohere`):\n *   `event: <type>\\ndata: <json>\\n\\n`\n * - data SSE (`openai-chat`, `gemini`, `gemini-interactions`): `data: <json>\\n\\n`;\n *   `openai-chat` ends with `data: [DONE]\\n\\n` unless `raw.done === false`\n * - NDJSON (`ollama`, `ollama-generate`): `<json>\\n`\n * - AWS event stream: `bedrock-invoke` wraps each event as a `chunk` frame with\n *   base64 `bytes`; `bedrock-converse` takes the event's single key as the\n *   frame's event type and its value as the payload.\n *\n * The framing functions are pure. `serveRawResponse` checks and journals the\n * fixture. It writes one reply itself: the untimed 500 for a fixture that\n * fails a check, targets another wire or has no body for the request mode.\n * Every other reply goes through the shared delivery layer (`deliverStream`,\n * `deliverJson`), which owns the delay loop, writability checks and abort\n * handling. A reply with a status of 400 or more is never delayed.\n */\nimport type * as http from \"node:http\";\nimport { encodeEventStreamMessage, eventStreamCodec } from \"../aws-event-stream.js\";\nimport { rawFixtureContext } from \"../fixture-loader.js\";\nimport { flattenHeaders } from \"../helpers.js\";\nimport type { Journal } from \"../journal.js\";\nimport { recordMisbehaviorOutcome, type MisbehaviorSummary } from \"../misbehavior.js\";\nimport { serializeOpenRouterError } from \"../openrouter-chat.js\";\nimport { ndjsonCodec } from \"../ndjson-writer.js\";\nimport { checkRawResponse } from \"../raw-validation.js\";\nimport { sseCodec, writeErrorResponse } from \"../sse-writer.js\";\nimport type { Fixture, HandlerDefaults, JournalEntry, RawResponse, RawWireId } from \"../types.js\";\nimport { deliverJson, deliverStream } from \"./deliver.js\";\nimport { renderError } from \"./errors.js\";\nimport type { FrameCodec } from \"./frame-loop.js\";\nimport type { ErrorWire } from \"./profiles.js\";\n\n/** The streaming Content-Type each wire's typed handler sends. */\nexport function rawContentType(wire: RawWireId): string {\n  switch (wire) {\n    case \"openai-responses\":\n    case \"openai-chat\":\n    case \"anthropic\":\n    case \"gemini\":\n    case \"gemini-interactions\":\n    case \"cohere\":\n      return \"text/event-stream\";\n    case \"ollama\":\n    case \"ollama-generate\":\n      return \"application/x-ndjson\";\n    case \"bedrock-invoke\":\n    case \"bedrock-converse\":\n      return \"application/vnd.amazon.eventstream\";\n  }\n}\n\n/**\n * The default headers of the typed stream on `wire`, read from the typed\n * codec: SSE and NDJSON add `Cache-Control: no-cache` and\n * `Connection: keep-alive`, the AWS event stream `Transfer-Encoding: chunked`.\n */\nfunction rawStreamHeaders(wire: RawWireId): Record<string, string> {\n  switch (wire) {\n    case \"openai-responses\":\n    case \"openai-chat\":\n    case \"anthropic\":\n    case \"gemini\":\n    case \"gemini-interactions\":\n    case \"cohere\":\n      return sseCodec({ done: false }).headers;\n    case \"ollama\":\n    case \"ollama-generate\":\n      return ndjsonCodec().headers;\n    case \"bedrock-invoke\":\n    case \"bedrock-converse\":\n      return eventStreamCodec().headers;\n  }\n}\n\n/** The non-streaming JSON default, as `deliverJson` sends it. */\nconst JSON_HEADERS: Readonly<Record<string, string>> = { \"Content-Type\": \"application/json\" };\n\n/**\n * `defaults` with each `authored` header laid over it. Header names are\n * case-insensitive: an authored header replaces the default of the same name\n * in any letter case and takes the default's spelling, so a later spread over\n * the same defaults (as `deliverJson` does) still has one key per name.\n */\nfunction overrideHeaders(\n  defaults: Readonly<Record<string, string>>,\n  authored: Readonly<Record<string, string>> | undefined,\n): Record<string, string> {\n  const merged: Record<string, string> = { ...defaults };\n  const spelling = new Map(Object.keys(defaults).map((name) => [name.toLowerCase(), name]));\n  for (const [name, value] of Object.entries(authored ?? {})) {\n    merged[spelling.get(name.toLowerCase()) ?? name] = value;\n  }\n  return merged;\n}\n\n/** One raw event, framed for `wire`. Events are checked before framing (raw-validation.ts). */\nexport function encodeRawFrame(wire: RawWireId, event: Record<string, unknown>): string | Buffer {\n  const json = JSON.stringify(event);\n  switch (wire) {\n    case \"openai-responses\":\n    case \"anthropic\":\n    case \"cohere\":\n      return `event: ${String(event.type)}\\ndata: ${json}\\n\\n`;\n    case \"openai-chat\":\n    case \"gemini\":\n    case \"gemini-interactions\":\n      return `data: ${json}\\n\\n`;\n    case \"ollama\":\n    case \"ollama-generate\":\n      return `${json}\\n`;\n    case \"bedrock-invoke\":\n      return encodeEventStreamMessage(\"chunk\", {\n        bytes: Buffer.from(json, \"utf8\").toString(\"base64\"),\n      });\n    case \"bedrock-converse\": {\n      // The checker guarantees exactly one key whose value is a JSON object.\n      const [eventType] = Object.keys(event);\n      const payload = event[eventType];\n      if (payload === null || typeof payload !== \"object\" || Array.isArray(payload)) {\n        throw new Error(\n          `raw framing internal error: bedrock-converse event \"${eventType}\" has no object payload`,\n        );\n      }\n      return encodeEventStreamMessage(eventType, payload);\n    }\n  }\n}\n\n/**\n * Bytes written after the last frame, if any. Only `openai-chat` has a\n * terminal (`data: [DONE]`), sent unless `raw.done === false` and never after\n * an interrupted stream.\n */\nexport function rawTrailer(\n  wire: RawWireId,\n  raw: RawResponse[\"raw\"],\n  aborted: boolean,\n): string | undefined {\n  if (wire === \"openai-chat\" && !aborted && raw.done !== false) return \"data: [DONE]\\n\\n\";\n  return undefined;\n}\n\n// ─── Serving ──────────────────────────────────────────────────────────────────\n\n/** The error code for a request the raw fixture has no body for. */\nexport const RAW_MODE_UNAVAILABLE = \"aimock_raw_mode_unavailable\";\n/** The error code for a raw fixture that fails its checks or targets another wire. */\nexport const RAW_FIXTURE_INVALID = \"aimock_raw_fixture_invalid\";\n\n/** Everything {@link serveRawResponse} needs from the calling handler. */\nexport interface RawServeContext {\n  wire: RawWireId;\n  /** Whether the request asked for a stream, as the handler decides it. */\n  stream: boolean;\n  req: http.IncomingMessage;\n  res: http.ServerResponse;\n  fixture: Fixture;\n  response: RawResponse;\n  /** The journaled request body, as the handler journals it. */\n  body: JournalEntry[\"body\"];\n  journal: Journal;\n  defaults: HandlerDefaults;\n  testId: string;\n  misbehaviorSummary?: MisbehaviorSummary;\n  /** The dialect of the handler's own `renderError(…, \"misbehavior\", …)` call. */\n  errorWire: ErrorWire;\n  /** OpenAI chat requests that arrived on the OpenRouter route. */\n  openRouter?: boolean;\n}\n\n/**\n * The raw events as a frame codec for the shared frame loop. Its headers are\n * the typed stream's defaults for `wire` with `raw.headers` laid over them.\n */\nexport function rawCodec(\n  wire: RawWireId,\n  raw: RawResponse[\"raw\"],\n): FrameCodec<Record<string, unknown>> {\n  return {\n    headers: overrideHeaders(rawStreamHeaders(wire), raw.headers),\n    encode: (event) => encodeRawFrame(wire, event),\n    trailer: (aborted) => {\n      const trailer = rawTrailer(wire, raw, aborted);\n      return trailer === undefined ? [] : [trailer];\n    },\n  };\n}\n\n/**\n * The error body for a raw 500, in the dialect of the handler's misbehavior\n * errors. Dialects with no code slot (Gemini, Ollama, OpenRouter) carry the\n * code as a message prefix.\n */\nfunction renderRawError(\n  ctx: RawServeContext,\n  code: string,\n  message: string,\n): { body: string; headers?: Record<string, string> } {\n  if (ctx.openRouter) return { body: serializeOpenRouterError(500, `${code}: ${message}`) };\n  switch (ctx.errorWire) {\n    case \"openai\":\n      return renderError(\"openai\", \"misbehavior\", {\n        message,\n        type: \"server_error\",\n        ...(ctx.wire === \"openai-chat\" ? { param: null, includeParam: true as const } : {}),\n        code,\n      });\n    case \"messages\":\n      return renderError(\"messages\", \"misbehavior\", { type: \"api_error\", code, message });\n    case \"gemini\":\n      return renderError(\"gemini\", \"misbehavior\", {\n        bodyCode: 500,\n        message: `${code}: ${message}`,\n        status: \"INTERNAL\",\n      });\n    case \"bedrock\":\n    case \"bedrock-converse\":\n      return renderError(ctx.errorWire, \"misbehavior\", {\n        type: \"InternalServerException\",\n        code,\n        message,\n      });\n    default:\n      return renderError(ctx.errorWire, \"misbehavior\", { code, message });\n  }\n}\n\n/**\n * Serve a raw passthrough fixture on the handler's wire: check it, journal it,\n * and send its events or JSON through the shared delivery layer. A fixture\n * that fails a check, targets another wire, or has no body for the requested\n * mode gets a 500 in the handler's misbehavior error dialect, and an error log\n * line. A reply with status 400 or more is never delayed, streaming or not,\n * and one with `json` answers in JSON even to a streaming request.\n */\nexport async function serveRawResponse(ctx: RawServeContext): Promise<void> {\n  const { wire, stream, req, res, fixture, journal, defaults, testId } = ctx;\n  const raw = ctx.response.raw;\n  const journalBase = {\n    method: req.method ?? \"POST\",\n    path: req.url ?? \"/\",\n    headers: flattenHeaders(req.headers),\n    body: ctx.body,\n  };\n  const record = (entry: JournalEntry): void =>\n    recordMisbehaviorOutcome({ entry, summary: ctx.misbehaviorSummary, defaults, testId });\n\n  const status = raw.status ?? 200;\n  // An error reply (status >= 400) is never delayed, streaming or not, as\n  // typed error replies are not. Fixture interruptions still apply.\n  const errorReply = status >= 400;\n  // An error status with a JSON body answers in JSON even to a streaming\n  // request, as provider APIs do; the JSON wins over any events.\n  const servesStream = stream && !(errorReply && raw.json !== undefined);\n\n  let failure: { code: string; message: string } | undefined;\n  const problems = checkRawResponse(raw, rawFixtureContext(fixture, ctx.response)).filter(\n    (finding) => finding.severity === \"error\",\n  );\n  if (problems.length > 0) {\n    failure = {\n      code: RAW_FIXTURE_INVALID,\n      message: `invalid raw fixture: ${problems.map((p) => p.message).join(\"; \")}`,\n    };\n  } else if (raw.wire !== wire) {\n    failure = { code: RAW_FIXTURE_INVALID, message: `raw fixture is for ${raw.wire}, not ${wire}` };\n  } else if (servesStream ? raw.events === undefined : raw.json === undefined) {\n    failure = {\n      code: RAW_MODE_UNAVAILABLE,\n      message: `raw fixture has no \"${servesStream ? \"events\" : \"json\"}\" body for a ${\n        servesStream ? \"streaming\" : \"non-streaming\"\n      } request on ${wire}`,\n    };\n  }\n  if (failure) {\n    defaults.logger.error(`${journalBase.method} ${journalBase.path}: ${failure.message}`);\n    const entry = journal.add({ ...journalBase, response: { status: 500, fixture } });\n    entry.response.error = failure.message;\n    record(entry);\n    const rendered = renderRawError(ctx, failure.code, failure.message);\n    for (const [name, value] of Object.entries(rendered.headers ?? {})) res.setHeader(name, value);\n    writeErrorResponse(res, 500, rendered.body);\n    return;\n  }\n\n  const entry = journal.add({ ...journalBase, response: { status, fixture } });\n  record(entry);\n\n  if (servesStream) {\n    const events = raw.events;\n    if (events === undefined) {\n      throw new Error(`raw serve internal error: a streamed reply on ${wire} has no events`);\n    }\n    await deliverStream(\n      res,\n      entry,\n      fixture,\n      rawCodec(wire, raw),\n      events,\n      errorReply\n        ? { latency: 0 }\n        : {\n            latency: fixture.latency ?? defaults.latency,\n            streamingProfile: fixture.streamingProfile,\n            recordedTimings: fixture.recordedTimings,\n            replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,\n          },\n      // The codec already carries raw.headers over its defaults.\n      { status: raw.status },\n    );\n    return;\n  }\n\n  // The wait is sized from the served JSON, as typed replies size theirs from\n  // the served content, in chunks of the fixture's or server's chunk size.\n  const json = raw.json;\n  if (json === undefined) {\n    throw new Error(`raw serve internal error: a JSON reply on ${wire} has no json`);\n  }\n  const servedLength = JSON.stringify(json).length;\n  // deliverJson reads the timing opt-ins from the fixture. With them off, an\n  // error reply still gets its writability check and journaling, but no wait.\n  await deliverJson(\n    res,\n    entry,\n    errorReply\n      ? { ...fixture, nonStreamingTiming: false, nonStreamingTimingAllProviders: false }\n      : fixture,\n    () => json,\n    {\n      surface: wire === \"openai-chat\" ? \"openai-chat\" : \"other\",\n      status: raw.status,\n      payloadLength: servedLength,\n      chunkSize: Math.max(1, fixture.chunkSize ?? defaults.chunkSize),\n      recordedTimings: fixture.recordedTimings,\n      replaySpeed: fixture.replaySpeed ?? defaults.replaySpeed,\n      headers: overrideHeaders(JSON_HEADERS, raw.headers),\n    },\n  );\n}\n"],"mappings":"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"}

package/dist/response/timing.cjs

@@ -0,0 +1,157 @@
+const require_helpers = require('../helpers.cjs');
+const require_sse_writer = require('../sse-writer.cjs');
+
+//#region src/response/timing.ts
+/**
+* Whether a non-streaming (`stream: false`) reply on `surface` waits. It is
+* opt-in per fixture: `nonStreamingTimingAllProviders: true` on every
+* surface that calls this, or the shipped `nonStreamingTiming: true` on OpenAI Chat
+* Completions only. Either one also needs an explicit `streamingProfile` or
+* `recordedTimings`. Only the boolean `true` counts.
+*/
+function nonStreamingTimingEnabled(fixture, surface) {
+	return (fixture.nonStreamingTimingAllProviders === true || fixture.nonStreamingTiming === true && surface === "openai-chat") && !!(fixture.streamingProfile || fixture.recordedTimings);
+}
+/**
+* The recorded timings a non-streaming wait on `surface` is sized from. `t` is
+* returned as given when it is `undefined`, when its `interChunkDelaysMs` is
+* an array, or for `nonStreamingTiming: true` on OpenAI Chat Completions.
+* Otherwise (a fixture built in code can omit `interChunkDelaysMs`) it is
+* returned with `interChunkDelaysMs: []`, so the wait counts no recorded gaps
+* and the reply is still served.
+*
+* The `nonStreamingTiming: true` OpenAI Chat Completions case is passed
+* through unchanged so that the shipped option keeps its behavior: with no
+* `streamingProfile`, sizing the wait for a reply of more than one chunk reads
+* the missing `interChunkDelaysMs` and throws. With `deliverJson`'s
+* `duplicateId` set, that path throws on a missing `interChunkDelaysMs` in any
+* case, because {@link extendRecordedTimings} reads the list first.
+*/
+function nonStreamingRecordedTimings(fixture, surface, t) {
+	if (!t || Array.isArray(t.interChunkDelaysMs)) return t;
+	if (fixture.nonStreamingTiming === true && surface === "openai-chat") return t;
+	return {
+		...t,
+		interChunkDelaysMs: []
+	};
+}
+/**
+* The total wait before a non-streaming reply: `calculateTotalDelay` over the
+* content chunks `payloadLength` makes at `chunkSize`. There is no latency
+* input, so bare `latency` never delays a non-streaming reply.
+*/
+function nonStreamingDelayMs(fixture, payloadLength, chunkSize, recordedTimings, replaySpeed) {
+	return require_sse_writer.calculateTotalDelay(payloadLength, chunkSize, fixture.streamingProfile, recordedTimings, replaySpeed);
+}
+function toolCallsLength(calls) {
+	return calls.map((tc) => tc.name + tc.arguments).join("").length;
+}
+/**
+* The payload a reply serves, as OpenAI Chat Completions sizes its
+* non-streaming wait: reasoning, then text content, then each tool call's
+* name and arguments. Non-empty `blocks` are authoritative and resolve
+* through `resolveFixtureBlockOutcome`. The inputs are fixture-level values,
+* so the length is the same on every provider.
+*/
+function servedPayloadLength(response, reasoning) {
+	const reasoningLength = reasoning?.length ?? 0;
+	if (require_helpers.isCombinedFixtureResponse(response)) {
+		if (response.blocks && response.blocks.length > 0) {
+			const outcome = require_helpers.resolveFixtureBlockOutcome(response.blocks);
+			return reasoningLength + outcome.content.length + toolCallsLength(outcome.toolCalls);
+		}
+		return reasoningLength + (response.content ?? "").length + toolCallsLength(response.toolCalls ?? []);
+	}
+	if (require_helpers.isTextResponse(response)) return reasoningLength + response.content.length;
+	if (require_helpers.isToolCallResponse(response)) return reasoningLength + toolCallsLength(response.toolCalls);
+	return reasoningLength;
+}
+/** Each served call's name plus its function `arguments` or custom `input`. */
+function servedCallsLength(calls) {
+	return calls.map((tc) => tc.name + (tc.type === "custom" ? tc.input : tc.arguments)).join("").length;
+}
+/**
+* The payload the OpenAI Responses API serves, sized as
+* {@link servedPayloadLength} sizes it but from the Responses carriers: a
+* non-empty `responsesBlocks` (else a non-empty `blocks`) through
+* `resolveServedBlockOutcome`, and `toolCalls` plus `customToolCalls` through
+* `servedToolCalls`. A custom call counts its name and `input`; its stream
+* sends the input in `chunkSize` deltas, as a function call's arguments.
+*/
+function responsesPayloadLength(response, reasoning) {
+	const reasoningLength = reasoning?.length ?? 0;
+	if (require_helpers.isCombinedFixtureResponse(response)) {
+		const outcome = require_helpers.resolveServedBlockOutcome(response);
+		if (outcome) return reasoningLength + outcome.content.length + servedCallsLength(outcome.toolCalls);
+		return reasoningLength + (response.content ?? "").length + servedCallsLength(require_helpers.servedToolCalls(response));
+	}
+	if (require_helpers.isTextResponse(response)) return reasoningLength + response.content.length;
+	if (require_helpers.isToolCallResponse(response)) return reasoningLength + servedCallsLength(require_helpers.servedToolCalls(response));
+	return reasoningLength;
+}
+/**
+* The stream frames of one `image_generation_call` item: `output_item.added`,
+* the `in_progress`, `generating` and `completed` events, and
+* `output_item.done`.
+*/
+const IMAGE_GENERATION_FRAMES = 5;
+/**
+* The frames the OpenAI Responses stream sends for a fixture's `citations`
+* and generated `files`, which carry no text for {@link responsesPayloadLength}
+* to count: one `output_text.annotation.added` per citation on a turn with
+* text, and {@link IMAGE_GENERATION_FRAMES} per file (its
+* `image_generation_call` item has no deltas; these frames are its whole
+* stream). The non-streaming wait counts each as one chunk, as the stream
+* counts each as one frame, so the JSON wait is not undersized for them. A
+* malformed value counts as none: this never throws, and the builder rejects
+* it with its coded error before any byte is written.
+*/
+function responsesOutputFrames(response) {
+	const textTurn = require_helpers.isCombinedFixtureResponse(response) || require_helpers.isTextResponse(response);
+	if (!textTurn && !require_helpers.isToolCallResponse(response)) return 0;
+	return (Array.isArray(response.files) ? response.files.length * IMAGE_GENERATION_FRAMES : 0) + (textTurn && Array.isArray(response.citations) ? response.citations.length : 0);
+}
+/**
+* The payload length for a misbehavior-applied reply. For the three fault
+* terminals on a text response (refusal, content filter, reasoning-only) it is
+* OpenAI's selection: the refusal text, nothing, or the reasoning. In every
+* other case, including a stop plan on a tool-call, combined or blocks
+* response, it is `servedLength`: {@link servedPayloadLength} by default, or
+* {@link responsesPayloadLength} on the OpenAI Responses API.
+*/
+function misbehaviorPayloadLength(plan, effReasoning, servedLength = servedPayloadLength) {
+	if (require_helpers.isTextResponse(plan.response) && (plan.stop === "refusal" || plan.stop === "content_filter" || plan.reasoning !== void 0)) {
+		if (plan.stop === "refusal") return (plan.refusal ?? "").length;
+		if (plan.stop === "content_filter") return 0;
+		return (plan.reasoning ?? "").length;
+	}
+	return servedLength(plan.response, effReasoning);
+}
+/**
+* The K4 duplicate-id gap extension: a duplicate-id plan can add frames, so
+* with `duplicate` true the recorded gaps grow to at least `frameCount - 1`
+* entries by repeating the last gap (0 when the list is empty). A longer
+* list is kept whole, except when `frameCount` is `NaN` (a `NaN` chunk size):
+* the list is then truncated to empty. The wait is 0 either way, because a
+* `NaN` chunk size gives no chunks to wait for. With `duplicate` false or no
+* `t`, `t` is returned unchanged.
+*/
+function extendRecordedTimings(t, frameCount, duplicate) {
+	if (!duplicate || !t) return t;
+	const gaps = t.interChunkDelaysMs;
+	return {
+		...t,
+		interChunkDelaysMs: Array.from({ length: Math.max(gaps.length, frameCount - 1) }, (_, index) => gaps[index] ?? gaps.at(-1) ?? 0)
+	};
+}
+
+//#endregion
+exports.extendRecordedTimings = extendRecordedTimings;
+exports.misbehaviorPayloadLength = misbehaviorPayloadLength;
+exports.nonStreamingDelayMs = nonStreamingDelayMs;
+exports.nonStreamingRecordedTimings = nonStreamingRecordedTimings;
+exports.nonStreamingTimingEnabled = nonStreamingTimingEnabled;
+exports.responsesOutputFrames = responsesOutputFrames;
+exports.responsesPayloadLength = responsesPayloadLength;
+exports.servedPayloadLength = servedPayloadLength;
+//# sourceMappingURL=timing.cjs.map

package/dist/response/timing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.cjs","names":["calculateTotalDelay","isCombinedFixtureResponse","resolveFixtureBlockOutcome","isTextResponse","isToolCallResponse","resolveServedBlockOutcome","servedToolCalls"],"sources":["../../src/response/timing.ts"],"sourcesContent":["import type {\n  Fixture,\n  FixtureResponse,\n  FixtureToolCall,\n  RecordedTimings,\n  ToolCall,\n} from \"../types.js\";\nimport type { MisbehaviorCandidate } from \"../misbehavior.js\";\nimport { calculateTotalDelay } from \"../sse-writer.js\";\nimport {\n  isCombinedFixtureResponse,\n  isTextResponse,\n  isToolCallResponse,\n  resolveFixtureBlockOutcome,\n  resolveServedBlockOutcome,\n  servedToolCalls,\n} from \"../helpers.js\";\n\n/** Which non-streaming surface asks: OpenAI Chat Completions, or any other provider. */\nexport type NonStreamingSurface = \"openai-chat\" | \"other\";\n\n/**\n * Whether a non-streaming (`stream: false`) reply on `surface` waits. It is\n * opt-in per fixture: `nonStreamingTimingAllProviders: true` on every\n * surface that calls this, or the shipped `nonStreamingTiming: true` on OpenAI Chat\n * Completions only. Either one also needs an explicit `streamingProfile` or\n * `recordedTimings`. Only the boolean `true` counts.\n */\nexport function nonStreamingTimingEnabled(fixture: Fixture, surface: NonStreamingSurface): boolean {\n  const optedIn =\n    fixture.nonStreamingTimingAllProviders === true ||\n    (fixture.nonStreamingTiming === true && surface === \"openai-chat\");\n  return optedIn && !!(fixture.streamingProfile || fixture.recordedTimings);\n}\n\n/**\n * The recorded timings a non-streaming wait on `surface` is sized from. `t` is\n * returned as given when it is `undefined`, when its `interChunkDelaysMs` is\n * an array, or for `nonStreamingTiming: true` on OpenAI Chat Completions.\n * Otherwise (a fixture built in code can omit `interChunkDelaysMs`) it is\n * returned with `interChunkDelaysMs: []`, so the wait counts no recorded gaps\n * and the reply is still served.\n *\n * The `nonStreamingTiming: true` OpenAI Chat Completions case is passed\n * through unchanged so that the shipped option keeps its behavior: with no\n * `streamingProfile`, sizing the wait for a reply of more than one chunk reads\n * the missing `interChunkDelaysMs` and throws. With `deliverJson`'s\n * `duplicateId` set, that path throws on a missing `interChunkDelaysMs` in any\n * case, because {@link extendRecordedTimings} reads the list first.\n */\nexport function nonStreamingRecordedTimings(\n  fixture: Fixture,\n  surface: NonStreamingSurface,\n  t: RecordedTimings | undefined,\n): RecordedTimings | undefined {\n  if (!t || Array.isArray(t.interChunkDelaysMs)) return t;\n  if (fixture.nonStreamingTiming === true && surface === \"openai-chat\") return t;\n  return { ...t, interChunkDelaysMs: [] };\n}\n\n/**\n * The total wait before a non-streaming reply: `calculateTotalDelay` over the\n * content chunks `payloadLength` makes at `chunkSize`. There is no latency\n * input, so bare `latency` never delays a non-streaming reply.\n */\nexport function nonStreamingDelayMs(\n  fixture: Fixture,\n  payloadLength: number,\n  chunkSize: number,\n  recordedTimings: RecordedTimings | undefined,\n  replaySpeed: number | undefined,\n): number {\n  return calculateTotalDelay(\n    payloadLength,\n    chunkSize,\n    fixture.streamingProfile,\n    recordedTimings,\n    replaySpeed,\n  );\n}\n\nfunction toolCallsLength(calls: ToolCall[]): number {\n  return calls.map((tc) => tc.name + tc.arguments).join(\"\").length;\n}\n\n/**\n * The payload a reply serves, as OpenAI Chat Completions sizes its\n * non-streaming wait: reasoning, then text content, then each tool call's\n * name and arguments. Non-empty `blocks` are authoritative and resolve\n * through `resolveFixtureBlockOutcome`. The inputs are fixture-level values,\n * so the length is the same on every provider.\n */\nexport function servedPayloadLength(response: FixtureResponse, reasoning?: string): number {\n  const reasoningLength = reasoning?.length ?? 0;\n  if (isCombinedFixtureResponse(response)) {\n    if (response.blocks && response.blocks.length > 0) {\n      const outcome = resolveFixtureBlockOutcome(response.blocks);\n      return reasoningLength + outcome.content.length + toolCallsLength(outcome.toolCalls);\n    }\n    return (\n      reasoningLength + (response.content ?? \"\").length + toolCallsLength(response.toolCalls ?? [])\n    );\n  }\n  if (isTextResponse(response)) return reasoningLength + response.content.length;\n  if (isToolCallResponse(response)) return reasoningLength + toolCallsLength(response.toolCalls);\n  return reasoningLength;\n}\n\n/** Each served call's name plus its function `arguments` or custom `input`. */\nfunction servedCallsLength(calls: readonly FixtureToolCall[]): number {\n  return calls.map((tc) => tc.name + (tc.type === \"custom\" ? tc.input : tc.arguments)).join(\"\")\n    .length;\n}\n\n/**\n * The payload the OpenAI Responses API serves, sized as\n * {@link servedPayloadLength} sizes it but from the Responses carriers: a\n * non-empty `responsesBlocks` (else a non-empty `blocks`) through\n * `resolveServedBlockOutcome`, and `toolCalls` plus `customToolCalls` through\n * `servedToolCalls`. A custom call counts its name and `input`; its stream\n * sends the input in `chunkSize` deltas, as a function call's arguments.\n */\nexport function responsesPayloadLength(response: FixtureResponse, reasoning?: string): number {\n  const reasoningLength = reasoning?.length ?? 0;\n  if (isCombinedFixtureResponse(response)) {\n    const outcome = resolveServedBlockOutcome(response);\n    if (outcome) {\n      return reasoningLength + outcome.content.length + servedCallsLength(outcome.toolCalls);\n    }\n    return (\n      reasoningLength +\n      (response.content ?? \"\").length +\n      servedCallsLength(servedToolCalls(response))\n    );\n  }\n  if (isTextResponse(response)) return reasoningLength + response.content.length;\n  if (isToolCallResponse(response)) {\n    return reasoningLength + servedCallsLength(servedToolCalls(response));\n  }\n  return reasoningLength;\n}\n\n/**\n * The stream frames of one `image_generation_call` item: `output_item.added`,\n * the `in_progress`, `generating` and `completed` events, and\n * `output_item.done`.\n */\nexport const IMAGE_GENERATION_FRAMES = 5;\n\n/**\n * The frames the OpenAI Responses stream sends for a fixture's `citations`\n * and generated `files`, which carry no text for {@link responsesPayloadLength}\n * to count: one `output_text.annotation.added` per citation on a turn with\n * text, and {@link IMAGE_GENERATION_FRAMES} per file (its\n * `image_generation_call` item has no deltas; these frames are its whole\n * stream). The non-streaming wait counts each as one chunk, as the stream\n * counts each as one frame, so the JSON wait is not undersized for them. A\n * malformed value counts as none: this never throws, and the builder rejects\n * it with its coded error before any byte is written.\n */\nexport function responsesOutputFrames(response: FixtureResponse): number {\n  const textTurn = isCombinedFixtureResponse(response) || isTextResponse(response);\n  if (!textTurn && !isToolCallResponse(response)) return 0;\n  const files = Array.isArray(response.files) ? response.files.length * IMAGE_GENERATION_FRAMES : 0;\n  // A tool-only turn has no text to annotate: its builder rejects citations.\n  const citations = textTurn && Array.isArray(response.citations) ? response.citations.length : 0;\n  return files + citations;\n}\n\n/**\n * The payload length for a misbehavior-applied reply. For the three fault\n * terminals on a text response (refusal, content filter, reasoning-only) it is\n * OpenAI's selection: the refusal text, nothing, or the reasoning. In every\n * other case, including a stop plan on a tool-call, combined or blocks\n * response, it is `servedLength`: {@link servedPayloadLength} by default, or\n * {@link responsesPayloadLength} on the OpenAI Responses API.\n */\nexport function misbehaviorPayloadLength(\n  plan: Pick<MisbehaviorCandidate, \"response\" | \"stop\" | \"refusal\" | \"reasoning\">,\n  effReasoning: string | undefined,\n  servedLength: (response: FixtureResponse, reasoning?: string) => number = servedPayloadLength,\n): number {\n  if (\n    isTextResponse(plan.response) &&\n    (plan.stop === \"refusal\" || plan.stop === \"content_filter\" || plan.reasoning !== undefined)\n  ) {\n    if (plan.stop === \"refusal\") return (plan.refusal ?? \"\").length;\n    if (plan.stop === \"content_filter\") return 0;\n    return (plan.reasoning ?? \"\").length;\n  }\n  return servedLength(plan.response, effReasoning);\n}\n\n/**\n * The K4 duplicate-id gap extension: a duplicate-id plan can add frames, so\n * with `duplicate` true the recorded gaps grow to at least `frameCount - 1`\n * entries by repeating the last gap (0 when the list is empty). A longer\n * list is kept whole, except when `frameCount` is `NaN` (a `NaN` chunk size):\n * the list is then truncated to empty. The wait is 0 either way, because a\n * `NaN` chunk size gives no chunks to wait for. With `duplicate` false or no\n * `t`, `t` is returned unchanged.\n */\nexport function extendRecordedTimings(\n  t: RecordedTimings | undefined,\n  frameCount: number,\n  duplicate: boolean,\n): RecordedTimings | undefined {\n  if (!duplicate || !t) return t;\n  const gaps = t.interChunkDelaysMs;\n  return {\n    ...t,\n    interChunkDelaysMs: Array.from(\n      { length: Math.max(gaps.length, frameCount - 1) },\n      (_, index) => gaps[index] ?? gaps.at(-1) ?? 0,\n    ),\n  };\n}\n"],"mappings":"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"}

package/dist/response/timing.js

@@ -0,0 +1,150 @@
+import { isCombinedFixtureResponse, isTextResponse, isToolCallResponse, resolveFixtureBlockOutcome, resolveServedBlockOutcome, servedToolCalls } from "../helpers.js";
+import { calculateTotalDelay } from "../sse-writer.js";
+
+//#region src/response/timing.ts
+/**
+* Whether a non-streaming (`stream: false`) reply on `surface` waits. It is
+* opt-in per fixture: `nonStreamingTimingAllProviders: true` on every
+* surface that calls this, or the shipped `nonStreamingTiming: true` on OpenAI Chat
+* Completions only. Either one also needs an explicit `streamingProfile` or
+* `recordedTimings`. Only the boolean `true` counts.
+*/
+function nonStreamingTimingEnabled(fixture, surface) {
+	return (fixture.nonStreamingTimingAllProviders === true || fixture.nonStreamingTiming === true && surface === "openai-chat") && !!(fixture.streamingProfile || fixture.recordedTimings);
+}
+/**
+* The recorded timings a non-streaming wait on `surface` is sized from. `t` is
+* returned as given when it is `undefined`, when its `interChunkDelaysMs` is
+* an array, or for `nonStreamingTiming: true` on OpenAI Chat Completions.
+* Otherwise (a fixture built in code can omit `interChunkDelaysMs`) it is
+* returned with `interChunkDelaysMs: []`, so the wait counts no recorded gaps
+* and the reply is still served.
+*
+* The `nonStreamingTiming: true` OpenAI Chat Completions case is passed
+* through unchanged so that the shipped option keeps its behavior: with no
+* `streamingProfile`, sizing the wait for a reply of more than one chunk reads
+* the missing `interChunkDelaysMs` and throws. With `deliverJson`'s
+* `duplicateId` set, that path throws on a missing `interChunkDelaysMs` in any
+* case, because {@link extendRecordedTimings} reads the list first.
+*/
+function nonStreamingRecordedTimings(fixture, surface, t) {
+	if (!t || Array.isArray(t.interChunkDelaysMs)) return t;
+	if (fixture.nonStreamingTiming === true && surface === "openai-chat") return t;
+	return {
+		...t,
+		interChunkDelaysMs: []
+	};
+}
+/**
+* The total wait before a non-streaming reply: `calculateTotalDelay` over the
+* content chunks `payloadLength` makes at `chunkSize`. There is no latency
+* input, so bare `latency` never delays a non-streaming reply.
+*/
+function nonStreamingDelayMs(fixture, payloadLength, chunkSize, recordedTimings, replaySpeed) {
+	return calculateTotalDelay(payloadLength, chunkSize, fixture.streamingProfile, recordedTimings, replaySpeed);
+}
+function toolCallsLength(calls) {
+	return calls.map((tc) => tc.name + tc.arguments).join("").length;
+}
+/**
+* The payload a reply serves, as OpenAI Chat Completions sizes its
+* non-streaming wait: reasoning, then text content, then each tool call's
+* name and arguments. Non-empty `blocks` are authoritative and resolve
+* through `resolveFixtureBlockOutcome`. The inputs are fixture-level values,
+* so the length is the same on every provider.
+*/
+function servedPayloadLength(response, reasoning) {
+	const reasoningLength = reasoning?.length ?? 0;
+	if (isCombinedFixtureResponse(response)) {
+		if (response.blocks && response.blocks.length > 0) {
+			const outcome = resolveFixtureBlockOutcome(response.blocks);
+			return reasoningLength + outcome.content.length + toolCallsLength(outcome.toolCalls);
+		}
+		return reasoningLength + (response.content ?? "").length + toolCallsLength(response.toolCalls ?? []);
+	}
+	if (isTextResponse(response)) return reasoningLength + response.content.length;
+	if (isToolCallResponse(response)) return reasoningLength + toolCallsLength(response.toolCalls);
+	return reasoningLength;
+}
+/** Each served call's name plus its function `arguments` or custom `input`. */
+function servedCallsLength(calls) {
+	return calls.map((tc) => tc.name + (tc.type === "custom" ? tc.input : tc.arguments)).join("").length;
+}
+/**
+* The payload the OpenAI Responses API serves, sized as
+* {@link servedPayloadLength} sizes it but from the Responses carriers: a
+* non-empty `responsesBlocks` (else a non-empty `blocks`) through
+* `resolveServedBlockOutcome`, and `toolCalls` plus `customToolCalls` through
+* `servedToolCalls`. A custom call counts its name and `input`; its stream
+* sends the input in `chunkSize` deltas, as a function call's arguments.
+*/
+function responsesPayloadLength(response, reasoning) {
+	const reasoningLength = reasoning?.length ?? 0;
+	if (isCombinedFixtureResponse(response)) {
+		const outcome = resolveServedBlockOutcome(response);
+		if (outcome) return reasoningLength + outcome.content.length + servedCallsLength(outcome.toolCalls);
+		return reasoningLength + (response.content ?? "").length + servedCallsLength(servedToolCalls(response));
+	}
+	if (isTextResponse(response)) return reasoningLength + response.content.length;
+	if (isToolCallResponse(response)) return reasoningLength + servedCallsLength(servedToolCalls(response));
+	return reasoningLength;
+}
+/**
+* The stream frames of one `image_generation_call` item: `output_item.added`,
+* the `in_progress`, `generating` and `completed` events, and
+* `output_item.done`.
+*/
+const IMAGE_GENERATION_FRAMES = 5;
+/**
+* The frames the OpenAI Responses stream sends for a fixture's `citations`
+* and generated `files`, which carry no text for {@link responsesPayloadLength}
+* to count: one `output_text.annotation.added` per citation on a turn with
+* text, and {@link IMAGE_GENERATION_FRAMES} per file (its
+* `image_generation_call` item has no deltas; these frames are its whole
+* stream). The non-streaming wait counts each as one chunk, as the stream
+* counts each as one frame, so the JSON wait is not undersized for them. A
+* malformed value counts as none: this never throws, and the builder rejects
+* it with its coded error before any byte is written.
+*/
+function responsesOutputFrames(response) {
+	const textTurn = isCombinedFixtureResponse(response) || isTextResponse(response);
+	if (!textTurn && !isToolCallResponse(response)) return 0;
+	return (Array.isArray(response.files) ? response.files.length * IMAGE_GENERATION_FRAMES : 0) + (textTurn && Array.isArray(response.citations) ? response.citations.length : 0);
+}
+/**
+* The payload length for a misbehavior-applied reply. For the three fault
+* terminals on a text response (refusal, content filter, reasoning-only) it is
+* OpenAI's selection: the refusal text, nothing, or the reasoning. In every
+* other case, including a stop plan on a tool-call, combined or blocks
+* response, it is `servedLength`: {@link servedPayloadLength} by default, or
+* {@link responsesPayloadLength} on the OpenAI Responses API.
+*/
+function misbehaviorPayloadLength(plan, effReasoning, servedLength = servedPayloadLength) {
+	if (isTextResponse(plan.response) && (plan.stop === "refusal" || plan.stop === "content_filter" || plan.reasoning !== void 0)) {
+		if (plan.stop === "refusal") return (plan.refusal ?? "").length;
+		if (plan.stop === "content_filter") return 0;
+		return (plan.reasoning ?? "").length;
+	}
+	return servedLength(plan.response, effReasoning);
+}
+/**
+* The K4 duplicate-id gap extension: a duplicate-id plan can add frames, so
+* with `duplicate` true the recorded gaps grow to at least `frameCount - 1`
+* entries by repeating the last gap (0 when the list is empty). A longer
+* list is kept whole, except when `frameCount` is `NaN` (a `NaN` chunk size):
+* the list is then truncated to empty. The wait is 0 either way, because a
+* `NaN` chunk size gives no chunks to wait for. With `duplicate` false or no
+* `t`, `t` is returned unchanged.
+*/
+function extendRecordedTimings(t, frameCount, duplicate) {
+	if (!duplicate || !t) return t;
+	const gaps = t.interChunkDelaysMs;
+	return {
+		...t,
+		interChunkDelaysMs: Array.from({ length: Math.max(gaps.length, frameCount - 1) }, (_, index) => gaps[index] ?? gaps.at(-1) ?? 0)
+	};
+}
+
+//#endregion
+export { extendRecordedTimings, misbehaviorPayloadLength, nonStreamingDelayMs, nonStreamingRecordedTimings, nonStreamingTimingEnabled, responsesOutputFrames, responsesPayloadLength, servedPayloadLength };
+//# sourceMappingURL=timing.js.map

package/dist/response/timing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.js","names":[],"sources":["../../src/response/timing.ts"],"sourcesContent":["import type {\n  Fixture,\n  FixtureResponse,\n  FixtureToolCall,\n  RecordedTimings,\n  ToolCall,\n} from \"../types.js\";\nimport type { MisbehaviorCandidate } from \"../misbehavior.js\";\nimport { calculateTotalDelay } from \"../sse-writer.js\";\nimport {\n  isCombinedFixtureResponse,\n  isTextResponse,\n  isToolCallResponse,\n  resolveFixtureBlockOutcome,\n  resolveServedBlockOutcome,\n  servedToolCalls,\n} from \"../helpers.js\";\n\n/** Which non-streaming surface asks: OpenAI Chat Completions, or any other provider. */\nexport type NonStreamingSurface = \"openai-chat\" | \"other\";\n\n/**\n * Whether a non-streaming (`stream: false`) reply on `surface` waits. It is\n * opt-in per fixture: `nonStreamingTimingAllProviders: true` on every\n * surface that calls this, or the shipped `nonStreamingTiming: true` on OpenAI Chat\n * Completions only. Either one also needs an explicit `streamingProfile` or\n * `recordedTimings`. Only the boolean `true` counts.\n */\nexport function nonStreamingTimingEnabled(fixture: Fixture, surface: NonStreamingSurface): boolean {\n  const optedIn =\n    fixture.nonStreamingTimingAllProviders === true ||\n    (fixture.nonStreamingTiming === true && surface === \"openai-chat\");\n  return optedIn && !!(fixture.streamingProfile || fixture.recordedTimings);\n}\n\n/**\n * The recorded timings a non-streaming wait on `surface` is sized from. `t` is\n * returned as given when it is `undefined`, when its `interChunkDelaysMs` is\n * an array, or for `nonStreamingTiming: true` on OpenAI Chat Completions.\n * Otherwise (a fixture built in code can omit `interChunkDelaysMs`) it is\n * returned with `interChunkDelaysMs: []`, so the wait counts no recorded gaps\n * and the reply is still served.\n *\n * The `nonStreamingTiming: true` OpenAI Chat Completions case is passed\n * through unchanged so that the shipped option keeps its behavior: with no\n * `streamingProfile`, sizing the wait for a reply of more than one chunk reads\n * the missing `interChunkDelaysMs` and throws. With `deliverJson`'s\n * `duplicateId` set, that path throws on a missing `interChunkDelaysMs` in any\n * case, because {@link extendRecordedTimings} reads the list first.\n */\nexport function nonStreamingRecordedTimings(\n  fixture: Fixture,\n  surface: NonStreamingSurface,\n  t: RecordedTimings | undefined,\n): RecordedTimings | undefined {\n  if (!t || Array.isArray(t.interChunkDelaysMs)) return t;\n  if (fixture.nonStreamingTiming === true && surface === \"openai-chat\") return t;\n  return { ...t, interChunkDelaysMs: [] };\n}\n\n/**\n * The total wait before a non-streaming reply: `calculateTotalDelay` over the\n * content chunks `payloadLength` makes at `chunkSize`. There is no latency\n * input, so bare `latency` never delays a non-streaming reply.\n */\nexport function nonStreamingDelayMs(\n  fixture: Fixture,\n  payloadLength: number,\n  chunkSize: number,\n  recordedTimings: RecordedTimings | undefined,\n  replaySpeed: number | undefined,\n): number {\n  return calculateTotalDelay(\n    payloadLength,\n    chunkSize,\n    fixture.streamingProfile,\n    recordedTimings,\n    replaySpeed,\n  );\n}\n\nfunction toolCallsLength(calls: ToolCall[]): number {\n  return calls.map((tc) => tc.name + tc.arguments).join(\"\").length;\n}\n\n/**\n * The payload a reply serves, as OpenAI Chat Completions sizes its\n * non-streaming wait: reasoning, then text content, then each tool call's\n * name and arguments. Non-empty `blocks` are authoritative and resolve\n * through `resolveFixtureBlockOutcome`. The inputs are fixture-level values,\n * so the length is the same on every provider.\n */\nexport function servedPayloadLength(response: FixtureResponse, reasoning?: string): number {\n  const reasoningLength = reasoning?.length ?? 0;\n  if (isCombinedFixtureResponse(response)) {\n    if (response.blocks && response.blocks.length > 0) {\n      const outcome = resolveFixtureBlockOutcome(response.blocks);\n      return reasoningLength + outcome.content.length + toolCallsLength(outcome.toolCalls);\n    }\n    return (\n      reasoningLength + (response.content ?? \"\").length + toolCallsLength(response.toolCalls ?? [])\n    );\n  }\n  if (isTextResponse(response)) return reasoningLength + response.content.length;\n  if (isToolCallResponse(response)) return reasoningLength + toolCallsLength(response.toolCalls);\n  return reasoningLength;\n}\n\n/** Each served call's name plus its function `arguments` or custom `input`. */\nfunction servedCallsLength(calls: readonly FixtureToolCall[]): number {\n  return calls.map((tc) => tc.name + (tc.type === \"custom\" ? tc.input : tc.arguments)).join(\"\")\n    .length;\n}\n\n/**\n * The payload the OpenAI Responses API serves, sized as\n * {@link servedPayloadLength} sizes it but from the Responses carriers: a\n * non-empty `responsesBlocks` (else a non-empty `blocks`) through\n * `resolveServedBlockOutcome`, and `toolCalls` plus `customToolCalls` through\n * `servedToolCalls`. A custom call counts its name and `input`; its stream\n * sends the input in `chunkSize` deltas, as a function call's arguments.\n */\nexport function responsesPayloadLength(response: FixtureResponse, reasoning?: string): number {\n  const reasoningLength = reasoning?.length ?? 0;\n  if (isCombinedFixtureResponse(response)) {\n    const outcome = resolveServedBlockOutcome(response);\n    if (outcome) {\n      return reasoningLength + outcome.content.length + servedCallsLength(outcome.toolCalls);\n    }\n    return (\n      reasoningLength +\n      (response.content ?? \"\").length +\n      servedCallsLength(servedToolCalls(response))\n    );\n  }\n  if (isTextResponse(response)) return reasoningLength + response.content.length;\n  if (isToolCallResponse(response)) {\n    return reasoningLength + servedCallsLength(servedToolCalls(response));\n  }\n  return reasoningLength;\n}\n\n/**\n * The stream frames of one `image_generation_call` item: `output_item.added`,\n * the `in_progress`, `generating` and `completed` events, and\n * `output_item.done`.\n */\nexport const IMAGE_GENERATION_FRAMES = 5;\n\n/**\n * The frames the OpenAI Responses stream sends for a fixture's `citations`\n * and generated `files`, which carry no text for {@link responsesPayloadLength}\n * to count: one `output_text.annotation.added` per citation on a turn with\n * text, and {@link IMAGE_GENERATION_FRAMES} per file (its\n * `image_generation_call` item has no deltas; these frames are its whole\n * stream). The non-streaming wait counts each as one chunk, as the stream\n * counts each as one frame, so the JSON wait is not undersized for them. A\n * malformed value counts as none: this never throws, and the builder rejects\n * it with its coded error before any byte is written.\n */\nexport function responsesOutputFrames(response: FixtureResponse): number {\n  const textTurn = isCombinedFixtureResponse(response) || isTextResponse(response);\n  if (!textTurn && !isToolCallResponse(response)) return 0;\n  const files = Array.isArray(response.files) ? response.files.length * IMAGE_GENERATION_FRAMES : 0;\n  // A tool-only turn has no text to annotate: its builder rejects citations.\n  const citations = textTurn && Array.isArray(response.citations) ? response.citations.length : 0;\n  return files + citations;\n}\n\n/**\n * The payload length for a misbehavior-applied reply. For the three fault\n * terminals on a text response (refusal, content filter, reasoning-only) it is\n * OpenAI's selection: the refusal text, nothing, or the reasoning. In every\n * other case, including a stop plan on a tool-call, combined or blocks\n * response, it is `servedLength`: {@link servedPayloadLength} by default, or\n * {@link responsesPayloadLength} on the OpenAI Responses API.\n */\nexport function misbehaviorPayloadLength(\n  plan: Pick<MisbehaviorCandidate, \"response\" | \"stop\" | \"refusal\" | \"reasoning\">,\n  effReasoning: string | undefined,\n  servedLength: (response: FixtureResponse, reasoning?: string) => number = servedPayloadLength,\n): number {\n  if (\n    isTextResponse(plan.response) &&\n    (plan.stop === \"refusal\" || plan.stop === \"content_filter\" || plan.reasoning !== undefined)\n  ) {\n    if (plan.stop === \"refusal\") return (plan.refusal ?? \"\").length;\n    if (plan.stop === \"content_filter\") return 0;\n    return (plan.reasoning ?? \"\").length;\n  }\n  return servedLength(plan.response, effReasoning);\n}\n\n/**\n * The K4 duplicate-id gap extension: a duplicate-id plan can add frames, so\n * with `duplicate` true the recorded gaps grow to at least `frameCount - 1`\n * entries by repeating the last gap (0 when the list is empty). A longer\n * list is kept whole, except when `frameCount` is `NaN` (a `NaN` chunk size):\n * the list is then truncated to empty. The wait is 0 either way, because a\n * `NaN` chunk size gives no chunks to wait for. With `duplicate` false or no\n * `t`, `t` is returned unchanged.\n */\nexport function extendRecordedTimings(\n  t: RecordedTimings | undefined,\n  frameCount: number,\n  duplicate: boolean,\n): RecordedTimings | undefined {\n  if (!duplicate || !t) return t;\n  const gaps = t.interChunkDelaysMs;\n  return {\n    ...t,\n    interChunkDelaysMs: Array.from(\n      { length: Math.max(gaps.length, frameCount - 1) },\n      (_, index) => gaps[index] ?? gaps.at(-1) ?? 0,\n    ),\n  };\n}\n"],"mappings":"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"}