@yanlinglabs/winter-provider-conformance 0.0.2

package/dist/fakes/azure-openai.d.ts

@@ -0,0 +1,18 @@
+import { type FakeRoute, type FakeServer, type RecordedRequest, type ScenarioResponder } from "./server.js";
+export declare const FAKE_AZURE_KEY = "test-key-azure-0000";
+export declare const FAKE_ENTRA_TOKEN = "test-token-entra-0000";
+export interface AzureFakeOptions {
+    /** modelId -> scripted answer for the CLASSIC deployment path (chat completions). */
+    chatScenarios?: Record<string, ScenarioResponder | Response[]>;
+    /** modelId -> scripted answer for the PREVIEW `/openai/v1/responses` surface. */
+    responsesScenarios?: Record<string, ScenarioResponder | Response[]>;
+    /** Rows served by `/openai/models` and `/openai/v1/models`. */
+    models?: unknown[];
+    routes?: FakeRoute[];
+}
+/** The deployment segment a request addressed, or `undefined` for the preview surface. */
+export declare function deploymentOf(recorded: RecordedRequest): string | undefined;
+/** The `api-version` a request carried, or `undefined`. */
+export declare function apiVersionOf(recorded: RecordedRequest): string | undefined;
+/** Starts a fake serving both Azure surfaces plus their discovery endpoints. */
+export declare function startAzureFake(opts: AzureFakeOptions): Promise<FakeServer>;

package/dist/fakes/bedrock.d.ts

@@ -0,0 +1,90 @@
+import { concatFrames, converseStreamEvent, converseStreamException } from "@yanlinglabs/winter-provider-runtime/testing";
+import { type FakeServer, type RecordedRequest, type ScenarioResponder } from "./server.js";
+/** AWS's own published example credentials. They authenticate nothing; the fake knows the secret so it can recompute. */
+export declare const FAKE_ACCESS_KEY_ID = "AKIDEXAMPLE";
+export declare const FAKE_SECRET_ACCESS_KEY = "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY";
+export declare const FAKE_REGION = "us-east-1";
+/** The model id a request addressed, read out of the PATH — Bedrock's own placement, unlike the OpenAI and Anthropic families' bodies. */
+export declare function bedrockModelOf(recorded: RecordedRequest): string | undefined;
+/** True when the request asked for the STREAMING operation. */
+export declare function isStreamingPath(recorded: RecordedRequest): boolean;
+export interface EventStreamResponseOptions {
+    status?: number;
+    /** Milliseconds to wait before writing each frame after the first — the slow-stream primitive. */
+    delayMs?: number;
+    /** END the stream after this many frames, WITHOUT the terminating `messageStop`: a truncated upstream. */
+    dropAfter?: number;
+    /**
+     * After every frame has been written, HOLD the stream open without closing it — the mid-turn
+     * stall. Bounded so it cannot outlive its test, and the timer is cleared on cancel: an
+     * unconditional `close()` against a controller the consumer already tore down throws from a bare
+     * timer callback, which Bun attributes to whichever test happens to be running (the spine hit
+     * exactly this in `stalledResponse` and fixed it the same way).
+     */
+    holdOpenMs?: number;
+    /**
+     * Split the whole body into chunks of this many bytes.
+     *
+     * The only way to prove ON THE WIRE that the decoder survives a frame boundary falling anywhere:
+     * a unit test can feed it byte by byte, but only a real socket proves the adapter's read loop
+     * feeds it correctly.
+     */
+    chunkSize?: number;
+}
+/**
+ * An `application/vnd.amazon.eventstream` response built from encoded frames.
+ *
+ * WRITES ONE FRAME PER PULL, and that is the fix for a defect this file shipped with for one test
+ * run: pacing was applied per CHUNK while `chunkSize` defaulted to the whole body, so `delayMs` was
+ * dead code and the "slow stream" wrote everything at once. `cancel-mid-stream` passed for the wrong
+ * reason — there was no mid-stream to cancel in. Frames are the unit a Bedrock consumer sees, so
+ * they are the unit this paces; `chunkSize` splits WITHIN a frame, which is the separate question of
+ * whether a decoder survives a frame spanning socket reads.
+ */
+export declare function eventStreamResponse(frames: Uint8Array[], opts?: EventStreamResponseOptions): Response;
+/** Bedrock's REST-JSON error shape: a bare `{"message"}` body with the code on `x-amzn-errortype`. */
+export declare function bedrockError(status: number, errorType: string, message: string, headers?: Record<string, string>): Response;
+/** A happy-path ConverseStream body: start, text, stop, metadata. */
+export declare function textTurnFrames(text: string, usage?: {
+    inputTokens: number;
+    outputTokens: number;
+}): Uint8Array[];
+/** What the fake observed about one request's SIGNATURE. */
+export interface RecordedSignature {
+    path: string;
+    /** The header names the client SIGNED, from the Authorization header's own `SignedHeaders=` list. */
+    signedHeaders: string[];
+    accessKeyId: string;
+    region: string;
+    service: string;
+    verified: boolean;
+}
+/**
+ * The fake, plus what it saw of each signature.
+ *
+ * `signatures` exists because `server.ts` REDACTS `authorization` as it records a request — correct
+ * for a request log, and it makes "was this header actually signed?" unaskable from `fake.requests`.
+ * A test that only checked the header was PRESENT would pass for an adapter that attached it after
+ * signing, which real AWS rejects with a 403 naming nothing useful.
+ */
+export interface BedrockFakeServer extends FakeServer {
+    signatures: RecordedSignature[];
+}
+export interface BedrockFakeOptions {
+    /** modelId -> the scripted answer for `/model/<id>/converse[-stream]`. */
+    scenarios: Record<string, ScenarioResponder | Response[]>;
+    /** The answer to `GET /foundation-models`. Defaults to a two-row inventory. */
+    discovery?: ScenarioResponder;
+    /** Skips signature verification. ONLY the guard-on-the-guard test sets it, to prove the check is load-bearing. */
+    skipSignatureCheck?: boolean;
+    /** Skips the request-SHAPE checks (alternation, empty text). Used by the fixture that proves those checks are themselves load-bearing. */
+    skipShapeCheck?: boolean;
+    secretAccessKey?: string;
+}
+/**
+ * Starts the Bedrock fake.
+ *
+ * ALWAYS close it in a `finally` — `withFake` from the base does that for you.
+ */
+export declare function startBedrockFake(opts: BedrockFakeOptions): Promise<BedrockFakeServer>;
+export { converseStreamEvent, converseStreamException, concatFrames };

