u1s1-cli-cn 1.17.0 → 1.19.0

package/dist/chat-protocol/anthropic.js

@@ -0,0 +1,484 @@
+// GENERATED from workers/gateway/src/chat-protocol/anthropic.ts; do not edit here. Edit the canonical file, then run: node scripts/sync-chat-protocol.mjs
+import { asRecord } from "./json.js";
+import { SSE_KEEPALIVE_COMMENT, SseParser } from "./sse.js";
+import { requestedThinkingLevel } from "./thinking.js";
+// Anthropic Messages (POST /v1/messages, Claude Code) <-> OpenAI Chat
+// Completions. The request is converted to a Chat body; the Chat response
+// (JSON or SSE) is converted back. Moved verbatim from the gateway's
+// anthropic-inbound.ts; what was gateway-specific is injected: the reasoning
+// fields (per-model thinking contract) and the usage mapping (the gateway
+// reuses its billing parser so clients see the token split they were billed).
+// See json.ts for the rules of this directory.
+export const MESSAGES_PATH = "/v1/messages";
+function count(value) {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+}
+/**
+ * Plain Chat Completions usage → Anthropic usage: cache reads
+ * (`prompt_tokens_details.cached_tokens`, or DeepSeek's
+ * `prompt_cache_hit_tokens`) are reported beside `input_tokens`, not in it.
+ */
+export function chatUsageToAnthropic(value) {
+    const usage = asRecord(value) ?? {};
+    const prompt = count(usage.prompt_tokens ?? usage.input_tokens);
+    const details = asRecord(usage.prompt_tokens_details) ?? asRecord(usage.input_tokens_details);
+    const cacheRead = Math.min(count(details?.cached_tokens ?? usage.prompt_cache_hit_tokens), prompt);
+    return {
+        input_tokens: prompt - cacheRead,
+        output_tokens: count(usage.completion_tokens ?? usage.output_tokens),
+        cache_read_input_tokens: cacheRead,
+        cache_creation_input_tokens: 0,
+    };
+}
+/** Anthropic error body: `{type: "error", error: {type, message}}`. */
+export function anthropicErrorBody(status, message) {
+    return { type: "error", error: { type: anthropicErrorType(status), message } };
+}
+// Claude Code prepends a request-metadata block to the system prompt. It is not
+// an instruction, and forwarding it would put a client-version string at the
+// very start of every upstream prompt (the prefix providers cache on).
+const BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
+function systemText(blocks) {
+    if (typeof blocks === "string")
+        return blocks;
+    if (!Array.isArray(blocks))
+        return "";
+    return blocks
+        .map((block) => {
+        const row = asRecord(block);
+        return row?.type === "text" && typeof row.text === "string" ? row.text : "";
+    })
+        .filter((text) => text && !text.startsWith(BILLING_HEADER_PREFIX))
+        .join("\n\n");
+}
+function imagePart(block) {
+    const source = asRecord(block.source);
+    if (source?.type === "base64" && typeof source.media_type === "string" && typeof source.data === "string") {
+        return { type: "image_url", image_url: { url: `data:${source.media_type};base64,${source.data}` } };
+    }
+    if (source?.type === "url" && typeof source.url === "string") {
+        return { type: "image_url", image_url: { url: source.url } };
+    }
+    return null;
+}
+/** text/image parts of a user turn; a text-only turn collapses to a plain string. */
+function userContent(parts) {
+    if (parts.every((part) => part.type === "text")) {
+        return parts.map((part) => part.text).join("\n\n");
+    }
+    return parts;
+}
+function toolResultMessage(block, images) {
+    const content = block.content;
+    let text = typeof content === "string" ? content : "";
+    if (Array.isArray(content)) {
+        const texts = [];
+        for (const item of content) {
+            const row = asRecord(item);
+            if (row?.type === "text" && typeof row.text === "string")
+                texts.push(row.text);
+            if (row?.type === "image") {
+                const image = imagePart(row);
+                if (image)
+                    images.push(image);
+            }
+        }
+        text = texts.join("\n\n");
+    }
+    if (block.is_error === true)
+        text = `Error: ${text}`;
+    return {
+        role: "tool",
+        tool_call_id: typeof block.tool_use_id === "string" ? block.tool_use_id : "unknown",
+        content: text,
+    };
+}
+function convertUserTurn(content, out) {
+    if (typeof content === "string") {
+        out.push({ role: "user", content });
+        return;
+    }
+    const parts = [];
+    const toolImages = [];
+    for (const item of Array.isArray(content) ? content : []) {
+        const block = asRecord(item);
+        if (!block)
+            continue;
+        if (block.type === "tool_result") {
+            // OpenAI requires tool messages directly after the assistant tool_calls turn.
+            out.push(toolResultMessage(block, toolImages));
+        }
+        else if (block.type === "text" && typeof block.text === "string") {
+            parts.push({ type: "text", text: block.text });
+        }
+        else if (block.type === "image") {
+            const image = imagePart(block);
+            if (image)
+                parts.push(image);
+        }
+        else if (block.type === "document") {
+            parts.push({ type: "text", text: "[document attachment omitted: unsupported by this endpoint]" });
+        }
+    }
+    // Chat Completions tool messages cannot carry images: replay them as a user turn.
+    if (toolImages.length)
+        parts.unshift({ type: "text", text: "Images returned by the tool call above:" }, ...toolImages);
+    if (parts.length)
+        out.push({ role: "user", content: userContent(parts) });
+}
+function convertAssistantTurn(content, out) {
+    if (typeof content === "string") {
+        out.push({ role: "assistant", content });
+        return;
+    }
+    const text = [];
+    const reasoning = [];
+    const toolCalls = [];
+    for (const item of Array.isArray(content) ? content : []) {
+        const block = asRecord(item);
+        if (block?.type === "text" && typeof block.text === "string")
+            text.push(block.text);
+        if (block?.type === "thinking" && typeof block.thinking === "string")
+            reasoning.push(block.thinking);
+        if (block?.type === "tool_use" && typeof block.name === "string") {
+            toolCalls.push({
+                id: typeof block.id === "string" ? block.id : `call_${crypto.randomUUID()}`,
+                type: "function",
+                function: { name: block.name, arguments: JSON.stringify(block.input ?? {}) },
+            });
+        }
+    }
+    const message = { role: "assistant", content: text.length ? text.join("") : null };
+    // DeepSeek thinking mode requires reasoning_content replay on tool-call turns.
+    if (reasoning.length)
+        message.reasoning_content = reasoning.join("");
+    if (toolCalls.length)
+        message.tool_calls = toolCalls;
+    if (message.content === null && !toolCalls.length)
+        message.content = "";
+    out.push(message);
+}
+function convertTools(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const tools = [];
+    for (const item of value) {
+        const tool = asRecord(item);
+        // Server tools (web_search_20250305 etc.) carry a versioned type and no schema.
+        if (typeof tool?.name !== "string" || !asRecord(tool.input_schema))
+            continue;
+        tools.push({
+            type: "function",
+            function: {
+                name: tool.name,
+                ...(typeof tool.description === "string" ? { description: tool.description } : {}),
+                parameters: tool.input_schema,
+            },
+        });
+    }
+    return tools.length ? tools : undefined;
+}
+function convertToolChoice(value) {
+    const choice = asRecord(value);
+    if (choice?.type === "auto")
+        return "auto";
+    if (choice?.type === "any")
+        return "required";
+    if (choice?.type === "none")
+        return "none";
+    if (choice?.type === "tool" && typeof choice.name === "string") {
+        return { type: "function", function: { name: choice.name } };
+    }
+    return undefined;
+}
+/**
+ * Anthropic Messages request → Chat Completions body. `thinking` and
+ * `output_config.effort` become whatever `reasoningFields` returns for the
+ * requested level (thinking.ts); `metadata` is dropped on purpose.
+ */
+export function anthropicRequestToChat(body, reasoningFields) {
+    const messages = [];
+    const system = systemText(body.system);
+    if (system)
+        messages.push({ role: "system", content: system });
+    for (const item of Array.isArray(body.messages) ? body.messages : []) {
+        const message = asRecord(item);
+        if (message?.role === "assistant")
+            convertAssistantTurn(message.content, messages);
+        else if (message?.role === "user")
+            convertUserTurn(message.content, messages);
+    }
+    const converted = { model: body.model, messages, stream: body.stream === true };
+    if (typeof body.max_tokens === "number")
+        converted.max_tokens = body.max_tokens;
+    for (const field of ["temperature", "top_p"]) {
+        if (typeof body[field] === "number")
+            converted[field] = body[field];
+    }
+    if (Array.isArray(body.stop_sequences) && body.stop_sequences.length)
+        converted.stop = body.stop_sequences;
+    Object.assign(converted, reasoningFields(String(body.model ?? ""), requestedThinkingLevel(body)));
+    const tools = convertTools(body.tools);
+    if (tools) {
+        converted.tools = tools;
+        const toolChoice = convertToolChoice(body.tool_choice);
+        if (toolChoice !== undefined)
+            converted.tool_choice = toolChoice;
+        if (asRecord(body.tool_choice)?.disable_parallel_tool_use === true)
+            converted.parallel_tool_calls = false;
+    }
+    return converted;
+}
+function stopReason(reason) {
+    if (reason === "length")
+        return "max_tokens";
+    if (reason === "tool_calls" || reason === "function_call")
+        return "tool_use";
+    return "end_turn";
+}
+function messageId(raw) {
+    return typeof raw === "string" && raw.startsWith("msg_") ? raw : `msg_${crypto.randomUUID().replaceAll("-", "")}`;
+}
+export function chatCompletionToAnthropic(value, requestedModel, usage = chatUsageToAnthropic) {
+    const completion = asRecord(value) ?? {};
+    const choice = asRecord(Array.isArray(completion.choices) ? completion.choices[0] : null) ?? {};
+    const message = asRecord(choice.message) ?? {};
+    const content = [];
+    const reasoning = message.reasoning_content ?? message.reasoning;
+    if (typeof reasoning === "string" && reasoning)
+        content.push({ type: "thinking", thinking: reasoning, signature: "" });
+    if (typeof message.content === "string" && message.content)
+        content.push({ type: "text", text: message.content });
+    for (const item of Array.isArray(message.tool_calls) ? message.tool_calls : []) {
+        const call = asRecord(item);
+        const fn = asRecord(call?.function);
+        if (typeof fn?.name !== "string")
+            continue;
+        let input = {};
+        try {
+            input = typeof fn.arguments === "string" && fn.arguments.trim() ? JSON.parse(fn.arguments) : {};
+        }
+        catch {
+            input = { raw: fn.arguments };
+        }
+        content.push({
+            type: "tool_use",
+            id: typeof call?.id === "string" ? call.id : `toolu_${crypto.randomUUID()}`,
+            name: fn.name,
+            input,
+        });
+    }
+    return {
+        id: messageId(completion.id),
+        type: "message",
+        role: "assistant",
+        model: requestedModel,
+        content,
+        stop_reason: stopReason(choice.finish_reason),
+        stop_sequence: null,
+        usage: usage(completion.usage),
+    };
+}
+/** OpenAI chat.completion.chunk SSE → Anthropic Messages SSE event sequence. */
+export function chatSseToAnthropic(requestedModel, usage = chatUsageToAnthropic) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const parser = new SseParser();
+    const state = {
+        started: false,
+        finished: false,
+        blockIndex: -1,
+        open: null,
+        openToolIndex: null,
+        stopReason: "end_turn",
+        usage: usage(null),
+    };
+    const emit = (controller, type, data) => {
+        controller.enqueue(encoder.encode(`event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`));
+    };
+    const start = (controller, id) => {
+        if (state.started)
+            return;
+        state.started = true;
+        emit(controller, "message_start", {
+            message: {
+                id: messageId(id),
+                type: "message",
+                role: "assistant",
+                model: requestedModel,
+                content: [],
+                stop_reason: null,
+                stop_sequence: null,
+                usage: { input_tokens: 0, output_tokens: 0 },
+            },
+        });
+    };
+    const closeBlock = (controller) => {
+        if (!state.open)
+            return;
+        emit(controller, "content_block_stop", { index: state.blockIndex });
+        state.open = null;
+        state.openToolIndex = null;
+    };
+    const openBlock = (controller, kind, block) => {
+        closeBlock(controller);
+        state.blockIndex += 1;
+        state.open = kind;
+        emit(controller, "content_block_start", { index: state.blockIndex, content_block: block });
+    };
+    const delta = (controller, data) => {
+        emit(controller, "content_block_delta", { index: state.blockIndex, delta: data });
+    };
+    const toolDeltas = (controller, calls) => {
+        for (const item of calls) {
+            const call = asRecord(item);
+            if (!call)
+                continue;
+            const fn = asRecord(call.function) ?? {};
+            const index = Number(call.index ?? 0);
+            if (state.open !== "tool_use" || (state.openToolIndex !== index && typeof fn.name === "string")) {
+                openBlock(controller, "tool_use", {
+                    type: "tool_use",
+                    id: typeof call.id === "string" ? call.id : `toolu_${crypto.randomUUID()}`,
+                    name: typeof fn.name === "string" ? fn.name : "",
+                    input: {},
+                });
+                state.openToolIndex = index;
+            }
+            if (typeof fn.arguments === "string" && fn.arguments) {
+                delta(controller, { type: "input_json_delta", partial_json: fn.arguments });
+            }
+        }
+    };
+    const finish = (controller) => {
+        if (state.finished)
+            return;
+        start(controller, null);
+        closeBlock(controller);
+        state.finished = true;
+        emit(controller, "message_delta", {
+            delta: { stop_reason: state.stopReason, stop_sequence: null },
+            usage: state.usage,
+        });
+        emit(controller, "message_stop", {});
+    };
+    const fail = (controller, message, type = "api_error") => {
+        if (state.finished)
+            return;
+        state.finished = true;
+        emit(controller, "error", { error: { type, message } });
+    };
+    const consume = (event, controller) => {
+        if (state.finished)
+            return;
+        const data = event.data.trim();
+        if (!data) {
+            // Keepalive comment frames: forward as ping so client idle timers reset.
+            // Before message_start a ping would be out of order, so pass the comment through.
+            if (state.started)
+                emit(controller, "ping", {});
+            else
+                controller.enqueue(encoder.encode(SSE_KEEPALIVE_COMMENT));
+            return;
+        }
+        if (data === "[DONE]") {
+            finish(controller);
+            return;
+        }
+        let chunk;
+        try {
+            chunk = asRecord(JSON.parse(data));
+        }
+        catch {
+            chunk = null;
+        }
+        if (!chunk)
+            return;
+        const error = asRecord(chunk.error);
+        if (error) {
+            // Gateway error frames sent after the keepalive headers carry the HTTP status they replaced.
+            const type = typeof error.upstream_status === "number" ? anthropicErrorType(error.upstream_status) : "api_error";
+            fail(controller, typeof error.message === "string" ? error.message : "upstream stream error", type);
+            return;
+        }
+        start(controller, chunk.id);
+        if (asRecord(chunk.usage))
+            state.usage = usage(chunk.usage);
+        const choice = asRecord(Array.isArray(chunk.choices) ? chunk.choices[0] : null);
+        if (!choice)
+            return;
+        const d = asRecord(choice.delta) ?? {};
+        const reasoning = d.reasoning_content ?? d.reasoning;
+        if (typeof reasoning === "string" && reasoning) {
+            if (state.open !== "thinking")
+                openBlock(controller, "thinking", { type: "thinking", thinking: "", signature: "" });
+            delta(controller, { type: "thinking_delta", thinking: reasoning });
+        }
+        if (typeof d.content === "string" && d.content) {
+            if (state.open !== "text")
+                openBlock(controller, "text", { type: "text", text: "" });
+            delta(controller, { type: "text_delta", text: d.content });
+        }
+        if (Array.isArray(d.tool_calls))
+            toolDeltas(controller, d.tool_calls);
+        if (typeof choice.finish_reason === "string")
+            state.stopReason = stopReason(choice.finish_reason);
+    };
+    const consumeAll = (events, controller) => {
+        for (const event of events)
+            consume(event, controller);
+    };
+    return new TransformStream({
+        transform(bytes, controller) {
+            try {
+                consumeAll(parser.push(decoder.decode(bytes, { stream: true })), controller);
+            }
+            catch (error) {
+                fail(controller, error instanceof Error ? error.message : "stream conversion failed");
+            }
+        },
+        flush(controller) {
+            try {
+                consumeAll(parser.finish(decoder.decode()), controller);
+            }
+            catch (error) {
+                fail(controller, error instanceof Error ? error.message : "stream conversion failed");
+            }
+            // A stream that ended without [DONE] or a terminal frame was cut off upstream.
+            if (!state.finished) {
+                if (state.started)
+                    fail(controller, "stream ended unexpectedly");
+                else
+                    finish(controller);
+            }
+        },
+    });
+}
+export function anthropicErrorType(status) {
+    if (status === 400)
+        return "invalid_request_error";
+    if (status === 401)
+        return "authentication_error";
+    if (status === 403)
+        return "permission_error";
+    if (status === 404)
+        return "not_found_error";
+    if (status === 413)
+        return "request_too_large";
+    if (status === 429)
+        return "rate_limit_error";
+    if (status === 529 || status === 503)
+        return "overloaded_error";
+    return "api_error";
+}
+/**
+ * Anthropic SDKs retry 408/409/429/5xx unless the server sends
+ * `x-should-retry: false`. Quota and policy refusals are final: without the
+ * header the client would hammer the gateway with retries.
+ */
+export function anthropicShouldRetry(status, code) {
+    if (status === 429)
+        return code !== "quota_exceeded";
+    return status === 408 || status === 409 || status >= 500;
+}

