u1s1-cli 1.18.0 → 1.20.0

package/dist/chat-protocol/responses.js

@@ -0,0 +1,1076 @@
+// GENERATED from workers/gateway/src/chat-protocol/responses.ts; do not edit here. Edit the canonical file, then run: node scripts/sync-chat-protocol.mjs
+import { asRecord } from "./json.js";
+import { SseParser } from "./sse.js";
+import { responsesThinkingLevel } from "./thinking.js";
+// OpenAI Responses (POST /v1/responses, Codex CLI) <-> OpenAI Chat Completions.
+// Moved verbatim from the gateway's responses-inbound.ts; the per-model
+// reasoning fields are injected (responsesRequestToChat). Shared with the u1s1
+// CLI's local proxy; see json.ts for the rules of this directory.
+//
+// Inbound OpenAI Responses adapter (POST /v1/responses), used by Codex CLI.
+// Same shape as anthropic-inbound.ts: the request becomes a Chat Completions
+// body before auth/billing/routing see it, and the finished Chat response
+// (JSON or SSE) is converted back here.
+//
+// Only the stateless subset is supported: `store: false`, full `input` every
+// turn, no `previous_response_id` (exactly what Codex sends over HTTP).
+// Unknown top-level fields, input items and tool kinds are ignored or skipped
+// and reported, never rejected: Codex adds new item/tool kinds often.
+//
+// Mappings (checked against Codex CLI 0.167.2 talking to a local mock):
+// - `custom` (freeform/grammar) tools become a function with one string
+//   parameter `input`; the call comes back as `custom_tool_call`. The grammar
+//   is only described to the model, not enforced.
+// - `namespace` tools are flattened to `<namespace>__<name>` functions and the
+//   call comes back as `function_call` with `name` + `namespace`.
+// - `tool_search` with `execution: "client"` (Codex runs the BM25 search over
+//   its deferred tools itself) becomes a plain function; the call comes back as
+//   `tool_search_call` with object `arguments`, and the `tool_search_output`
+//   Codex sends next turn adds the discovered tools to the Chat tool list.
+//   `additional_tools` input items add their tools the same way.
+// - Reasoning streams as reasoning-summary events. The upstream's reasoning
+//   text and any structured `reasoning_details` (signed/encrypted reasoning
+//   from aggregator-style upstreams) are wrapped into a gateway-issued
+//   `encrypted_content` and replayed on the next assistant turn. Foreign blobs
+//   (issued by the real Responses API) cannot be replayed and are dropped.
+//
+// Skipped (reported in notes, logged by userAuth):
+// - Hosted tools the gateway has no backend for: `web_search`,
+//   `image_generation`, `file_search`, `code_interpreter`, `computer_use*`,
+//   `mcp`, server-side `tool_search`, `local_shell` (legacy, not sent to the
+//   models Codex reaches through a custom provider).
+// - Input items with no Chat equivalent: `web_search_call`,
+//   `image_generation_call`, `compaction` / `context_compaction` (encrypted
+//   remote-compaction summaries; custom providers compact locally),
+//   `agent_message` (inter-agent message whose shape is not documented),
+//   `local_shell_call`, `configuration_update`, `compaction_trigger` and
+//   anything new. A tool output whose call was skipped is replayed as user
+//   text so the Chat history stays valid.
+//
+// Privacy: Codex puts local paths and an installation id into the
+// `x-codex-turn-metadata` header and the `client_metadata` body field. Only
+// the converted Chat body is archived (request-archive.ts → R2) and request
+// headers are never archived, so both are dropped here by construction: the
+// converter copies a fixed set of fields and nothing else.
+export const RESPONSES_PATH = "/v1/responses";
+const NAMESPACE_SEPARATOR = "__";
+const REASONING_BLOB_PREFIX = "u1s1r1.";
+/** Chat function name the client-executed `tool_search` tool is exposed as. */
+const TOOL_SEARCH_NAME = "tool_search";
+// ---- reasoning blob ----
+function base64UrlEncode(text) {
+    const bytes = new TextEncoder().encode(text);
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function base64UrlDecode(text) {
+    try {
+        const binary = atob(text.replaceAll("-", "+").replaceAll("_", "/"));
+        return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 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 function encodeReasoningBlob(reasoning, details) {
+    return REASONING_BLOB_PREFIX + base64UrlEncode(JSON.stringify(details?.length ? { r: reasoning, d: details } : { r: reasoning }));
+}
+export function decodeReasoningPayload(blob) {
+    if (typeof blob !== "string" || !blob.startsWith(REASONING_BLOB_PREFIX))
+        return null;
+    const json = base64UrlDecode(blob.slice(REASONING_BLOB_PREFIX.length));
+    if (json === null)
+        return null;
+    try {
+        const value = asRecord(JSON.parse(json));
+        if (typeof value?.r !== "string")
+            return null;
+        const details = Array.isArray(value.d) ? value.d.map(asRecord).filter((d) => d !== null) : [];
+        return details.length ? { text: value.r, details } : { text: value.r };
+    }
+    catch {
+        return null;
+    }
+}
+export function decodeReasoningBlob(blob) {
+    return decodeReasoningPayload(blob)?.text ?? 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 function mergeReasoningDetails(into, fragments) {
+    for (const entry of Array.isArray(fragments) ? fragments : []) {
+        const fragment = asRecord(entry);
+        if (!fragment)
+            continue;
+        const existing = typeof fragment.index === "number"
+            ? into.find((detail) => detail.index === fragment.index && detail.type === fragment.type)
+            : undefined;
+        if (!existing) {
+            into.push({ ...fragment });
+            continue;
+        }
+        for (const [key, value] of Object.entries(fragment)) {
+            if ((key === "text" || key === "summary" || key === "data") && typeof value === "string" && typeof existing[key] === "string") {
+                existing[key] = existing[key] + value;
+            }
+            else if (value !== null && value !== undefined) {
+                existing[key] = value;
+            }
+        }
+    }
+}
+// ---- request: Responses → Chat Completions ----
+function contentParts(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    const parts = [];
+    for (const item of Array.isArray(content) ? content : []) {
+        const part = asRecord(item);
+        if (!part)
+            continue;
+        if ((part.type === "input_text" || part.type === "output_text" || part.type === "text") && typeof part.text === "string") {
+            parts.push({ type: "text", text: part.text });
+        }
+        else if (part.type === "refusal" && typeof part.refusal === "string") {
+            parts.push({ type: "text", text: part.refusal });
+        }
+        else if (part.type === "input_image") {
+            const url = typeof part.image_url === "string" ? part.image_url : null;
+            if (url) {
+                parts.push({
+                    type: "image_url",
+                    image_url: { url, ...(typeof part.detail === "string" && part.detail !== "auto" ? { detail: part.detail === "original" ? "high" : part.detail } : {}) },
+                });
+            }
+            else {
+                parts.push({ type: "text", text: "[image attachment omitted: only inline image URLs are supported]" });
+            }
+        }
+        else if (part.type === "input_file") {
+            parts.push({ type: "text", text: "[file attachment omitted: unsupported by this endpoint]" });
+        }
+    }
+    return parts;
+}
+function textOnly(parts) {
+    return parts.filter((part) => part.type === "text").map((part) => part.text).join("\n\n");
+}
+/** text/image parts of a turn; a text-only turn collapses to a plain string. */
+function collapse(parts) {
+    return parts.every((part) => part.type === "text") ? textOnly(parts) : parts;
+}
+/** Chat Completions upstreams reject function names longer than this. */
+const MAX_CHAT_TOOL_NAME = 64;
+function fnv1a(text) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i += 1)
+        hash = Math.imul(hash ^ text.charCodeAt(i), 0x01000193) >>> 0;
+    return hash.toString(16).padStart(8, "0");
+}
+/**
+ * Chat function name for a (possibly namespaced) tool. Deterministic, because
+ * the request side (tool list, history items) and the response side compute it
+ * independently every turn; over-long names are cut and suffixed with a hash.
+ */
+function chatToolName(name, namespace) {
+    const full = typeof namespace === "string" && namespace ? `${namespace}${NAMESPACE_SEPARATOR}${name}` : name;
+    if (full.length <= MAX_CHAT_TOOL_NAME)
+        return full;
+    return `${full.slice(0, MAX_CHAT_TOOL_NAME - 9)}_${fnv1a(full)}`;
+}
+function toolOutputText(output, images) {
+    if (typeof output === "string")
+        return output;
+    const parts = contentParts(output);
+    for (const part of parts)
+        if (part.type === "image_url")
+            images.push(part);
+    return textOnly(parts);
+}
+function functionTool(name, description, parameters, strict) {
+    return {
+        type: "function",
+        function: {
+            name,
+            ...(typeof description === "string" && description ? { description } : {}),
+            parameters: asRecord(parameters) ?? { type: "object", properties: {} },
+            ...(strict === true ? { strict: true } : {}),
+        },
+    };
+}
+function customToolDescription(tool) {
+    const description = typeof tool.description === "string" ? tool.description : "";
+    const format = asRecord(tool.format);
+    const grammar = format?.type === "grammar" && typeof format.definition === "string"
+        ? `\n\nPut the raw tool input (not JSON-encoded) in the \`input\` string. It must match this ${String(format.syntax ?? "")} grammar:\n${format.definition}`
+        : "\n\nPut the raw tool input in the `input` string.";
+    return description + grammar;
+}
+function convertTools(value, notes, out, namespace) {
+    for (const item of Array.isArray(value) ? value : []) {
+        const tool = asRecord(item);
+        if (!tool)
+            continue;
+        const name = typeof tool.name === "string" ? tool.name : "";
+        const chatName = chatToolName(name, namespace);
+        if (name && chatName !== (namespace ? `${namespace}${NAMESPACE_SEPARATOR}${name}` : name)) {
+            notes.aliases[chatName] = namespace ? { name, namespace } : { name };
+        }
+        // The same tool can arrive twice (tools + a later tool_search_output);
+        // duplicate Chat function names are rejected by most upstreams.
+        if (name && out.some((existing) => asRecord(existing.function)?.name === chatName))
+            continue;
+        if (tool.type === "function" && name) {
+            out.push(functionTool(chatName, tool.description, tool.parameters, tool.strict));
+        }
+        else if (tool.type === "custom" && name) {
+            notes.customTools.push(chatName);
+            out.push(functionTool(chatName, customToolDescription(tool), {
+                type: "object",
+                properties: { input: { type: "string", description: "Raw tool input." } },
+                required: ["input"],
+                additionalProperties: false,
+            }));
+        }
+        else if (tool.type === "namespace" && name && !namespace) {
+            if (!notes.namespaces.includes(name))
+                notes.namespaces.push(name);
+            convertTools(tool.tools, notes, out, name);
+        }
+        else if (tool.type === "tool_search" && tool.execution === "client" && !namespace) {
+            if (notes.toolSearch)
+                continue;
+            notes.toolSearch = true;
+            out.push(functionTool(TOOL_SEARCH_NAME, tool.description, tool.parameters));
+        }
+        else {
+            notes.skippedTools.push(String(tool.type ?? "unknown") + (name ? `:${name}` : ""));
+        }
+    }
+}
+/** Tool names a `tool_search_output` made available, for the tool message text. */
+function discoveredToolNames(value) {
+    const names = [];
+    for (const item of Array.isArray(value) ? value : []) {
+        const tool = asRecord(item);
+        if (typeof tool?.name !== "string")
+            continue;
+        if (tool.type === "namespace") {
+            for (const inner of Array.isArray(tool.tools) ? tool.tools : []) {
+                const name = asRecord(inner)?.name;
+                if (typeof name === "string")
+                    names.push(chatToolName(name, tool.name));
+            }
+        }
+        else {
+            names.push(tool.name);
+        }
+    }
+    return names;
+}
+function convertToolChoice(value) {
+    if (value === "auto" || value === "none" || value === "required")
+        return value;
+    const choice = asRecord(value);
+    if ((choice?.type === "function" || choice?.type === "custom") && typeof choice.name === "string") {
+        return { type: "function", function: { name: chatToolName(choice.name, choice.namespace) } };
+    }
+    return undefined;
+}
+function responseFormat(text) {
+    const format = asRecord(asRecord(text)?.format);
+    if (format?.type === "json_schema" && asRecord(format.schema)) {
+        return {
+            type: "json_schema",
+            json_schema: {
+                name: typeof format.name === "string" ? format.name : "output",
+                schema: format.schema,
+                ...(typeof format.strict === "boolean" ? { strict: format.strict } : {}),
+            },
+        };
+    }
+    if (format?.type === "json_object")
+        return { type: "json_object" };
+    return undefined;
+}
+/** Builds Chat messages from Responses `input`, merging assistant items of one turn. */
+class MessageBuilder {
+    messages = [];
+    assistant = null;
+    pendingReasoning = [];
+    /** Images returned by tool calls, replayed as one user turn after the tool messages. */
+    pendingImages = [];
+    notes;
+    constructor(notes) {
+        this.notes = notes;
+    }
+    flushAssistant() {
+        if (!this.assistant)
+            return;
+        if (this.assistant.content === null && !this.assistant.tool_calls)
+            this.assistant.content = "";
+        this.messages.push(this.assistant);
+        this.assistant = null;
+    }
+    flushImages() {
+        if (!this.pendingImages.length)
+            return;
+        // Chat Completions tool messages cannot carry images: replay them as a user turn.
+        this.messages.push({ role: "user", content: [{ type: "text", text: "Images returned by the tool calls above:" }, ...this.pendingImages] });
+        this.pendingImages = [];
+    }
+    currentAssistant() {
+        if (!this.assistant) {
+            this.flushImages();
+            this.assistant = { role: "assistant", content: null };
+            // Thinking-mode models require reasoning_content replay on tool-call turns;
+            // signed/encrypted details go back as `reasoning_details`.
+            if (this.pendingReasoning.length) {
+                this.assistant.reasoning_content = this.pendingReasoning.map((r) => r.text).join("");
+                const details = this.pendingReasoning.flatMap((r) => r.details ?? []);
+                if (details.length)
+                    this.assistant.reasoning_details = details;
+            }
+            this.pendingReasoning = [];
+        }
+        return this.assistant;
+    }
+    push(message) {
+        this.flushAssistant();
+        this.flushImages();
+        this.pendingReasoning = [];
+        this.messages.push(message);
+    }
+    system(text) {
+        if (text)
+            this.push({ role: "system", content: text });
+    }
+    message(item) {
+        const parts = contentParts(item.content);
+        if (item.role === "assistant") {
+            const text = textOnly(parts);
+            const assistant = this.currentAssistant();
+            // A text message after tool calls starts a new assistant turn in Chat terms.
+            if (assistant.tool_calls) {
+                this.flushAssistant();
+                this.currentAssistant().content = text;
+            }
+            else {
+                assistant.content = typeof assistant.content === "string" ? assistant.content + text : text;
+            }
+            return;
+        }
+        if (!parts.length)
+            return;
+        // Codex sends its base instructions and permission updates as `developer`
+        // messages. Chat upstreams other than OpenAI only know `system`.
+        const role = item.role === "developer" || item.role === "system" ? "system" : "user";
+        this.push({ role, content: role === "system" ? textOnly(parts) : collapse(parts) });
+    }
+    reasoning(item) {
+        const payload = decodeReasoningPayload(item.encrypted_content);
+        // Foreign blobs (issued by the real Responses API) cannot be replayed here.
+        if (payload === null)
+            return;
+        this.flushAssistant();
+        this.pendingReasoning.push(payload);
+    }
+    addToolCall(callId, chatName, args) {
+        const assistant = this.currentAssistant();
+        const calls = (assistant.tool_calls ??= []);
+        calls.push({
+            id: typeof callId === "string" && callId ? callId : `call_${crypto.randomUUID()}`,
+            type: "function",
+            function: { name: chatName, arguments: args },
+        });
+    }
+    toolCall(item, custom) {
+        const name = typeof item.name === "string" ? item.name : "";
+        if (!name) {
+            this.notes.skippedItems.push(String(item.type));
+            return;
+        }
+        const args = custom
+            ? JSON.stringify({ input: typeof item.input === "string" ? item.input : "" })
+            : typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {});
+        this.addToolCall(item.call_id, chatToolName(name, item.namespace), args);
+    }
+    /** Client-executed tool_search: `arguments` is an object on this item. */
+    toolSearchCall(item) {
+        if (item.execution !== undefined && item.execution !== "client") {
+            this.notes.skippedItems.push("tool_search_call:server");
+            return;
+        }
+        const args = typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {});
+        this.addToolCall(item.call_id, TOOL_SEARCH_NAME, args);
+    }
+    toolOutput(item, text) {
+        this.flushAssistant();
+        this.messages.push({
+            role: "tool",
+            tool_call_id: typeof item.call_id === "string" ? item.call_id : "unknown",
+            content: text ?? toolOutputText(item.output, this.pendingImages),
+        });
+    }
+    finish() {
+        this.flushAssistant();
+        this.flushImages();
+        return pairToolMessages(this.messages);
+    }
+}
+const MISSING_TOOL_OUTPUT = "No output was recorded for this tool call.";
+/**
+ * Chat upstreams reject a tool message without a matching assistant tool call
+ * and an assistant tool call without its tool message. Either happens when one
+ * side of a pair was a skipped item kind, or the client dropped an output: the
+ * orphan output becomes user text, the orphan call gets a placeholder output.
+ */
+function pairToolMessages(messages) {
+    const out = [];
+    let pending = [];
+    const closePending = () => {
+        for (const id of pending)
+            out.push({ role: "tool", tool_call_id: id, content: MISSING_TOOL_OUTPUT });
+        pending = [];
+    };
+    for (const message of messages) {
+        if (message.role === "tool") {
+            const id = String(message.tool_call_id);
+            const at = pending.indexOf(id);
+            if (at >= 0) {
+                pending.splice(at, 1);
+                out.push(message);
+            }
+            else {
+                out.push({ role: "user", content: `Output of tool call ${id}:\n${String(message.content ?? "")}` });
+            }
+            continue;
+        }
+        closePending();
+        out.push(message);
+        if (message.role === "assistant" && Array.isArray(message.tool_calls)) {
+            pending = message.tool_calls.map((call) => String(asRecord(call)?.id ?? ""));
+        }
+    }
+    closePending();
+    return out;
+}
+/**
+ * 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 function responsesRequestToChat(body, reasoningFields) {
+    const notes = { skippedItems: [], skippedTools: [], customTools: [], namespaces: [], aliases: {}, toolSearch: false };
+    const builder = new MessageBuilder(notes);
+    if (typeof body.instructions === "string")
+        builder.system(body.instructions);
+    const extraTools = [];
+    const input = typeof body.input === "string" ? [{ type: "message", role: "user", content: body.input }] : body.input;
+    for (const entry of Array.isArray(input) ? input : []) {
+        const item = asRecord(entry);
+        if (!item)
+            continue;
+        const type = item.type ?? (typeof item.role === "string" ? "message" : undefined);
+        if (type === "message")
+            builder.message(item);
+        else if (type === "reasoning")
+            builder.reasoning(item);
+        else if (type === "function_call")
+            builder.toolCall(item, false);
+        else if (type === "custom_tool_call")
+            builder.toolCall(item, true);
+        else if (type === "function_call_output" || type === "custom_tool_call_output")
+            builder.toolOutput(item);
+        else if (type === "tool_search_call")
+            builder.toolSearchCall(item);
+        else if (type === "tool_search_output") {
+            if (Array.isArray(item.tools))
+                extraTools.push(...item.tools);
+            const names = discoveredToolNames(item.tools);
+            builder.toolOutput(item, names.length ? `Tools now available: ${names.join(", ")}` : "No matching tools found.");
+        }
+        else if (type === "additional_tools" && Array.isArray(item.tools))
+            extraTools.push(...item.tools);
+        else
+            notes.skippedItems.push(String(type ?? "unknown"));
+    }
+    const model = body.model;
+    const converted = { model, messages: builder.finish(), stream: body.stream === true };
+    if (typeof body.max_output_tokens === "number")
+        converted.max_tokens = body.max_output_tokens;
+    for (const field of ["temperature", "top_p"]) {
+        if (typeof body[field] === "number")
+            converted[field] = body[field];
+    }
+    if (typeof body.prompt_cache_key === "string" && body.prompt_cache_key)
+        converted.prompt_cache_key = body.prompt_cache_key;
+    Object.assign(converted, reasoningFields(String(model ?? ""), responsesThinkingLevel(body)));
+    const format = responseFormat(body.text);
+    if (format)
+        converted.response_format = format;
+    const tools = [];
+    convertTools(body.tools, notes, tools);
+    convertTools(extraTools, notes, tools);
+    if (tools.length) {
+        converted.tools = tools;
+        const toolChoice = convertToolChoice(body.tool_choice);
+        if (toolChoice !== undefined)
+            converted.tool_choice = toolChoice;
+        if (body.parallel_tool_calls === false)
+            converted.parallel_tool_calls = false;
+    }
+    return { body: converted, notes };
+}
+// ---- response: Chat Completions → Responses ----
+function responsesUsage(value) {
+    const usage = asRecord(value) ?? {};
+    // Some OpenAI-compatible upstreams put Responses-shaped usage on Chat chunks; accept both.
+    const input = Number(usage.prompt_tokens ?? usage.input_tokens ?? 0) || 0;
+    const output = Number(usage.completion_tokens ?? usage.output_tokens ?? 0) || 0;
+    const inputDetails = asRecord(usage.prompt_tokens_details) ?? asRecord(usage.input_tokens_details);
+    const outputDetails = asRecord(usage.completion_tokens_details) ?? asRecord(usage.output_tokens_details);
+    const cached = Number(inputDetails?.cached_tokens ?? usage.prompt_cache_hit_tokens ?? 0) || 0;
+    const reasoning = Number(outputDetails?.reasoning_tokens ?? 0) || 0;
+    return {
+        input_tokens: input,
+        input_tokens_details: { cached_tokens: cached },
+        output_tokens: output,
+        output_tokens_details: { reasoning_tokens: reasoning },
+        total_tokens: input + output,
+    };
+}
+function responseId(raw) {
+    const suffix = typeof raw === "string" && /^[A-Za-z0-9_-]{6,80}$/.test(raw) ? raw.replace(/^(chatcmpl-|resp_)/, "") : crypto.randomUUID().replaceAll("-", "");
+    return `resp_${suffix}`;
+}
+function itemId(prefix) {
+    return `${prefix}_${crypto.randomUUID().replaceAll("-", "")}`;
+}
+/**
+ * Splits a flattened `<namespace>__<name>` back unless it is a plain tool name.
+ * Namespaces may contain the separator themselves (MCP servers are exposed as
+ * `mcp__<server>`), so the longest known namespace prefix wins.
+ */
+function splitToolName(chatName, namespaces) {
+    let best = "";
+    for (const namespace of namespaces) {
+        if (namespace.length > best.length && chatName.length > namespace.length + NAMESPACE_SEPARATOR.length
+            && chatName.startsWith(namespace + NAMESPACE_SEPARATOR))
+            best = namespace;
+    }
+    return best ? { namespace: best, name: chatName.slice(best.length + NAMESPACE_SEPARATOR.length) } : { name: chatName };
+}
+export function responsesContext(body, notes) {
+    const namespaces = new Set(notes.namespaces);
+    for (const item of Array.isArray(body.tools) ? body.tools : []) {
+        const tool = asRecord(item);
+        if (tool?.type === "namespace" && typeof tool.name === "string")
+            namespaces.add(tool.name);
+    }
+    const conversation = typeof body.conversation === "string" ? body.conversation : asRecord(body.conversation)?.id;
+    return {
+        model: typeof body.model === "string" ? body.model : "",
+        previousResponseId: typeof body.previous_response_id === "string" && body.previous_response_id ? body.previous_response_id : null,
+        conversation: typeof conversation === "string" && conversation ? conversation : null,
+        customTools: notes.customTools,
+        namespaces: [...namespaces],
+        aliases: notes.aliases,
+        toolSearch: notes.toolSearch,
+        stream: body.stream === true,
+    };
+}
+function parseJsonObject(text) {
+    try {
+        return asRecord(JSON.parse(text));
+    }
+    catch {
+        return null;
+    }
+}
+function isToolSearch(chatName, ctx) {
+    return ctx.toolSearch === true && chatName === TOOL_SEARCH_NAME;
+}
+/** Calls whose arguments Codex reads from the final item only (no per-chunk deltas). */
+function wholeArgumentsOnly(chatName, ctx) {
+    return ctx.customTools.includes(chatName) || isToolSearch(chatName, ctx);
+}
+function toolCallItem(id, callId, chatName, args, ctx, status) {
+    if (isToolSearch(chatName, ctx)) {
+        // Codex 0.167 parses `arguments` as an object here; a JSON string is
+        // silently treated as an empty search.
+        return { type: "tool_search_call", id, status, call_id: callId, execution: "client", arguments: parseJsonObject(args) ?? {} };
+    }
+    const { name, namespace } = ctx.aliases?.[chatName] ?? splitToolName(chatName, ctx.namespaces);
+    if (ctx.customTools.includes(chatName)) {
+        const parsed = parseJsonObject(args);
+        // Unparseable arguments are handed over raw; the tool reports the error.
+        const input = typeof parsed?.input === "string" ? parsed.input : args;
+        return { type: "custom_tool_call", id, status, call_id: callId, name, input, ...(namespace ? { namespace } : {}) };
+    }
+    return { type: "function_call", id, status, call_id: callId, name, arguments: args, ...(namespace ? { namespace } : {}) };
+}
+function reasoningItem(id, text, details) {
+    return {
+        type: "reasoning",
+        id,
+        summary: text ? [{ type: "summary_text", text }] : [],
+        encrypted_content: encodeReasoningBlob(text, details),
+    };
+}
+function messageItem(id, text, status) {
+    return {
+        type: "message",
+        id,
+        status,
+        role: "assistant",
+        content: [{ type: "output_text", text, annotations: [] }],
+    };
+}
+function responseObject(id, ctx, status, output, usage, extra = {}) {
+    return {
+        id,
+        object: "response",
+        created_at: Math.floor(Date.now() / 1000),
+        status,
+        model: ctx.model,
+        output,
+        parallel_tool_calls: true,
+        store: false,
+        usage,
+        ...extra,
+    };
+}
+function incompleteDetails(finishReason) {
+    if (finishReason === "length")
+        return { reason: "max_output_tokens" };
+    if (finishReason === "content_filter")
+        return { reason: "content_filter" };
+    return null;
+}
+export function openAICompletionToResponses(value, ctx) {
+    const completion = asRecord(value) ?? {};
+    const choice = asRecord(Array.isArray(completion.choices) ? completion.choices[0] : null) ?? {};
+    const message = asRecord(choice.message) ?? {};
+    const output = [];
+    const reasoning = message.reasoning_content ?? message.reasoning;
+    const reasoningText = typeof reasoning === "string" ? reasoning : "";
+    const details = [];
+    mergeReasoningDetails(details, message.reasoning_details);
+    if (reasoningText || details.length)
+        output.push(reasoningItem(itemId("rs"), reasoningText, details));
+    if (typeof message.content === "string" && message.content)
+        output.push(messageItem(itemId("msg"), message.content, "completed"));
+    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;
+        output.push(toolCallItem(itemId("fc"), typeof call?.id === "string" ? call.id : `call_${crypto.randomUUID()}`, fn.name, typeof fn.arguments === "string" ? fn.arguments : "", ctx, "completed"));
+    }
+    const incomplete = incompleteDetails(choice.finish_reason);
+    return responseObject(responseId(completion.id), ctx, incomplete ? "incomplete" : "completed", output, responsesUsage(completion.usage), {
+        incomplete_details: incomplete,
+    });
+}
+/** OpenAI chat.completion.chunk SSE → Responses SSE event sequence. */
+export function openAISseToResponses(ctx) {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    const parser = new SseParser();
+    let id = responseId(null);
+    let started = false;
+    let finished = false;
+    let sequence = 0;
+    let finishReason = null;
+    let usage = null;
+    const items = [];
+    const tools = new Map();
+    let reasoning = null;
+    let message = null;
+    const emit = (controller, type, data) => {
+        controller.enqueue(encoder.encode(`event: ${type}\ndata: ${JSON.stringify({ type, sequence_number: sequence++, ...data })}\n\n`));
+    };
+    const finalItem = (item) => {
+        if (item.kind === "reasoning")
+            return reasoningItem(item.id, item.text, item.details);
+        if (item.kind === "message")
+            return messageItem(item.id, item.text, "completed");
+        return toolCallItem(item.id, item.callId, item.name, item.text, ctx, "completed");
+    };
+    const start = (controller, rawId) => {
+        if (started)
+            return;
+        started = true;
+        id = responseId(rawId);
+        const response = responseObject(id, ctx, "in_progress", [], null);
+        emit(controller, "response.created", { response });
+        emit(controller, "response.in_progress", { response });
+    };
+    const open = (controller, item, added) => {
+        items.push(item);
+        emit(controller, "response.output_item.added", { output_index: item.outputIndex, item: added });
+    };
+    const close = (controller, item) => {
+        if (!item || item.done)
+            return;
+        item.done = true;
+        const base = { item_id: item.id, output_index: item.outputIndex };
+        if (item.kind === "reasoning" && item.summaryOpen) {
+            emit(controller, "response.reasoning_summary_text.done", { ...base, summary_index: 0, text: item.text });
+            emit(controller, "response.reasoning_summary_part.done", { ...base, summary_index: 0, part: { type: "summary_text", text: item.text } });
+        }
+        else if (item.kind === "message") {
+            emit(controller, "response.output_text.done", { ...base, content_index: 0, text: item.text });
+            emit(controller, "response.content_part.done", { ...base, content_index: 0, part: { type: "output_text", text: item.text, annotations: [] } });
+        }
+        else if (item.kind === "tool") {
+            if (isToolSearch(item.name, ctx)) {
+                // tool_search_call has no argument events; the final item carries them.
+            }
+            else if (ctx.customTools.includes(item.name)) {
+                const final = finalItem(item);
+                emit(controller, "response.custom_tool_call_input.done", { ...base, input: final.input });
+            }
+            else {
+                emit(controller, "response.function_call_arguments.done", { ...base, arguments: item.text });
+            }
+        }
+        emit(controller, "response.output_item.done", { output_index: item.outputIndex, item: finalItem(item) });
+    };
+    const closeAll = (controller) => {
+        for (const item of items)
+            close(controller, item);
+    };
+    const openReasoning = (controller) => {
+        if (!reasoning || reasoning.done) {
+            reasoning = { kind: "reasoning", outputIndex: items.length, id: itemId("rs"), text: "", details: [], done: false };
+            open(controller, reasoning, { type: "reasoning", id: reasoning.id, summary: [] });
+        }
+        return reasoning;
+    };
+    // Streamed as one reasoning summary part; Codex 0.167 renders
+    // reasoning_summary_text.delta live and ignores the *.done events.
+    const onReasoning = (controller, text) => {
+        const item = openReasoning(controller);
+        const base = { item_id: item.id, output_index: item.outputIndex, summary_index: 0 };
+        if (!item.summaryOpen) {
+            item.summaryOpen = true;
+            emit(controller, "response.reasoning_summary_part.added", { ...base, part: { type: "summary_text", text: "" } });
+        }
+        item.text += text;
+        emit(controller, "response.reasoning_summary_text.delta", { ...base, delta: text });
+    };
+    // Signed/encrypted reasoning (`reasoning_details`) is not shown,
+    // only carried in the item's encrypted_content for replay.
+    const onReasoningDetails = (controller, details) => {
+        mergeReasoningDetails(openReasoning(controller).details, details);
+    };
+    const onText = (controller, text) => {
+        close(controller, reasoning);
+        if (!message || message.done) {
+            message = { kind: "message", outputIndex: items.length, id: itemId("msg"), text: "", done: false };
+            open(controller, message, { type: "message", id: message.id, status: "in_progress", role: "assistant", content: [] });
+            emit(controller, "response.content_part.added", {
+                item_id: message.id,
+                output_index: message.outputIndex,
+                content_index: 0,
+                part: { type: "output_text", text: "", annotations: [] },
+            });
+        }
+        message.text += text;
+        emit(controller, "response.output_text.delta", {
+            item_id: message.id,
+            output_index: message.outputIndex,
+            content_index: 0,
+            delta: text,
+        });
+    };
+    const onToolCalls = (controller, calls) => {
+        close(controller, reasoning);
+        close(controller, message);
+        for (const entry of calls) {
+            const call = asRecord(entry);
+            if (!call)
+                continue;
+            const fn = asRecord(call.function) ?? {};
+            const index = Number(call.index ?? 0);
+            let item = tools.get(index);
+            if (!item) {
+                item = {
+                    kind: "tool",
+                    outputIndex: items.length,
+                    id: itemId("fc"),
+                    text: "",
+                    callId: typeof call.id === "string" ? call.id : `call_${crypto.randomUUID()}`,
+                    name: typeof fn.name === "string" ? fn.name : "",
+                    done: false,
+                };
+                tools.set(index, item);
+                open(controller, item, toolCallItem(item.id, item.callId, item.name, "", ctx, "in_progress"));
+            }
+            if (typeof fn.arguments === "string" && fn.arguments) {
+                item.text += fn.arguments;
+                // Custom tool input is only known once the JSON wrapper is complete and
+                // tool_search arguments are an object; Codex reads the final item, so
+                // both skip the per-chunk deltas.
+                if (!wholeArgumentsOnly(item.name, ctx)) {
+                    emit(controller, "response.function_call_arguments.delta", {
+                        item_id: item.id,
+                        output_index: item.outputIndex,
+                        delta: fn.arguments,
+                    });
+                }
+            }
+        }
+    };
+    const finish = (controller) => {
+        if (finished)
+            return;
+        start(controller, null);
+        closeAll(controller);
+        finished = true;
+        const incomplete = incompleteDetails(finishReason);
+        const response = responseObject(id, ctx, incomplete ? "incomplete" : "completed", items.map(finalItem), usage ?? responsesUsage(null), {
+            incomplete_details: incomplete,
+        });
+        emit(controller, incomplete ? "response.incomplete" : "response.completed", { response });
+    };
+    const fail = (controller, errorMessage, code) => {
+        if (finished)
+            return;
+        start(controller, null);
+        finished = true;
+        emit(controller, "response.failed", {
+            response: responseObject(id, ctx, "failed", items.filter((item) => item.done).map(finalItem), usage, {
+                error: { code, message: errorMessage },
+            }),
+        });
+    };
+    const consume = (event, controller) => {
+        if (finished)
+            return;
+        const data = event.data.trim();
+        if (!data) {
+            // Keepalive comment frames: SSE clients ignore comments, forward as-is.
+            controller.enqueue(encoder.encode(": keepalive\n\n"));
+            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) {
+            // Frames sent after the keepalive headers carry the status they replaced;
+            // post-output stream failures carry a numeric code (502/504) instead.
+            const status = typeof error.upstream_status === "number" ? error.upstream_status : typeof error.code === "number" ? error.code : 502;
+            fail(controller, typeof error.message === "string" ? error.message : "upstream stream error", responsesStreamErrorCode(status, error.code));
+            return;
+        }
+        start(controller, chunk.id);
+        if (asRecord(chunk.usage))
+            usage = responsesUsage(chunk.usage);
+        const choice = asRecord(Array.isArray(chunk.choices) ? chunk.choices[0] : null);
+        if (!choice)
+            return;
+        const d = asRecord(choice.delta) ?? {};
+        const reasoningText = d.reasoning_content ?? d.reasoning;
+        if (typeof reasoningText === "string" && reasoningText)
+            onReasoning(controller, reasoningText);
+        if (Array.isArray(d.reasoning_details) && d.reasoning_details.length)
+            onReasoningDetails(controller, d.reasoning_details);
+        if (typeof d.content === "string" && d.content)
+            onText(controller, d.content);
+        if (Array.isArray(d.tool_calls))
+            onToolCalls(controller, d.tool_calls);
+        if (typeof choice.finish_reason === "string")
+            finishReason = choice.finish_reason;
+    };
+    return new TransformStream({
+        transform(bytes, controller) {
+            try {
+                for (const event of parser.push(decoder.decode(bytes, { stream: true })))
+                    consume(event, controller);
+            }
+            catch (error) {
+                fail(controller, error instanceof Error ? error.message : "stream conversion failed", "server_error");
+            }
+        },
+        flush(controller) {
+            try {
+                for (const event of parser.finish(decoder.decode()))
+                    consume(event, controller);
+            }
+            catch (error) {
+                fail(controller, error instanceof Error ? error.message : "stream conversion failed", "server_error");
+            }
+            // A stream that ended without [DONE] was cut off upstream.
+            if (!finished) {
+                if (started)
+                    fail(controller, "stream ended unexpectedly", "server_error");
+                else
+                    finish(controller);
+            }
+        },
+    });
+}
+/** Gateway codes that are final whatever their HTTP status (429 quota, 403 review, 503 model). */
+const FINAL_ERROR_CODES = new Set([
+    "quota_exceeded",
+    "insufficient_quota",
+    "client_integrity_review",
+    "u1s1_client_only",
+    "model_not_found",
+    "model_unavailable",
+    "request_body_too_large",
+]);
+/** HTTP 400 codes whose `message` Codex shows as is (any other code prints the raw body). */
+const CODEX_MESSAGE_400_CODES = new Set(["invalid_prompt", "model_not_found"]);
+export function classifyError(status, code) {
+    if (code === "context_length_exceeded")
+        return "context";
+    if (typeof code === "string" && FINAL_ERROR_CODES.has(code))
+        return "final";
+    if (status === 408 || status === 409 || status === 429 || status >= 500)
+        return "retry";
+    return status >= 400 ? "final" : "retry";
+}
+/** `response.failed` error code for a gateway error frame. */
+export function responsesStreamErrorCode(status, code) {
+    const kind = classifyError(status, code);
+    if (kind === "context")
+        return "context_length_exceeded";
+    if (kind === "final")
+        return "invalid_prompt";
+    return status === 429 ? "rate_limit_exceeded" : "server_error";
+}
+/** SSE body with just `response.created` + `response.failed`, for errors Codex only understands in-stream. */
+export function failedStream(ctx, code, message, headers) {
+    const encoder = new TextEncoder();
+    const id = responseId(null);
+    let sequence = 0;
+    const frame = (type, data) => `event: ${type}\ndata: ${JSON.stringify({ type, sequence_number: sequence++, ...data })}\n\n`;
+    const body = frame("response.created", { response: responseObject(id, ctx, "in_progress", [], null) })
+        + frame("response.failed", { response: responseObject(id, ctx, "failed", [], null, { error: { code, message } }) });
+    headers.set("content-type", "text/event-stream");
+    headers.set("cache-control", "no-cache");
+    return new Response(encoder.encode(body), { status: 200, headers });
+}
+/**
+ * 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 function responsesFinalError(error, status, message, headers = new Headers()) {
+    const gatewayCode = error?.code;
+    const code = typeof gatewayCode === "string" && CODEX_MESSAGE_400_CODES.has(gatewayCode) ? gatewayCode : "invalid_prompt";
+    // OpenAI SDKs honour x-should-retry; Codex keys off the 400 status.
+    headers.set("x-should-retry", "false");
+    headers.set("content-type", "application/json");
+    headers.delete("content-length");
+    return new Response(JSON.stringify({
+        error: {
+            message,
+            type: typeof error?.type === "string" && error.type ? error.type : "invalid_request_error",
+            code,
+            param: typeof error?.param === "string" ? error.param : null,
+            ...(gatewayCode !== undefined && gatewayCode !== null && gatewayCode !== code ? { u1s1_code: gatewayCode } : {}),
+            ...(status !== 400 ? { u1s1_status: status } : {}),
+            ...(typeof error?.request_id === "string" ? { request_id: error.request_id } : {}),
+        },
+    }), { status: 400, headers });
+}
+async function errorToResponses(response, ctx) {
+    const text = await response.text();
+    let error = null;
+    try {
+        error = asRecord(asRecord(JSON.parse(text))?.error);
+    }
+    catch {
+        // Non-JSON error bodies keep their raw text as the message.
+    }
+    const message = typeof error?.message === "string" ? error.message : text.slice(0, 2_000) || response.statusText || "request failed";
+    const headers = new Headers();
+    for (const name of ["x-request-id", "retry-after"]) {
+        const value = response.headers.get(name);
+        if (value)
+            headers.set(name, value);
+    }
+    const gatewayCode = error?.code;
+    const kind = classifyError(response.status, gatewayCode);
+    // Context overflow: in-stream `context_length_exceeded` is the shape Codex
+    // maps to its context-window handling; over HTTP 400 it would print raw JSON.
+    if (kind === "context" && ctx.stream)
+        return failedStream(ctx, "context_length_exceeded", message, headers);
+    if (kind === "final")
+        return responsesFinalError(error, response.status, message, headers);
+    // Upstream 5xx with every channel already tried (see the table above): in-stream
+    // server_error, so Codex retries 6 times instead of 30.
+    if (ctx.stream && response.status >= 500 && gatewayCode === "upstream_error") {
+        return failedStream(ctx, "server_error", message, headers);
+    }
+    const requestId = typeof error?.request_id === "string" ? { request_id: error.request_id } : {};
+    headers.set("content-type", "application/json");
+    const code = kind === "context" ? "context_length_exceeded" : response.status === 429 ? "rate_limit_exceeded" : "server_error";
+    return new Response(JSON.stringify({
+        error: {
+            message,
+            type: typeof error?.type === "string" && error.type ? error.type : "api_error",
+            code: kind === "context" ? code : typeof gatewayCode === "string" && gatewayCode ? gatewayCode : code,
+            param: typeof error?.param === "string" ? error.param : null,
+            ...requestId,
+        },
+    }), { status: kind === "context" ? 400 : response.status, headers });
+}
+/** Convert the Chat Completions handler's response into a Responses API response. */
+export async function openAIResponseToResponses(response, ctx) {
+    if (!response.ok)
+        return errorToResponses(response, ctx);
+    const headers = new Headers();
+    const requestId = response.headers.get("x-request-id");
+    if (requestId)
+        headers.set("x-request-id", requestId);
+    const isStream = (response.headers.get("content-type") ?? "").includes("text/event-stream");
+    if (isStream) {
+        if (!response.body)
+            return errorToResponses(new Response("missing stream body", { status: 502 }), ctx);
+        headers.set("content-type", "text/event-stream");
+        headers.set("cache-control", "no-cache");
+        return new Response(response.body.pipeThrough(openAISseToResponses(ctx)), { status: response.status, headers });
+    }
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return errorToResponses(new Response("malformed completion body", { status: 502 }), ctx);
+    }
+    headers.set("content-type", "application/json");
+    return new Response(JSON.stringify(openAICompletionToResponses(payload, ctx)), { status: response.status, headers });
+}