package/dist/fakes/codex-oauth.d.ts

@@ -0,0 +1,46 @@
+import { type FakeRoute, type FakeServer, type ScenarioResponder } from "./server.js";
+export declare const FAKE_ACCOUNT_ID = "acct-test-0001";
+export declare const FAKE_ACCESS_TOKEN = "test-token-codex-access";
+export declare const FAKE_REFRESHED_ACCESS_TOKEN = "test-token-codex-access-refreshed";
+export declare const FAKE_REFRESH_TOKEN = "test-token-codex-refresh";
+/**
+ * An id token carrying a ChatGPT account id.
+ *
+ * UNSIGNED (`alg: "none"`), and that is honest rather than lazy: the adapter reads this claim as a
+ * LOCATOR — a Keychain account name and a request header — never as an authorization decision, and
+ * a fake that signed it would imply a verification step that does not exist.
+ */
+export declare function fakeIdToken(accountId?: string): string;
+export interface CodexTokenEndpointOptions {
+    /** Answer every exchange with this status instead of 200. */
+    failWith?: number;
+    accountId?: string;
+    accessToken?: string;
+    /** Omit the id token, which is what a real REFRESH grant usually does. */
+    omitIdToken?: boolean;
+    /** Omit the refresh token — a refresh grant that does not rotate it. */
+    omitRefreshToken?: boolean;
+    expiresIn?: number;
+}
+/** The `/oauth/token` route, serving both the authorization-code exchange and the refresh grant. */
+export declare function codexTokenRoute(opts?: CodexTokenEndpointOptions): FakeRoute;
+/** A codex fake, plus the bearers its `/responses` route actually saw — in order. */
+export interface CodexFakeServer extends FakeServer {
+    bearers: string[];
+}
+export interface CodexFakeOptions {
+    /** modelId -> scripted answer, keyed exactly as the shared `scenarioTable` would. */
+    scenarios: Record<string, ScenarioResponder | Response[]>;
+    /** Model ids whose FIRST request must be answered 401 — the refresh probe. A later request carrying a different bearer is served the scenario. */
+    requireRefreshFor?: string[];
+    token?: CodexTokenEndpointOptions;
+    routes?: FakeRoute[];
+    unknownModel?: ScenarioResponder;
+}
+/**
+ * Starts a codex backend fake.
+ *
+ * Both path spellings are served: `/responses` (a base URL pointing straight at the fake) and
+ * `/backend-api/codex/responses` (a base URL mirroring the real backend's own path).
+ */
+export declare function startCodexFake(opts: CodexFakeOptions): Promise<CodexFakeServer>;