package/dist/chat-protocol/json.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared chat-protocol modules (this directory): pure Anthropic Messages /
+ * OpenAI Responses <-> OpenAI Chat Completions conversion, used by the gateway
+ * (/v1/messages, /v1/responses) and by the u1s1 CLI's local signing proxy
+ * (custom endpoints for Claude Code / Codex).
+ *
+ * The canonical copy lives in workers/gateway/src/chat-protocol/; the CLI keeps
+ * an identical copy (plus a generated-file header line) in
+ * packages/cli/src/chat-protocol/ (the self-hosted gateway image only sees
+ * workers/*, the npm package only sees packages/cli).
+ * Edit here, then run `node scripts/sync-chat-protocol.mjs`; tests on both
+ * sides fail when the copies differ.
+ *
+ * Rules: Web-standard globals only (fetch types, streams, TextEncoder, crypto,
+ * btoa/atob) available in Workers and Node >= 22.19; no gateway env, billing,
+ * logging or storage; relative imports with `.ts` extensions only.
+ */
+export type JsonRecord = Record<string, unknown>;
+/** Plain object (not null, not an array) or null. */
+export declare function asRecord(value: unknown): JsonRecord | null;

package/dist/chat-protocol/json.js

@@ -0,0 +1,22 @@
+// GENERATED from workers/gateway/src/chat-protocol/json.ts; do not edit here. Edit the canonical file, then run: node scripts/sync-chat-protocol.mjs
+/**
+ * Shared chat-protocol modules (this directory): pure Anthropic Messages /
+ * OpenAI Responses <-> OpenAI Chat Completions conversion, used by the gateway
+ * (/v1/messages, /v1/responses) and by the u1s1 CLI's local signing proxy
+ * (custom endpoints for Claude Code / Codex).
+ *
+ * The canonical copy lives in workers/gateway/src/chat-protocol/; the CLI keeps
+ * an identical copy (plus a generated-file header line) in
+ * packages/cli/src/chat-protocol/ (the self-hosted gateway image only sees
+ * workers/*, the npm package only sees packages/cli).
+ * Edit here, then run `node scripts/sync-chat-protocol.mjs`; tests on both
+ * sides fail when the copies differ.
+ *
+ * Rules: Web-standard globals only (fetch types, streams, TextEncoder, crypto,
+ * btoa/atob) available in Workers and Node >= 22.19; no gateway env, billing,
+ * logging or storage; relative imports with `.ts` extensions only.
+ */
+/** Plain object (not null, not an array) or null. */
+export function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}

