@copilotkit/aimock 1.46.0 → 1.47.0

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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"}