package/dist/fakes/gemini.d.ts

@@ -0,0 +1,121 @@
+import { type FakeRoute, type RecordedRequest, type SseFrame, type SseResponseOptions } from "./server.js";
+/** One `parts` entry, in the family's own spelling. */
+export type GeminiPart = {
+    text: string;
+    thought?: boolean;
+    thoughtSignature?: string;
+} | {
+    functionCall: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    thoughtSignature?: string;
+} | {
+    functionResponse: {
+        name: string;
+        response: Record<string, unknown>;
+    };
+} | {
+    inlineData: {
+        mimeType: string;
+        data: string;
+    };
+};
+/** One streamed chunk. A chunk carrying `finishReason` is the COMPLETING one. */
+export interface GeminiChunk {
+    parts?: GeminiPart[];
+    finishReason?: "STOP" | "MAX_TOKENS" | "SAFETY" | "RECITATION" | "PROHIBITED_CONTENT" | "MALFORMED_FUNCTION_CALL";
+    usageMetadata?: {
+        promptTokenCount?: number;
+        candidatesTokenCount?: number;
+        cachedContentTokenCount?: number;
+        thoughtsTokenCount?: number;
+        totalTokenCount?: number;
+    };
+    modelVersion?: string;
+    /** A top-level prompt block -- the family's own refusal shape, which carries no candidate at all. */
+    promptFeedback?: {
+        blockReason: string;
+    };
+    delayMs?: number;
+}
+export declare function geminiSseFrames(chunks: GeminiChunk[]): SseFrame[];
+export declare function geminiStreamResponse(chunks: GeminiChunk[], opts?: SseResponseOptions): Response;
+/** The family's error envelope: a NUMERIC `error.code` with the machine-readable value in `error.status`. */
+export declare function geminiError(status: number, googleStatus: string, message?: string, headers?: Record<string, string>): Response;
+/**
+ * Reads the model id out of a Gemini request.
+ *
+ * IT IS IN THE PATH, not the body -- `/v1beta/models/<model>:streamGenerateContent` -- which is why
+ * the base's `scenarioTable` takes a family-specific `modelOf` instead of guessing.
+ */
+export declare function geminiModelOf(recorded: RecordedRequest): string | undefined;
+export declare function geminiBody(recorded: RecordedRequest): Record<string, unknown>;
+/** The `contents` array of a recorded request. */
+export declare function geminiContents(recorded: RecordedRequest): Array<{
+    role?: string;
+    parts?: GeminiPart[];
+}>;
+export interface GeminiRequestExpectation {
+    model?: string;
+    /** The whole search string, so `?alt=sse` is asserted as the literal it is. */
+    search?: string;
+    roles?: string[];
+    /** Every part's discriminating KEY (`text` / `functionCall` / `functionResponse` / `inlineData`), flattened in wire order. */
+    partKinds?: string[];
+    thinkingConfig?: unknown;
+    toolConfig?: unknown;
+    functionNames?: string[];
+    systemInstruction?: string;
+    maxOutputTokens?: number;
+}
+/** The discriminating key of one part, for an ordering assertion that does not depend on the payload. */
+export declare function partKind(part: GeminiPart): string;
+/**
+ * Asserts the EXACT request shape on the live request the fake received.
+ *
+ * `x-goog-api-key` is checked in its REDACTED form -- the base replaces a credential header's
+ * material as it records, so asserting on `***` proves both that the adapter authenticated and that
+ * the redaction ran.
+ */
+export declare function assertGeminiRequest(recorded: RecordedRequest, expected?: GeminiRequestExpectation): void;
+/**
+ * This dialect's equivalent ordering constraint, enforced so a pin about it can fail.
+ *
+ * A `functionResponse` answers the turn it follows; a text part placed ahead of one inside the same
+ * `user` entry is the shape this lane emitted for a decorated tool message. `inlineData` is exempt:
+ * an image the response's Struct could not carry rides beside it by construction.
+ *
+ * Returns the offending entry index, or `undefined` when every entry is well-formed.
+ */
+export declare function findFunctionResponseOrderingViolation(recorded: RecordedRequest): number | undefined;
+/**
+ * Role ALTERNATION, enforced so a pin about the merge can fail.
+ *
+ * `contents` is a conversation: two adjacent entries with the same role are not a turn the endpoint
+ * accepts. This lane's own serializer merges adjacent same-role messages precisely because of that —
+ * and then shipped a version where a message rendering to ZERO parts split the merge and produced
+ * two consecutive `user` entries, with nothing on the receiving end to notice. A fake that accepts
+ * any role sequence cannot fail a pin about role sequence.
+ *
+ * Returns the index of the second entry of the first offending pair, or `undefined` when the
+ * conversation alternates.
+ */
+export declare function findRoleAlternationViolation(recorded: RecordedRequest): number | undefined;
+export interface GeminiFakeOptions {
+    /** modelId -> the scripted answer for `:streamGenerateContent`. */
+    stream: Record<string, ((recorded: RecordedRequest, attempt: number) => Response | Promise<Response>) | Response[]>;
+    countTokens?: (recorded: RecordedRequest) => Response;
+    /** `GET /v1beta/models` -- discovery and credential validation both land here. */
+    models?: (recorded: RecordedRequest) => Response | Promise<Response>;
+    /** The path prefix the routes are mounted under. `/v1beta` for the Gemini API, `/v1/projects/...` for Vertex. */
+    prefix?: string;
+}
+/**
+ * The routes a Google-family adapter can reach.
+ *
+ * PREFIX-MATCHED (`path` ending in `*`) rather than exact, because the model id and the method are
+ * both IN THE PATH -- `/v1beta/models/gemini-2.5-pro:streamGenerateContent` -- so an exact match
+ * would need one route per scenario model.
+ */
+export declare function geminiFakeRoutes(opts: GeminiFakeOptions): FakeRoute[];