package/dist/chat-protocol/responses.d.ts

@@ -0,0 +1,97 @@
+import { type JsonRecord } from "./json.ts";
+import { type ReasoningFields } from "./thinking.ts";
+export declare const RESPONSES_PATH = "/v1/responses";
+/** What the request converter dropped; logged by the route, asserted by tests. */
+export interface ResponsesConversionNotes {
+    skippedItems: string[];
+    skippedTools: string[];
+    /** custom (freeform) tool names: calls to these come back as custom_tool_call. */
+    customTools: string[];
+    /** Namespaces seen in `tools`, `additional_tools` and `tool_search_output`. */
+    namespaces: string[];
+    /** Shortened Chat names (see chatToolName) → the client's name and namespace. */
+    aliases: Record<string, {
+        name: string;
+        namespace?: string;
+    }>;
+    /** The client offered `tool_search` with client-side execution. */
+    toolSearch: boolean;
+}
+export interface ResponsesConversion {
+    body: JsonRecord;
+    notes: ResponsesConversionNotes;
+}
+/** What a gateway reasoning blob carries. */
+export interface ReasoningPayload {
+    text: string;
+    /**
+     * Aggregator-style `reasoning_details` (signed thinking, encrypted
+     * reasoning) exactly as the upstream sent them, merged per `index` when
+     * streamed. Replayed verbatim; the upstream verifies its own signatures.
+     */
+    details?: JsonRecord[];
+}
+/**
+ * Opaque reasoning blob handed to the client as `encrypted_content`. Not
+ * encrypted: the text is the user's own conversation and replaying a tampered
+ * one is no different from editing a message (signed details are verified by
+ * the upstream that issued them). `{r}` is the P0 layout; `d` was added
+ * without a version bump because older readers ignore it.
+ */
+export declare function encodeReasoningBlob(reasoning: string, details?: readonly JsonRecord[]): string;
+export declare function decodeReasoningPayload(blob: unknown): ReasoningPayload | null;
+export declare function decodeReasoningBlob(blob: unknown): string | null;
+/**
+ * Merges streamed `reasoning_details` fragments: entries sharing an `index`
+ * are one block whose `text`/`summary`/`data` arrive in pieces and whose
+ * `signature`/`id`/`format` arrive once. Fragments without an index append.
+ */
+export declare function mergeReasoningDetails(into: JsonRecord[], fragments: unknown): void;
+/**
+ * Responses request → Chat Completions body. Only the fields below are read;
+ * everything else (`store`, `include`, `client_metadata`, `text.verbosity`,
+ * `service_tier`, `truncation`, `metadata`, future fields …) is ignored.
+ * `prompt_cache_key` is forwarded (Chat whitelist field, also feeds
+ * upstream session affinity).
+ */
+export declare function responsesRequestToChat(body: JsonRecord, reasoningFields: ReasoningFields): ResponsesConversion;
+/** What the response converter needs to know about the original request. */
+export interface ResponsesContext {
+    model: string;
+    /** Set when the client relied on server-side state we do not keep. */
+    previousResponseId: string | null;
+    /** `conversation` (Conversations API): server-side state as well. */
+    conversation?: string | null;
+    customTools: readonly string[];
+    namespaces: readonly string[];
+    /** Shortened Chat tool names → client name/namespace. */
+    aliases?: Readonly<Record<string, {
+        name: string;
+        namespace?: string;
+    }>>;
+    /** Calls to `tool_search` come back as client-executed `tool_search_call`. */
+    toolSearch?: boolean;
+    /** The client asked for SSE; errors that Codex only understands in-stream use it. */
+    stream?: boolean;
+}
+export declare function responsesContext(body: JsonRecord, notes: ResponsesConversionNotes): ResponsesContext;
+export declare function openAICompletionToResponses(value: unknown, ctx: ResponsesContext): JsonRecord;
+/** OpenAI chat.completion.chunk SSE → Responses SSE event sequence. */
+export declare function openAISseToResponses(ctx: ResponsesContext): TransformStream<Uint8Array, Uint8Array>;
+type ErrorClass = "final" | "context" | "retry";
+export declare function classifyError(status: number, code: unknown): ErrorClass;
+/** `response.failed` error code for a gateway error frame. */
+export declare function responsesStreamErrorCode(status: number, code: unknown): string;
+/** SSE body with just `response.created` + `response.failed`, for errors Codex only understands in-stream. */
+export declare function failedStream(ctx: ResponsesContext, code: string, message: string, headers: Headers): Response;
+/**
+ * The one shape of a final error on /v1/responses: HTTP 400, `code: "invalid_prompt"`
+ * (or `model_not_found`, the other code Codex displays), `x-should-retry: false`, the
+ * gateway's own code and status kept as `u1s1_code` / `u1s1_status`. Codex sends the
+ * turn once and shows `message`. Used for chat-pipeline errors (errorToResponses) and
+ * auth-stage refusals (auth.ts) alike.
+ */
+export declare function responsesFinalError(error: JsonRecord | null, status: number, message: string, headers?: Headers): Response;
+/** Convert the Chat Completions handler's response into a Responses API response. */
+export declare function openAIResponseToResponses(response: Response, ctx: ResponsesContext): Promise<Response>;
+export {};