package/dist/fakes/index.d.ts

@@ -0,0 +1,15 @@
+export { errorResponse, jsonResponse, noRequestContains, redirectResponse, requestsTo, scenarioTable, sseResponse, stalledResponse, startFake, withFake, } from "./server.js";
+export type { FakeRoute, FakeServer, RecordedRequest, ScenarioResponder, ScenarioTableOptions, SseFrame, SseResponseOptions, StartFakeOptions } from "./server.js";
+export * as anthropicConsoleOauthFake from "./anthropic-console-oauth.js";
+export * as anthropicFake from "./anthropic-messages.js";
+export * as azureFake from "./azure-openai.js";
+export * as bedrockFake from "./bedrock.js";
+export * as codexFake from "./codex-oauth.js";
+export * as geminiFake from "./gemini.js";
+export * as openaiChatFake from "./openai-chat.js";
+export * as openaiModelsFake from "./openai-models.js";
+export * as openaiResponsesFake from "./openai-responses.js";
+export * as vertexFake from "./vertex.js";
+export * as xaiOauthFake from "./xai-oauth.js";
+export { OPAQUE_FIELD_NAMES, redactOpaqueFields } from "./redact-opaque.js";
+export { base64UrlDecodeBytes, base64UrlDecodeText, verifyRs256Jwt } from "./jwt-verify.js";

package/dist/fakes/index.js

@@ -0,0 +1,56 @@
+import {
+  startFake2,
+  withFake2,
+  sseResponse2,
+  jsonResponse2,
+  errorResponse2,
+  redirectResponse2,
+  stalledResponse2,
+  scenarioTable2,
+  requestsTo2,
+  noRequestContains2,
+  exports_openai_chat,
+  exports_openai_responses,
+  exports_azure_openai,
+  exports_anthropic_console_oauth,
+  OPAQUE_FIELD_NAMES2,
+  redactOpaqueFields2,
+  exports_anthropic_messages,
+  exports_bedrock,
+  exports_codex_oauth,
+  exports_gemini,
+  exports_openai_models,
+  base64UrlDecodeText2,
+  base64UrlDecodeBytes2,
+  verifyRs256Jwt2,
+  exports_vertex,
+  exports_xai_oauth
+} from "../index-k4mhh1q5.js";
+export {
+  OPAQUE_FIELD_NAMES2 as OPAQUE_FIELD_NAMES,
+  exports_anthropic_console_oauth as anthropicConsoleOauthFake,
+  exports_anthropic_messages as anthropicFake,
+  exports_azure_openai as azureFake,
+  base64UrlDecodeBytes2 as base64UrlDecodeBytes,
+  base64UrlDecodeText2 as base64UrlDecodeText,
+  exports_bedrock as bedrockFake,
+  exports_codex_oauth as codexFake,
+  errorResponse2 as errorResponse,
+  exports_gemini as geminiFake,
+  jsonResponse2 as jsonResponse,
+  noRequestContains2 as noRequestContains,
+  exports_openai_chat as openaiChatFake,
+  exports_openai_models as openaiModelsFake,
+  exports_openai_responses as openaiResponsesFake,
+  redactOpaqueFields2 as redactOpaqueFields,
+  redirectResponse2 as redirectResponse,
+  requestsTo2 as requestsTo,
+  scenarioTable2 as scenarioTable,
+  sseResponse2 as sseResponse,
+  stalledResponse2 as stalledResponse,
+  startFake2 as startFake,
+  verifyRs256Jwt2 as verifyRs256Jwt,
+  exports_vertex as vertexFake,
+  withFake2 as withFake,
+  exports_xai_oauth as xaiOauthFake
+};

package/dist/fakes/jwt-verify.d.ts

@@ -0,0 +1,13 @@
+export declare function base64UrlDecodeText(value: string): string;
+export declare function base64UrlDecodeBytes(value: string): Uint8Array;
+/**
+ * Verifies a compact RS256 JWT against a public key and returns its claims.
+ *
+ * Exported for the LOOPBACK FAKE, which is the whole point: a fake that accepted any assertion would
+ * make "the adapter authenticated correctly" untestable, and the only way to check a signature is to
+ * check it. Nothing in the shipped path calls this.
+ */
+export declare function verifyRs256Jwt(jwt: string, publicKey: CryptoKey): Promise<{
+    header: Record<string, unknown>;
+    claims: Record<string, unknown>;
+} | undefined>;

package/dist/fakes/openai-chat.d.ts

@@ -0,0 +1,61 @@
+import { type FakeRoute, type FakeServer, type RecordedRequest, type ScenarioResponder, type SseFrame } from "./server.js";
+export interface ChatToolCallScript {
+    index: number;
+    id: string;
+    name: string;
+    /** Argument fragments, in order. The first fragment carries the id and name; later ones carry the index alone. */
+    argumentChunks: string[];
+}
+export interface ChatScript {
+    id?: string;
+    model?: string;
+    /** `delta.content` payloads, in order. */
+    text?: string[];
+    /** `delta.reasoning_content` payloads — DeepSeek's exposed reasoning channel. */
+    reasoning?: string[];
+    /** Emit the exposed channel under OpenRouter's `reasoning` spelling instead of DeepSeek's `reasoning_content`. */
+    reasoningFieldIsPlain?: boolean;
+    toolCalls?: ChatToolCallScript[];
+    finishReason?: "stop" | "tool_calls" | "length" | "content_filter";
+    usage?: {
+        prompt: number;
+        completion: number;
+        cachedPrompt?: number;
+    };
+    /** An error object inside a 200 stream. */
+    inlineError?: {
+        message: string;
+        code: string;
+    };
+    /** A tool-call fragment opening a NEW slot with no id/name — the no-silent-tool-dropping probe. */
+    anonymousToolCall?: boolean;
+    frameDelayMs?: number;
+    /** Omit the terminating `[DONE]` — the shape most local servers actually produce. */
+    omitDone?: boolean;
+    /** Omit the finish_reason too: a stream that simply stops. */
+    omitFinish?: boolean;
+}
+export declare function chatFrames(script: ChatScript): SseFrame[];
+export declare function chatStream(script: ChatScript, opts?: {
+    dropAfter?: number;
+}): Response;
+export declare function chatModelOf(recorded: RecordedRequest): string | undefined;
+/**
+ * The wire invariant OpenAI and Azure both enforce: a `tool` message must respond to the assistant
+ * `tool_calls` message immediately before it, with only other `tool` messages in between.
+ *
+ * MODELLED HERE ON PURPOSE. A fake that accepts anything cannot fail a pin, and round 3 is exactly
+ * that story: a decoration was rendered as a `user` message between an assistant's `tool_calls` and
+ * its `tool` reply, every fixture stayed green, and the shape would have failed every real turn.
+ * The DeepSeek and Azure fakes already model their providers' refusals; this closes the gap.
+ */
+export declare function toolAdjacencyRefusal(body: string): Response | undefined;
+export interface OpenAiChatFakeOptions {
+    scenarios: Record<string, ScenarioResponder | Response[]>;
+    routes?: FakeRoute[];
+    unknownModel?: ScenarioResponder;
+}
+/** Serves `/chat/completions` in every path spelling the family's surfaces use (bare, `/v1`, and Azure's deployment path). */
+export declare function startOpenAiChatFake(opts: OpenAiChatFakeOptions): Promise<FakeServer>;
+/** A DeepSeek-shaped 400 for a tool loop missing its prior `reasoning_content` — §6.3's hard error, reproduced. */
+export declare function deepSeekMissingReasoningError(): Response;

package/dist/fakes/openai-models.d.ts

@@ -0,0 +1,49 @@
+import { type FakeRoute } from "./server.js";
+export interface ModelRow {
+    id?: unknown;
+    display_name?: string;
+    context_window?: number;
+    [k: string]: unknown;
+}
+export interface ModelsPage {
+    rows: ModelRow[];
+    hasMore?: boolean;
+}
+export interface OpenAiModelsFakeOptions {
+    /**
+     * Pages, in order. Page N+1 is served when the request carries an `after` cursor equal to page
+     * N's last id — so a fixture proves the adapter actually PAGED rather than asking twice.
+     */
+    pages: ModelsPage[];
+    /**
+     * Answer the Nth call (1-based) AND EVERY CALL AFTER IT with this status.
+     *
+     * Persistent rather than a single blip, and the distinction is load-bearing: the cached-fallback
+     * probe needs a SECOND failure to prove that a failure with no cache PROPAGATES, and a one-shot
+     * failure quietly succeeds on that call instead.
+     */
+    failOnCall?: {
+        call: number;
+        status: number;
+        body?: unknown;
+    };
+    /** Serve a body that is not JSON. */
+    notJson?: boolean;
+    /** Path prefix, for a surface whose discovery does not sit at the root (Azure's `/openai/models`). */
+    pathPrefix?: string;
+}
+/**
+ * Routes for `/models` and `/v1/models`.
+ *
+ * The cursor is honoured rather than ignored: a page is chosen by matching `after` against the
+ * previous page's last id, so an adapter that sends no cursor (or the wrong one) re-reads page 1 and
+ * a duplicate-id assertion catches it.
+ */
+export declare function openAiModelsRoutes(opts: OpenAiModelsFakeOptions): FakeRoute[];
+/** Ollama's own `/api/tags` shape — the local adapter's second discovery door. */
+export declare function ollamaTagsRoute(models: Array<{
+    name: string;
+    model?: string;
+}>): FakeRoute;
+/** A `/v1/models` that answers 404 — what a server which only speaks `/api/tags` does. */
+export declare function modelsNotFoundRoutes(): FakeRoute[];

package/dist/fakes/openai-responses.d.ts

@@ -0,0 +1,86 @@
+import { type FakeRoute, type FakeServer, type RecordedRequest, type ScenarioResponder, type SseFrame } from "./server.js";
+/** A Responses turn, described by what it CONTAINS rather than by its frames. */
+export interface ResponsesScript {
+    id?: string;
+    model?: string;
+    /** `response.output_text.delta` payloads, in order. */
+    text?: string[];
+    /** `response.reasoning_summary_text.delta` payloads — the readable summary channel. */
+    summary?: string[];
+    /** Completed reasoning items, by output index. `encrypted` becomes `encrypted_content`; an empty string means "summary only, nothing replayable". */
+    reasoningItems?: Array<{
+        index: number;
+        encrypted: string;
+        summaryText?: string;
+    }>;
+    calls?: Array<{
+        index: number;
+        itemId: string;
+        callId: string;
+        name: string;
+        /** When present, arguments arrive as `function_call_arguments.delta` frames. */
+        argumentChunks?: string[];
+        /** The complete `arguments` string on the final item. Defaults to the joined chunks. */
+        argumentsJson?: string;
+    }>;
+    usage?: {
+        input: number;
+        output: number;
+        cachedInput?: number;
+    };
+    /** Sets `incomplete_details.reason` on the completion event (`max_output_tokens` is the interesting one). */
+    incompleteReason?: string;
+    /** Adds a `refusal` content part to the completion's output message. */
+    refusal?: boolean;
+    /** An output item type this adapter cannot represent (`computer_call`, `mcp_call`, …) — the no-silent-tool-dropping probe. */
+    unrepresentableCall?: string;
+    /** Milliseconds before EVERY frame. The slow-stream / stall primitive. */
+    frameDelayMs?: number;
+    /** Emit `response.failed` instead of `response.completed`. */
+    failed?: string;
+    /** Omit the completion event entirely — a stream that just stops. */
+    omitCompleted?: boolean;
+}
+/**
+ * A script -> the SSE frames the real API produces, in the real order: created, summary, item
+ * openings, argument deltas, text, item completions, completion.
+ *
+ * The ORDER matters to more than one corpus case — `streaming-order` asserts it survives
+ * normalization unreordered, and `opaque-continuation` asserts the reasoning item is taken from the
+ * completion side of it rather than from `output_item.added`.
+ */
+export declare function responsesFrames(script: ResponsesScript): SseFrame[];
+/** A complete SSE response for one script. */
+export declare function responsesStream(script: ResponsesScript, opts?: {
+    dropAfter?: number;
+}): Response;
+/** Reads the model id out of a Responses request body — the key `scenarioTable` dispatches on. */
+export declare function responsesModelOf(recorded: RecordedRequest): string | undefined;
+/** The parsed request body, for a serialization assertion. Always read off the FAKE'S RECORD, never off adapter intent. */
+export declare function recordedBody(recorded: RecordedRequest): Record<string, unknown>;
+/**
+ * The Responses twin of the chat surface's tool-message adjacency: a `function_call_output` must
+ * follow the `function_call` it answers, with only other outputs in between.
+ *
+ * Same reason as `toolAdjacencyRefusal` — a fake that accepts anything cannot fail a pin, and round
+ * 3's decoration bug inserted exactly such an item.
+ */
+export declare function callPairingRefusal(body: string): Response | undefined;
+export interface OpenAiResponsesFakeOptions {
+    /** modelId -> scripted answer. A `Response[]` is consumed by attempt, with the last entry repeating. */
+    scenarios: Record<string, ScenarioResponder | Response[]>;
+    /** Extra routes (a `/models` page set, a redirect target). */
+    routes?: FakeRoute[];
+    unknownModel?: ScenarioResponder;
+}
+/**
+ * Starts a fake serving `/responses` and `/v1/responses` (the adapter's base may or may not carry
+ * the `/v1` segment, and a fixture should not have to care which).
+ */
+export declare function startOpenAiResponsesFake(opts: OpenAiResponsesFakeOptions): Promise<FakeServer>;
+/** An OpenAI-shaped error body: `{ error: { message, type, code } }`, with `code` AFTER an unbounded human message (which is the whole reason `parseProviderErrorCode` reads the full body). */
+export declare function openAiErrorBody(message: string, code: string, type?: string): Record<string, unknown>;
+/** A non-JSON body, for the malformed-response case. */
+export declare function htmlErrorResponse(status: number): Response;
+/** A 200 whose body is not SSE at all — the other half of `error-malformed`. */
+export declare function notSseResponse(): Response;

package/dist/fakes/redact-opaque.d.ts

@@ -0,0 +1,4 @@
+/** The field names whose VALUES are opaque provider state wherever they appear. */
+export declare const OPAQUE_FIELD_NAMES: readonly string[];
+/** A recorded body, safe to print. */
+export declare function redactOpaqueFields(body: string): string;