@dbx-tools/shared-model 0.3.44 → 0.4.0

package/lib/src/openai-responses.js

@@ -0,0 +1,686 @@
+/**
+ * OpenAI Responses API <-> Chat Completions translation.
+ *
+ * Some clients speak only the Responses API (`POST /v1/responses`) - the Codex
+ * CLI is the motivating one. Databricks now also exposes native Responses
+ * surfaces (`/serving-endpoints/responses` and `/serving-endpoints/open-responses`),
+ * while most endpoints still speak Chat Completions at `/invocations`. This
+ * module bridges the two, in both directions:
+ *
+ *   - {@link responsesToChat} lowers a Responses request body to a chat
+ *     completions body (instructions -> system message, typed `input` items ->
+ *     `messages`, `tools`/`tool_choice` carried through, function-call outputs
+ *     folded back into the transcript).
+ *   - {@link chatToResponsesRequest} raises a chat-completions request into a
+ *     Responses request (the inverse of {@link responsesToChat}), for routing a
+ *     chat client at a Responses-only model like Codex.
+ *   - {@link chatToResponse} lifts a non-streaming chat completion back into a
+ *     Responses `response` object.
+ *   - {@link responseToChatCompletion} lifts a native Responses `response`
+ *     back into a chat-completions body (the inverse of {@link chatToResponse}).
+ *   - {@link createResponsesStreamTranslator} lifts a streaming chat completion
+ *     (an OpenAI SSE `chat.completion.chunk` stream) into the Responses SSE
+ *     event stream those clients consume (`response.created`,
+ *     `response.output_text.delta`, function-call argument deltas,
+ *     `response.completed`).
+ *   - {@link readResponsesOutput} reads the other direction: pull the answer
+ *     text and citations out of a `response` object returned by an endpoint
+ *     that speaks Responses natively (the Databricks native web-search tool).
+ *   - {@link sanitizeResponsesTools} keeps only `function` tools on a Responses
+ *     request body (for `/open-responses` / Anthropic, which reject Codex
+ *     built-ins like `web_search`).
+ *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types
+ *     in `input` to `input_*`, and drops Claude thinking / reasoning blocks
+ *     that Open Responses rejects on replay (`redacted_thinking`, …).
+ *
+ * Only the surface real clients exercise is translated; unknown fields are
+ * ignored rather than rejected, so a newer client degrades instead of breaking.
+ *
+ * Browser-safe: pure functions over plain JSON, no transport and no Node
+ * built-ins, so the same translation runs in a proxy, a server route, or a test.
+ *
+ * @module
+ */
+import { string } from "@dbx-tools/shared-core";
+import { chatContentToText } from "./openai-chat.js";
+/**
+ * Lower a Responses request body to a chat-completions body. Returns the chat
+ * body plus whether the caller asked for streaming (the server needs it to pick
+ * the upstream `accept` header and the translation path).
+ */
+export function responsesToChat(body) {
+    const messages = [];
+    // `instructions` becomes the leading system message.
+    if (typeof body.instructions === "string" && body.instructions.length > 0) {
+        messages.push({ role: "system", content: body.instructions });
+    }
+    // `input` is an array of typed items: messages, function_call, and
+    // function_call_output. Fold each into the chat transcript.
+    const input = Array.isArray(body.input) ? body.input : [];
+    for (const raw of input) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const item = raw;
+        const type = item.type;
+        if (type === "function_call") {
+            // A prior tool call the model made; re-attach it to an assistant turn.
+            messages.push({
+                role: "assistant",
+                content: null,
+                tool_calls: [toChatToolCall(item)],
+            });
+            continue;
+        }
+        if (type === "function_call_output") {
+            // The tool's result, keyed back to the call it answers.
+            messages.push({
+                role: "tool",
+                tool_call_id: String(item.call_id ?? item.id ?? ""),
+                content: typeof item.output === "string" ? item.output : chatContentToText(item.output),
+            });
+            continue;
+        }
+        // Default: a message item with a role and typed content.
+        const role = typeof item.role === "string" ? item.role : "user";
+        // Chat has no "developer" role; treat it as system (its intent here).
+        const chatRole = role === "developer" ? "system" : role;
+        messages.push({ role: chatRole, content: chatContentToText(item.content) });
+    }
+    const chat = {
+        model: body.model,
+        messages,
+        stream: body.stream === true,
+    };
+    // Carry through function-calling config when present. Responses function
+    // tools are FLAT (`{type:"function", name, description, parameters}`); chat
+    // wants them NESTED (`{type:"function", function:{name, …}}`). Clients also
+    // send built-in tool types (local_shell, web_search, …) that Databricks chat
+    // rejects ("Missing 'function' in the tool specification"), so we translate
+    // only function tools and drop the rest.
+    if (Array.isArray(body.tools) && body.tools.length > 0) {
+        const chatTools = body.tools
+            .map(toChatTool)
+            .filter((t) => t !== undefined);
+        if (chatTools.length > 0) {
+            chat.tools = chatTools;
+            if (body.tool_choice !== undefined)
+                chat.tool_choice = body.tool_choice;
+            // NOTE: do NOT forward `parallel_tool_calls`. Clients send it, but
+            // Databricks Model Serving's chat API rejects unknown fields
+            // ("parallel_tool_calls: Extra inputs are not permitted"), which would
+            // fail the whole turn. Drop it.
+        }
+    }
+    return { chat, stream: body.stream === true };
+}
+/**
+ * Raise a chat-completions request into a Responses request body. Inverse of
+ * {@link responsesToChat}: used when a chat client hits a Responses-only
+ * Databricks model (e.g. Codex) so the proxy can POST to
+ * `/serving-endpoints/responses` without the client knowing.
+ */
+export function chatToResponsesRequest(body) {
+    const messages = Array.isArray(body.messages) ? body.messages : [];
+    const input = [];
+    let instructions;
+    for (const raw of messages) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const message = raw;
+        const role = typeof message.role === "string" ? message.role : "user";
+        // Leading system / developer messages become top-level `instructions`.
+        if ((role === "system" || role === "developer") &&
+            instructions === undefined &&
+            input.length === 0) {
+            const text = chatContentToText(message.content);
+            if (text)
+                instructions = text;
+            continue;
+        }
+        if (role === "tool") {
+            input.push({
+                type: "function_call_output",
+                call_id: String(message.tool_call_id ?? ""),
+                output: chatContentToText(message.content),
+            });
+            continue;
+        }
+        if (role === "assistant" &&
+            Array.isArray(message.tool_calls) &&
+            message.tool_calls.length > 0) {
+            for (const rawCall of message.tool_calls) {
+                if (!rawCall || typeof rawCall !== "object")
+                    continue;
+                input.push(toFunctionCallItem(rawCall));
+            }
+            const text = chatContentToText(message.content);
+            if (text) {
+                input.push({ type: "message", role: "assistant", content: text });
+            }
+            continue;
+        }
+        input.push({
+            type: "message",
+            role,
+            content: chatContentToText(message.content),
+        });
+    }
+    const responses = {
+        model: body.model,
+        input,
+        stream: body.stream === true,
+    };
+    if (instructions)
+        responses.instructions = instructions;
+    // Chat tools are nested (`function: { name, … }`); Responses wants them flat.
+    if (Array.isArray(body.tools) && body.tools.length > 0) {
+        const tools = body.tools
+            .map(toResponsesTool)
+            .filter((t) => t !== undefined);
+        if (tools.length > 0) {
+            responses.tools = tools;
+            if (body.tool_choice !== undefined)
+                responses.tool_choice = body.tool_choice;
+        }
+    }
+    // Prefer Responses' max_output_tokens naming; fall back from chat max_tokens.
+    if (typeof body.max_output_tokens === "number") {
+        responses.max_output_tokens = body.max_output_tokens;
+    }
+    else if (typeof body.max_tokens === "number") {
+        responses.max_output_tokens = body.max_tokens;
+    }
+    return { responses, stream: body.stream === true };
+}
+/** Lift a non-streaming chat completion JSON into a Responses `response` object. */
+export function chatToResponse(chat, model) {
+    const choices = Array.isArray(chat.choices) ? chat.choices : [];
+    const first = (choices[0] ?? {});
+    const message = (first.message ?? {});
+    const output = [];
+    const text = typeof message.content === "string" ? message.content : "";
+    if (text) {
+        output.push({
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text }],
+        });
+    }
+    // Surface any tool calls as Responses `function_call` output items.
+    const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    for (const raw of toolCalls) {
+        output.push(toFunctionCallItem(raw));
+    }
+    const usage = (chat.usage ?? {});
+    return {
+        id: String(chat.id ?? "resp"),
+        object: "response",
+        created_at: typeof chat.created === "number" ? chat.created : 0,
+        model,
+        status: "completed",
+        output,
+        usage: {
+            input_tokens: Number(usage.prompt_tokens ?? 0),
+            output_tokens: Number(usage.completion_tokens ?? 0),
+            total_tokens: Number(usage.total_tokens ?? 0),
+        },
+    };
+}
+/**
+ * Lift a native Responses `response` object into a chat-completions body.
+ * Inverse of {@link chatToResponse}: used after a Responses-only upstream call
+ * when the client spoke Chat Completions.
+ */
+export function responseToChatCompletion(response, model) {
+    const { text } = readResponsesOutput(response);
+    const toolCalls = [];
+    const output = Array.isArray(response.output) ? response.output : [];
+    for (const raw of output) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const item = raw;
+        if (item.type !== "function_call")
+            continue;
+        toolCalls.push(toChatToolCall(item));
+    }
+    const message = {
+        role: "assistant",
+        content: text || null,
+    };
+    if (toolCalls.length > 0)
+        message.tool_calls = toolCalls;
+    const usage = (response.usage ?? {});
+    return {
+        id: String(response.id ?? "chatcmpl"),
+        object: "chat.completion",
+        created: typeof response.created_at === "number" ? response.created_at : 0,
+        model,
+        choices: [
+            {
+                index: 0,
+                message,
+                finish_reason: toolCalls.length > 0 ? "tool_calls" : "stop",
+            },
+        ],
+        usage: {
+            prompt_tokens: Number(usage.input_tokens ?? 0),
+            completion_tokens: Number(usage.output_tokens ?? 0),
+            total_tokens: Number(usage.total_tokens ?? 0),
+        },
+    };
+}
+/**
+ * A tool call's `arguments` JSON. Both wires carry it as an unparsed string;
+ * anything else (absent, an already-parsed object) becomes an empty literal so
+ * the receiving side always has valid JSON to parse.
+ */
+function callArguments(value) {
+    return typeof value === "string" ? value : "{}";
+}
+/**
+ * The Responses `function_call` item for a tool call in either spelling: a chat
+ * `tool_calls[]` entry (`{id, function:{name, arguments}}`) or an item that is
+ * already flat.
+ */
+function toFunctionCallItem(call) {
+    const fn = (call.function ?? call);
+    return {
+        type: "function_call",
+        call_id: String(call.call_id ?? call.id ?? ""),
+        name: String(fn.name ?? ""),
+        arguments: callArguments(fn.arguments),
+    };
+}
+/** The chat `tool_calls[]` entry for a Responses `function_call` item. */
+function toChatToolCall(item) {
+    return {
+        id: String(item.call_id ?? item.id ?? ""),
+        type: "function",
+        function: {
+            name: String(item.name ?? ""),
+            arguments: callArguments(item.arguments),
+        },
+    };
+}
+/**
+ * The chat-nested spelling (`{type:"function", function:{name, …}}`) of a tool
+ * spec, or `undefined` for a built-in Responses tool (`web_search`,
+ * `local_shell`, …) that chat cannot express and Databricks rejects.
+ */
+function toChatTool(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const tool = value;
+    if (tool.type !== "function")
+        return undefined;
+    if (tool.function && typeof tool.function === "object")
+        return tool; // already nested
+    if (typeof tool.name !== "string")
+        return undefined;
+    return {
+        type: "function",
+        function: {
+            name: tool.name,
+            ...(tool.description ? { description: tool.description } : {}),
+            ...(tool.parameters ? { parameters: tool.parameters } : {}),
+        },
+    };
+}
+/**
+ * The flat Responses spelling (`{type:"function", name, …}`) of a tool spec.
+ * Inverse of {@link toChatTool}; non-function tools are dropped the same way.
+ */
+function toResponsesTool(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const tool = value;
+    if (tool.type !== "function")
+        return undefined;
+    if (tool.function && typeof tool.function === "object") {
+        const fn = tool.function;
+        return {
+            type: "function",
+            name: fn.name,
+            ...(fn.description ? { description: fn.description } : {}),
+            ...(fn.parameters ? { parameters: fn.parameters } : {}),
+        };
+    }
+    return typeof tool.name === "string" ? tool : undefined; // already flat
+}
+/** One Server-Sent Event, ready to write to the client. */
+function sse(event, data) {
+    return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+/**
+ * Translate an upstream chat-completions SSE stream into the Responses SSE
+ * event stream a Responses client consumes.
+ *
+ * Upstream chunks are `chat.completion.chunk` objects whose `choices[0].delta`
+ * carries incremental `content` (assistant text) and/or `tool_calls` (function
+ * calls, streamed by `index` with partial `arguments`). We emit the Responses
+ * lifecycle around them:
+ *
+ *   response.created
+ *   -> per text run:  output_item.added → output_text.delta* → output_item.done
+ *   -> per tool call: output_item.added → function_call_arguments.delta*
+ *                       → function_call_arguments.done → output_item.done
+ *   response.completed   (with the assembled final `response` object)
+ *
+ * The translator is intentionally tolerant: malformed/keepalive lines yield
+ * nothing.
+ */
+export function createResponsesStreamTranslator(model, responseId) {
+    let started = false;
+    let outputIndex = 0;
+    // Text run state: whether a message item is currently open, and its buffer.
+    let textOpen = false;
+    let textBuffer = "";
+    let textItemId = "";
+    const tools = new Map();
+    const created = () => sse("response.created", {
+        type: "response.created",
+        response: { id: responseId, object: "response", status: "in_progress", model, output: [] },
+    });
+    function openText() {
+        textOpen = true;
+        textItemId = `${responseId}-msg-${outputIndex}`;
+        const ev = sse("response.output_item.added", {
+            type: "response.output_item.added",
+            output_index: outputIndex,
+            item: { id: textItemId, type: "message", role: "assistant", content: [] },
+        });
+        return ev;
+    }
+    function closeText() {
+        if (!textOpen)
+            return "";
+        const item = {
+            id: textItemId,
+            type: "message",
+            role: "assistant",
+            content: [{ type: "output_text", text: textBuffer }],
+        };
+        const ev = sse("response.output_text.done", {
+            type: "response.output_text.done",
+            item_id: textItemId,
+            output_index: outputIndex,
+            content_index: 0,
+            text: textBuffer,
+        }) +
+            sse("response.output_item.done", {
+                type: "response.output_item.done",
+                output_index: outputIndex,
+                item,
+            });
+        textOpen = false;
+        textBuffer = "";
+        outputIndex += 1;
+        return ev;
+    }
+    function feed(chunk) {
+        let out = "";
+        if (!started) {
+            started = true;
+            out += created();
+        }
+        const choices = Array.isArray(chunk.choices) ? chunk.choices : [];
+        const choice = (choices[0] ?? {});
+        const delta = (choice.delta ?? {});
+        // Assistant text deltas.
+        if (typeof delta.content === "string" && delta.content.length > 0) {
+            if (!textOpen)
+                out += openText();
+            textBuffer += delta.content;
+            out += sse("response.output_text.delta", {
+                type: "response.output_text.delta",
+                item_id: textItemId,
+                output_index: outputIndex,
+                content_index: 0,
+                delta: delta.content,
+            });
+        }
+        // Tool-call deltas: each is keyed by `index`; `arguments` arrives in pieces.
+        const toolDeltas = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+        for (const rawTc of toolDeltas) {
+            const tc = rawTc;
+            const idx = Number(tc.index ?? 0);
+            const fn = (tc.function ?? {});
+            let state = tools.get(idx);
+            if (!state) {
+                // First fragment for this call: a text run (if open) must close first so
+                // output ordering stays monotonic, then we open a function_call item.
+                out += closeText();
+                state = {
+                    outputIndex,
+                    callId: String(tc.id ?? `${responseId}-call-${idx}`),
+                    name: String(fn.name ?? ""),
+                    args: "",
+                };
+                tools.set(idx, state);
+                out += sse("response.output_item.added", {
+                    type: "response.output_item.added",
+                    output_index: state.outputIndex,
+                    item: {
+                        id: state.callId,
+                        type: "function_call",
+                        call_id: state.callId,
+                        name: state.name,
+                        arguments: "",
+                    },
+                });
+                outputIndex += 1;
+            }
+            if (typeof fn.name === "string" && fn.name && !state.name)
+                state.name = fn.name;
+            if (typeof fn.arguments === "string" && fn.arguments.length > 0) {
+                state.args += fn.arguments;
+                out += sse("response.function_call_arguments.delta", {
+                    type: "response.function_call_arguments.delta",
+                    item_id: state.callId,
+                    output_index: state.outputIndex,
+                    delta: fn.arguments,
+                });
+            }
+        }
+        return out;
+    }
+    function finish() {
+        let out = closeText();
+        // Close any open tool calls, emitting their assembled arguments.
+        for (const state of tools.values()) {
+            out += sse("response.function_call_arguments.done", {
+                type: "response.function_call_arguments.done",
+                item_id: state.callId,
+                output_index: state.outputIndex,
+                arguments: state.args,
+            });
+            out += sse("response.output_item.done", {
+                type: "response.output_item.done",
+                output_index: state.outputIndex,
+                item: {
+                    id: state.callId,
+                    type: "function_call",
+                    call_id: state.callId,
+                    name: state.name,
+                    arguments: state.args,
+                },
+            });
+        }
+        out += sse("response.completed", {
+            type: "response.completed",
+            response: { id: responseId, object: "response", status: "completed", model },
+        });
+        return out;
+    }
+    return { feed, finish };
+}
+/**
+ * Read the answer text and cited sources out of a Responses `response` payload.
+ *
+ * This is the inverse of {@link chatToResponse}: it consumes what an endpoint
+ * speaking Responses natively returns, rather than producing it. The Databricks
+ * native web-search tool answers this way, with each source attached as a
+ * `url_citation` annotation on the content part that used it.
+ *
+ * Prefers the flattened `output_text` when the payload carries it, and falls
+ * back to walking `output[].content[].text`. Every field is optional upstream,
+ * so a payload missing any of it yields empty results rather than throwing.
+ */
+export function readResponsesOutput(payload) {
+    const output = Array.isArray(payload.output) ? payload.output : [];
+    const texts = [];
+    const citations = [];
+    const seen = new Set();
+    for (const rawItem of output) {
+        if (!rawItem || typeof rawItem !== "object")
+            continue;
+        const content = rawItem.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const rawPart of content) {
+            if (!rawPart || typeof rawPart !== "object")
+                continue;
+            const part = rawPart;
+            const text = string.trimToEmpty(part.text);
+            if (text)
+                texts.push(text);
+            const annotations = Array.isArray(part.annotations) ? part.annotations : [];
+            for (const rawAnn of annotations) {
+                if (!rawAnn || typeof rawAnn !== "object")
+                    continue;
+                const ann = rawAnn;
+                const url = string.trimToEmpty(ann.url);
+                if (!url || seen.has(url))
+                    continue;
+                seen.add(url);
+                const title = string.trimToEmpty(ann.title);
+                citations.push({ url, ...(title ? { title } : {}) });
+            }
+        }
+    }
+    return { text: string.trimToEmpty(payload.output_text) || texts.join("\n").trim(), citations };
+}
+/**
+ * Strip tool types the upstream model doesn't support from a Responses request
+ * body, returning a shallow copy safe to forward (the input is not mutated).
+ *
+ * Clients like the Codex CLI include built-in Responses tools (`web_search`,
+ * `local_shell`, `custom`, ...) alongside their `function` tools. Databricks'
+ * Open Responses surface for Anthropic/Claude (and other non-OpenAI providers)
+ * only accepts `function` tools and hard-errors otherwise:
+ *   "Anthropic does not support tool type 'web_search'. Only 'function' is supported."
+ * Call this before forwarding to `/serving-endpoints/open-responses`. The OpenAI
+ * `/serving-endpoints/responses` path should keep built-ins (GPT supports them).
+ * If filtering empties the list, `tools` / `tool_choice` / `parallel_tool_calls`
+ * are dropped so we never send an empty `tools: []`.
+ */
+export function sanitizeResponsesTools(body) {
+    if (!Array.isArray(body.tools) || body.tools.length === 0)
+        return body;
+    const fnTools = body.tools.filter((t) => t && typeof t === "object" && t.type === "function");
+    if (fnTools.length === body.tools.length)
+        return body; // nothing to strip
+    const next = { ...body };
+    if (fnTools.length > 0) {
+        next.tools = fnTools;
+    }
+    else {
+        delete next.tools;
+        delete next.tool_choice;
+        delete next.parallel_tool_calls;
+    }
+    return next;
+}
+/**
+ * Content-part / input-item types Claude extended thinking uses on the wire.
+ *
+ * Shared so both wire surfaces strip the same set: the Responses path here
+ * ({@link sanitizeOpenResponsesInput}) and the Chat Completions path in
+ * `@dbx-tools/appkit-mastra`'s serving sanitize. Anthropic signs these blocks,
+ * so a replay that mutates one is rejected outright - both paths must agree on
+ * what counts as a reasoning block.
+ */
+export const REASONING_TYPES = new Set([
+    "reasoning",
+    "thinking",
+    "redacted_thinking",
+]);
+/**
+ * Rewrite Responses `input` so Open Responses will accept it.
+ *
+ * Two OpenAI / Codex shapes that Databricks Open Responses (Claude, Gemini, …)
+ * reject:
+ *
+ * 1. Prior assistant turns with `output_text` / `output_*` content parts —
+ *    Open Responses only allows `input_text`, `input_image`, `input_file`,
+ *    `input_audio`. Map every `output_<kind>` part to `input_<kind>`.
+ * 2. Replayed extended-thinking blocks (`thinking`, `redacted_thinking`,
+ *    `reasoning` content parts, and top-level `reasoning` input items). Claude
+ *    signs those; any client round-trip that mutates them (or a cross-provider
+ *    replay) fails with e.g.
+ *      "messages.N.content.M: Invalid `data` in `redacted_thinking` block"
+ *    Strip them — the UI/client already showed the thinking; replay does not
+ *    need the signed blob. Same policy as appkit-mastra's serving sanitize.
+ *
+ * Returns a shallow copy when anything changes; otherwise the input body.
+ */
+export function sanitizeOpenResponsesInput(body) {
+    if (!Array.isArray(body.input) || body.input.length === 0)
+        return body;
+    let changed = false;
+    const input = [];
+    for (const raw of body.input) {
+        if (!raw || typeof raw !== "object") {
+            input.push(raw);
+            continue;
+        }
+        const item = raw;
+        // Top-level Responses reasoning items (not message content parts).
+        if (typeof item.type === "string" && REASONING_TYPES.has(item.type)) {
+            changed = true;
+            continue;
+        }
+        if (!Array.isArray(item.content)) {
+            input.push(raw);
+            continue;
+        }
+        let partChanged = false;
+        const content = [];
+        for (const part of item.content) {
+            if (!part || typeof part !== "object") {
+                content.push(part);
+                continue;
+            }
+            const p = part;
+            if (typeof p.type === "string" && REASONING_TYPES.has(p.type)) {
+                partChanged = true;
+                continue;
+            }
+            if (typeof p.type === "string" && p.type.startsWith("output_")) {
+                partChanged = true;
+                content.push({ ...p, type: `input_${p.type.slice("output_".length)}` });
+                continue;
+            }
+            content.push(part);
+        }
+        if (!partChanged) {
+            input.push(raw);
+            continue;
+        }
+        changed = true;
+        // Drop assistant turns that only carried thinking (nothing left to replay).
+        if (content.length === 0 && item.role === "assistant")
+            continue;
+        input.push({ ...item, content });
+    }
+    return changed ? { ...body, input } : body;
+}
+/**
+ * Full Open Responses request sanitizer: strip non-`function` tools, rewrite
+ * `output_*` content parts, and drop thinking / reasoning blocks. Safe no-op
+ * when nothing needs changing.
+ */
+export function sanitizeOpenResponsesRequest(body) {
+    return sanitizeOpenResponsesInput(sanitizeResponsesTools(body));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openai-responses.js","sourceRoot":"","sources":["../../src/openai-responses.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenAI Responses API <-> Chat Completions translation.\n *\n * Some clients speak only the Responses API (`POST /v1/responses`) - the Codex\n * CLI is the motivating one. Databricks now also exposes native Responses\n * surfaces (`/serving-endpoints/responses` and `/serving-endpoints/open-responses`),\n * while most endpoints still speak Chat Completions at `/invocations`. This\n * module bridges the two, in both directions:\n *\n *   - {@link responsesToChat} lowers a Responses request body to a chat\n *     completions body (instructions -> system message, typed `input` items ->\n *     `messages`, `tools`/`tool_choice` carried through, function-call outputs\n *     folded back into the transcript).\n *   - {@link chatToResponsesRequest} raises a chat-completions request into a\n *     Responses request (the inverse of {@link responsesToChat}), for routing a\n *     chat client at a Responses-only model like Codex.\n *   - {@link chatToResponse} lifts a non-streaming chat completion back into a\n *     Responses `response` object.\n *   - {@link responseToChatCompletion} lifts a native Responses `response`\n *     back into a chat-completions body (the inverse of {@link chatToResponse}).\n *   - {@link createResponsesStreamTranslator} lifts a streaming chat completion\n *     (an OpenAI SSE `chat.completion.chunk` stream) into the Responses SSE\n *     event stream those clients consume (`response.created`,\n *     `response.output_text.delta`, function-call argument deltas,\n *     `response.completed`).\n *   - {@link readResponsesOutput} reads the other direction: pull the answer\n *     text and citations out of a `response` object returned by an endpoint\n *     that speaks Responses natively (the Databricks native web-search tool).\n *   - {@link sanitizeResponsesTools} keeps only `function` tools on a Responses\n *     request body (for `/open-responses` / Anthropic, which reject Codex\n *     built-ins like `web_search`).\n *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types\n *     in `input` to `input_*`, and drops Claude thinking / reasoning blocks\n *     that Open Responses rejects on replay (`redacted_thinking`, …).\n *\n * Only the surface real clients exercise is translated; unknown fields are\n * ignored rather than rejected, so a newer client degrades instead of breaking.\n *\n * Browser-safe: pure functions over plain JSON, no transport and no Node\n * built-ins, so the same translation runs in a proxy, a server route, or a test.\n *\n * @module\n */\n\nimport { string } from \"@dbx-tools/shared-core\";\n\nimport { type ChatMessage, type ChatToolCall, chatContentToText } from \"./openai-chat\";\n\n/**\n * Lower a Responses request body to a chat-completions body. Returns the chat\n * body plus whether the caller asked for streaming (the server needs it to pick\n * the upstream `accept` header and the translation path).\n */\nexport function responsesToChat(body: Record<string, unknown>): {\n  chat: Record<string, unknown>;\n  stream: boolean;\n} {\n  const messages: ChatMessage[] = [];\n\n  // `instructions` becomes the leading system message.\n  if (typeof body.instructions === \"string\" && body.instructions.length > 0) {\n    messages.push({ role: \"system\", content: body.instructions });\n  }\n\n  // `input` is an array of typed items: messages, function_call, and\n  // function_call_output. Fold each into the chat transcript.\n  const input = Array.isArray(body.input) ? body.input : [];\n  for (const raw of input) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const item = raw as Record<string, unknown>;\n    const type = item.type;\n\n    if (type === \"function_call\") {\n      // A prior tool call the model made; re-attach it to an assistant turn.\n      messages.push({\n        role: \"assistant\",\n        content: null,\n        tool_calls: [toChatToolCall(item)],\n      });\n      continue;\n    }\n\n    if (type === \"function_call_output\") {\n      // The tool's result, keyed back to the call it answers.\n      messages.push({\n        role: \"tool\",\n        tool_call_id: String(item.call_id ?? item.id ?? \"\"),\n        content: typeof item.output === \"string\" ? item.output : chatContentToText(item.output),\n      });\n      continue;\n    }\n\n    // Default: a message item with a role and typed content.\n    const role = typeof item.role === \"string\" ? item.role : \"user\";\n    // Chat has no \"developer\" role; treat it as system (its intent here).\n    const chatRole = role === \"developer\" ? \"system\" : role;\n    messages.push({ role: chatRole, content: chatContentToText(item.content) });\n  }\n\n  const chat: Record<string, unknown> = {\n    model: body.model,\n    messages,\n    stream: body.stream === true,\n  };\n\n  // Carry through function-calling config when present. Responses function\n  // tools are FLAT (`{type:\"function\", name, description, parameters}`); chat\n  // wants them NESTED (`{type:\"function\", function:{name, …}}`). Clients also\n  // send built-in tool types (local_shell, web_search, …) that Databricks chat\n  // rejects (\"Missing 'function' in the tool specification\"), so we translate\n  // only function tools and drop the rest.\n  if (Array.isArray(body.tools) && body.tools.length > 0) {\n    const chatTools = body.tools\n      .map(toChatTool)\n      .filter((t): t is Record<string, unknown> => t !== undefined);\n    if (chatTools.length > 0) {\n      chat.tools = chatTools;\n      if (body.tool_choice !== undefined) chat.tool_choice = body.tool_choice;\n      // NOTE: do NOT forward `parallel_tool_calls`. Clients send it, but\n      // Databricks Model Serving's chat API rejects unknown fields\n      // (\"parallel_tool_calls: Extra inputs are not permitted\"), which would\n      // fail the whole turn. Drop it.\n    }\n  }\n\n  return { chat, stream: body.stream === true };\n}\n\n/**\n * Raise a chat-completions request into a Responses request body. Inverse of\n * {@link responsesToChat}: used when a chat client hits a Responses-only\n * Databricks model (e.g. Codex) so the proxy can POST to\n * `/serving-endpoints/responses` without the client knowing.\n */\nexport function chatToResponsesRequest(body: Record<string, unknown>): {\n  responses: Record<string, unknown>;\n  stream: boolean;\n} {\n  const messages = Array.isArray(body.messages) ? body.messages : [];\n  const input: unknown[] = [];\n  let instructions: string | undefined;\n\n  for (const raw of messages) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const message = raw as Record<string, unknown>;\n    const role = typeof message.role === \"string\" ? message.role : \"user\";\n\n    // Leading system / developer messages become top-level `instructions`.\n    if (\n      (role === \"system\" || role === \"developer\") &&\n      instructions === undefined &&\n      input.length === 0\n    ) {\n      const text = chatContentToText(message.content);\n      if (text) instructions = text;\n      continue;\n    }\n\n    if (role === \"tool\") {\n      input.push({\n        type: \"function_call_output\",\n        call_id: String(message.tool_call_id ?? \"\"),\n        output: chatContentToText(message.content),\n      });\n      continue;\n    }\n\n    if (\n      role === \"assistant\" &&\n      Array.isArray(message.tool_calls) &&\n      message.tool_calls.length > 0\n    ) {\n      for (const rawCall of message.tool_calls) {\n        if (!rawCall || typeof rawCall !== \"object\") continue;\n        input.push(toFunctionCallItem(rawCall as Record<string, unknown>));\n      }\n      const text = chatContentToText(message.content);\n      if (text) {\n        input.push({ type: \"message\", role: \"assistant\", content: text });\n      }\n      continue;\n    }\n\n    input.push({\n      type: \"message\",\n      role,\n      content: chatContentToText(message.content),\n    });\n  }\n\n  const responses: Record<string, unknown> = {\n    model: body.model,\n    input,\n    stream: body.stream === true,\n  };\n  if (instructions) responses.instructions = instructions;\n\n  // Chat tools are nested (`function: { name, … }`); Responses wants them flat.\n  if (Array.isArray(body.tools) && body.tools.length > 0) {\n    const tools = body.tools\n      .map(toResponsesTool)\n      .filter((t): t is Record<string, unknown> => t !== undefined);\n    if (tools.length > 0) {\n      responses.tools = tools;\n      if (body.tool_choice !== undefined) responses.tool_choice = body.tool_choice;\n    }\n  }\n\n  // Prefer Responses' max_output_tokens naming; fall back from chat max_tokens.\n  if (typeof body.max_output_tokens === \"number\") {\n    responses.max_output_tokens = body.max_output_tokens;\n  } else if (typeof body.max_tokens === \"number\") {\n    responses.max_output_tokens = body.max_tokens;\n  }\n\n  return { responses, stream: body.stream === true };\n}\n\n/** Lift a non-streaming chat completion JSON into a Responses `response` object. */\nexport function chatToResponse(chat: Record<string, unknown>, model: string): unknown {\n  const choices = Array.isArray(chat.choices) ? chat.choices : [];\n  const first = (choices[0] ?? {}) as Record<string, unknown>;\n  const message = (first.message ?? {}) as Record<string, unknown>;\n  const output: unknown[] = [];\n\n  const text = typeof message.content === \"string\" ? message.content : \"\";\n  if (text) {\n    output.push({\n      type: \"message\",\n      role: \"assistant\",\n      content: [{ type: \"output_text\", text }],\n    });\n  }\n\n  // Surface any tool calls as Responses `function_call` output items.\n  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];\n  for (const raw of toolCalls) {\n    output.push(toFunctionCallItem(raw as Record<string, unknown>));\n  }\n\n  const usage = (chat.usage ?? {}) as Record<string, unknown>;\n  return {\n    id: String(chat.id ?? \"resp\"),\n    object: \"response\",\n    created_at: typeof chat.created === \"number\" ? chat.created : 0,\n    model,\n    status: \"completed\",\n    output,\n    usage: {\n      input_tokens: Number(usage.prompt_tokens ?? 0),\n      output_tokens: Number(usage.completion_tokens ?? 0),\n      total_tokens: Number(usage.total_tokens ?? 0),\n    },\n  };\n}\n\n/**\n * Lift a native Responses `response` object into a chat-completions body.\n * Inverse of {@link chatToResponse}: used after a Responses-only upstream call\n * when the client spoke Chat Completions.\n */\nexport function responseToChatCompletion(\n  response: Record<string, unknown>,\n  model: string,\n): Record<string, unknown> {\n  const { text } = readResponsesOutput(response);\n  const toolCalls: unknown[] = [];\n  const output = Array.isArray(response.output) ? response.output : [];\n  for (const raw of output) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const item = raw as Record<string, unknown>;\n    if (item.type !== \"function_call\") continue;\n    toolCalls.push(toChatToolCall(item));\n  }\n\n  const message: Record<string, unknown> = {\n    role: \"assistant\",\n    content: text || null,\n  };\n  if (toolCalls.length > 0) message.tool_calls = toolCalls;\n\n  const usage = (response.usage ?? {}) as Record<string, unknown>;\n  return {\n    id: String(response.id ?? \"chatcmpl\"),\n    object: \"chat.completion\",\n    created: typeof response.created_at === \"number\" ? response.created_at : 0,\n    model,\n    choices: [\n      {\n        index: 0,\n        message,\n        finish_reason: toolCalls.length > 0 ? \"tool_calls\" : \"stop\",\n      },\n    ],\n    usage: {\n      prompt_tokens: Number(usage.input_tokens ?? 0),\n      completion_tokens: Number(usage.output_tokens ?? 0),\n      total_tokens: Number(usage.total_tokens ?? 0),\n    },\n  };\n}\n\n/**\n * A tool call's `arguments` JSON. Both wires carry it as an unparsed string;\n * anything else (absent, an already-parsed object) becomes an empty literal so\n * the receiving side always has valid JSON to parse.\n */\nfunction callArguments(value: unknown): string {\n  return typeof value === \"string\" ? value : \"{}\";\n}\n\n/**\n * The Responses `function_call` item for a tool call in either spelling: a chat\n * `tool_calls[]` entry (`{id, function:{name, arguments}}`) or an item that is\n * already flat.\n */\nfunction toFunctionCallItem(call: Record<string, unknown>): Record<string, unknown> {\n  const fn = (call.function ?? call) as Record<string, unknown>;\n  return {\n    type: \"function_call\",\n    call_id: String(call.call_id ?? call.id ?? \"\"),\n    name: String(fn.name ?? \"\"),\n    arguments: callArguments(fn.arguments),\n  };\n}\n\n/** The chat `tool_calls[]` entry for a Responses `function_call` item. */\nfunction toChatToolCall(item: Record<string, unknown>): ChatToolCall {\n  return {\n    id: String(item.call_id ?? item.id ?? \"\"),\n    type: \"function\",\n    function: {\n      name: String(item.name ?? \"\"),\n      arguments: callArguments(item.arguments),\n    },\n  };\n}\n\n/**\n * The chat-nested spelling (`{type:\"function\", function:{name, …}}`) of a tool\n * spec, or `undefined` for a built-in Responses tool (`web_search`,\n * `local_shell`, …) that chat cannot express and Databricks rejects.\n */\nfunction toChatTool(value: unknown): Record<string, unknown> | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const tool = value as Record<string, unknown>;\n  if (tool.type !== \"function\") return undefined;\n  if (tool.function && typeof tool.function === \"object\") return tool; // already nested\n  if (typeof tool.name !== \"string\") return undefined;\n  return {\n    type: \"function\",\n    function: {\n      name: tool.name,\n      ...(tool.description ? { description: tool.description } : {}),\n      ...(tool.parameters ? { parameters: tool.parameters } : {}),\n    },\n  };\n}\n\n/**\n * The flat Responses spelling (`{type:\"function\", name, …}`) of a tool spec.\n * Inverse of {@link toChatTool}; non-function tools are dropped the same way.\n */\nfunction toResponsesTool(value: unknown): Record<string, unknown> | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const tool = value as Record<string, unknown>;\n  if (tool.type !== \"function\") return undefined;\n  if (tool.function && typeof tool.function === \"object\") {\n    const fn = tool.function as Record<string, unknown>;\n    return {\n      type: \"function\",\n      name: fn.name,\n      ...(fn.description ? { description: fn.description } : {}),\n      ...(fn.parameters ? { parameters: fn.parameters } : {}),\n    };\n  }\n  return typeof tool.name === \"string\" ? tool : undefined; // already flat\n}\n\n/** One Server-Sent Event, ready to write to the client. */\nfunction sse(event: string, data: unknown): string {\n  return `event: ${event}\\ndata: ${JSON.stringify(data)}\\n\\n`;\n}\n\n/**\n * Incremental chat-chunk -> Responses-SSE translator. `feed` and `finish` both\n * return the SSE bytes to forward, or `\"\"` when a chunk produced no event.\n */\nexport interface ResponsesStreamTranslator {\n  /** Translate one upstream `chat.completion.chunk` object. */\n  feed(chunk: Record<string, unknown>): string;\n  /** Close any open items and emit `response.completed`. Call once, at end of stream. */\n  finish(): string;\n}\n\n/**\n * Translate an upstream chat-completions SSE stream into the Responses SSE\n * event stream a Responses client consumes.\n *\n * Upstream chunks are `chat.completion.chunk` objects whose `choices[0].delta`\n * carries incremental `content` (assistant text) and/or `tool_calls` (function\n * calls, streamed by `index` with partial `arguments`). We emit the Responses\n * lifecycle around them:\n *\n *   response.created\n *   -> per text run:  output_item.added → output_text.delta* → output_item.done\n *   -> per tool call: output_item.added → function_call_arguments.delta*\n *                       → function_call_arguments.done → output_item.done\n *   response.completed   (with the assembled final `response` object)\n *\n * The translator is intentionally tolerant: malformed/keepalive lines yield\n * nothing.\n */\nexport function createResponsesStreamTranslator(\n  model: string,\n  responseId: string,\n): ResponsesStreamTranslator {\n  let started = false;\n  let outputIndex = 0;\n\n  // Text run state: whether a message item is currently open, and its buffer.\n  let textOpen = false;\n  let textBuffer = \"\";\n  let textItemId = \"\";\n\n  // Tool-call state, keyed by the upstream `tool_calls[].index`.\n  interface ToolState {\n    outputIndex: number;\n    callId: string;\n    name: string;\n    args: string;\n  }\n  const tools = new Map<number, ToolState>();\n\n  const created = () =>\n    sse(\"response.created\", {\n      type: \"response.created\",\n      response: { id: responseId, object: \"response\", status: \"in_progress\", model, output: [] },\n    });\n\n  function openText(): string {\n    textOpen = true;\n    textItemId = `${responseId}-msg-${outputIndex}`;\n    const ev = sse(\"response.output_item.added\", {\n      type: \"response.output_item.added\",\n      output_index: outputIndex,\n      item: { id: textItemId, type: \"message\", role: \"assistant\", content: [] },\n    });\n    return ev;\n  }\n\n  function closeText(): string {\n    if (!textOpen) return \"\";\n    const item = {\n      id: textItemId,\n      type: \"message\",\n      role: \"assistant\",\n      content: [{ type: \"output_text\", text: textBuffer }],\n    };\n    const ev =\n      sse(\"response.output_text.done\", {\n        type: \"response.output_text.done\",\n        item_id: textItemId,\n        output_index: outputIndex,\n        content_index: 0,\n        text: textBuffer,\n      }) +\n      sse(\"response.output_item.done\", {\n        type: \"response.output_item.done\",\n        output_index: outputIndex,\n        item,\n      });\n    textOpen = false;\n    textBuffer = \"\";\n    outputIndex += 1;\n    return ev;\n  }\n\n  function feed(chunk: Record<string, unknown>): string {\n    let out = \"\";\n    if (!started) {\n      started = true;\n      out += created();\n    }\n    const choices = Array.isArray(chunk.choices) ? chunk.choices : [];\n    const choice = (choices[0] ?? {}) as Record<string, unknown>;\n    const delta = (choice.delta ?? {}) as Record<string, unknown>;\n\n    // Assistant text deltas.\n    if (typeof delta.content === \"string\" && delta.content.length > 0) {\n      if (!textOpen) out += openText();\n      textBuffer += delta.content;\n      out += sse(\"response.output_text.delta\", {\n        type: \"response.output_text.delta\",\n        item_id: textItemId,\n        output_index: outputIndex,\n        content_index: 0,\n        delta: delta.content,\n      });\n    }\n\n    // Tool-call deltas: each is keyed by `index`; `arguments` arrives in pieces.\n    const toolDeltas = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];\n    for (const rawTc of toolDeltas) {\n      const tc = rawTc as Record<string, unknown>;\n      const idx = Number(tc.index ?? 0);\n      const fn = (tc.function ?? {}) as Record<string, unknown>;\n      let state = tools.get(idx);\n      if (!state) {\n        // First fragment for this call: a text run (if open) must close first so\n        // output ordering stays monotonic, then we open a function_call item.\n        out += closeText();\n        state = {\n          outputIndex,\n          callId: String(tc.id ?? `${responseId}-call-${idx}`),\n          name: String(fn.name ?? \"\"),\n          args: \"\",\n        };\n        tools.set(idx, state);\n        out += sse(\"response.output_item.added\", {\n          type: \"response.output_item.added\",\n          output_index: state.outputIndex,\n          item: {\n            id: state.callId,\n            type: \"function_call\",\n            call_id: state.callId,\n            name: state.name,\n            arguments: \"\",\n          },\n        });\n        outputIndex += 1;\n      }\n      if (typeof fn.name === \"string\" && fn.name && !state.name) state.name = fn.name;\n      if (typeof fn.arguments === \"string\" && fn.arguments.length > 0) {\n        state.args += fn.arguments;\n        out += sse(\"response.function_call_arguments.delta\", {\n          type: \"response.function_call_arguments.delta\",\n          item_id: state.callId,\n          output_index: state.outputIndex,\n          delta: fn.arguments,\n        });\n      }\n    }\n    return out;\n  }\n\n  function finish(): string {\n    let out = closeText();\n    // Close any open tool calls, emitting their assembled arguments.\n    for (const state of tools.values()) {\n      out += sse(\"response.function_call_arguments.done\", {\n        type: \"response.function_call_arguments.done\",\n        item_id: state.callId,\n        output_index: state.outputIndex,\n        arguments: state.args,\n      });\n      out += sse(\"response.output_item.done\", {\n        type: \"response.output_item.done\",\n        output_index: state.outputIndex,\n        item: {\n          id: state.callId,\n          type: \"function_call\",\n          call_id: state.callId,\n          name: state.name,\n          arguments: state.args,\n        },\n      });\n    }\n    out += sse(\"response.completed\", {\n      type: \"response.completed\",\n      response: { id: responseId, object: \"response\", status: \"completed\", model },\n    });\n    return out;\n  }\n\n  return { feed, finish };\n}\n\n/** A source the model cited, as carried by a Responses content-part annotation. */\nexport interface ResponsesCitation {\n  url: string;\n  title?: string;\n}\n\n/** What {@link readResponsesOutput} pulls out of a `response` object. */\nexport interface ResponsesOutput {\n  /** The assistant's answer, with the output items concatenated. */\n  text: string;\n  /** Cited sources in first-seen order, deduplicated by URL. */\n  citations: ResponsesCitation[];\n}\n\n/**\n * Read the answer text and cited sources out of a Responses `response` payload.\n *\n * This is the inverse of {@link chatToResponse}: it consumes what an endpoint\n * speaking Responses natively returns, rather than producing it. The Databricks\n * native web-search tool answers this way, with each source attached as a\n * `url_citation` annotation on the content part that used it.\n *\n * Prefers the flattened `output_text` when the payload carries it, and falls\n * back to walking `output[].content[].text`. Every field is optional upstream,\n * so a payload missing any of it yields empty results rather than throwing.\n */\nexport function readResponsesOutput(payload: Record<string, unknown>): ResponsesOutput {\n  const output = Array.isArray(payload.output) ? (payload.output as unknown[]) : [];\n  const texts: string[] = [];\n  const citations: ResponsesCitation[] = [];\n  const seen = new Set<string>();\n\n  for (const rawItem of output) {\n    if (!rawItem || typeof rawItem !== \"object\") continue;\n    const content = (rawItem as Record<string, unknown>).content;\n    if (!Array.isArray(content)) continue;\n    for (const rawPart of content) {\n      if (!rawPart || typeof rawPart !== \"object\") continue;\n      const part = rawPart as Record<string, unknown>;\n      const text = string.trimToEmpty(part.text);\n      if (text) texts.push(text);\n      const annotations = Array.isArray(part.annotations) ? part.annotations : [];\n      for (const rawAnn of annotations) {\n        if (!rawAnn || typeof rawAnn !== \"object\") continue;\n        const ann = rawAnn as Record<string, unknown>;\n        const url = string.trimToEmpty(ann.url);\n        if (!url || seen.has(url)) continue;\n        seen.add(url);\n        const title = string.trimToEmpty(ann.title);\n        citations.push({ url, ...(title ? { title } : {}) });\n      }\n    }\n  }\n\n  return { text: string.trimToEmpty(payload.output_text) || texts.join(\"\\n\").trim(), citations };\n}\n\n/**\n * Strip tool types the upstream model doesn't support from a Responses request\n * body, returning a shallow copy safe to forward (the input is not mutated).\n *\n * Clients like the Codex CLI include built-in Responses tools (`web_search`,\n * `local_shell`, `custom`, ...) alongside their `function` tools. Databricks'\n * Open Responses surface for Anthropic/Claude (and other non-OpenAI providers)\n * only accepts `function` tools and hard-errors otherwise:\n *   \"Anthropic does not support tool type 'web_search'. Only 'function' is supported.\"\n * Call this before forwarding to `/serving-endpoints/open-responses`. The OpenAI\n * `/serving-endpoints/responses` path should keep built-ins (GPT supports them).\n * If filtering empties the list, `tools` / `tool_choice` / `parallel_tool_calls`\n * are dropped so we never send an empty `tools: []`.\n */\nexport function sanitizeResponsesTools(body: Record<string, unknown>): Record<string, unknown> {\n  if (!Array.isArray(body.tools) || body.tools.length === 0) return body;\n  const fnTools = body.tools.filter(\n    (t) => t && typeof t === \"object\" && (t as Record<string, unknown>).type === \"function\",\n  );\n  if (fnTools.length === body.tools.length) return body; // nothing to strip\n  const next: Record<string, unknown> = { ...body };\n  if (fnTools.length > 0) {\n    next.tools = fnTools;\n  } else {\n    delete next.tools;\n    delete next.tool_choice;\n    delete next.parallel_tool_calls;\n  }\n  return next;\n}\n\n/**\n * Content-part / input-item types Claude extended thinking uses on the wire.\n *\n * Shared so both wire surfaces strip the same set: the Responses path here\n * ({@link sanitizeOpenResponsesInput}) and the Chat Completions path in\n * `@dbx-tools/appkit-mastra`'s serving sanitize. Anthropic signs these blocks,\n * so a replay that mutates one is rejected outright - both paths must agree on\n * what counts as a reasoning block.\n */\nexport const REASONING_TYPES: ReadonlySet<string> = new Set([\n  \"reasoning\",\n  \"thinking\",\n  \"redacted_thinking\",\n]);\n\n/**\n * Rewrite Responses `input` so Open Responses will accept it.\n *\n * Two OpenAI / Codex shapes that Databricks Open Responses (Claude, Gemini, …)\n * reject:\n *\n * 1. Prior assistant turns with `output_text` / `output_*` content parts —\n *    Open Responses only allows `input_text`, `input_image`, `input_file`,\n *    `input_audio`. Map every `output_<kind>` part to `input_<kind>`.\n * 2. Replayed extended-thinking blocks (`thinking`, `redacted_thinking`,\n *    `reasoning` content parts, and top-level `reasoning` input items). Claude\n *    signs those; any client round-trip that mutates them (or a cross-provider\n *    replay) fails with e.g.\n *      \"messages.N.content.M: Invalid `data` in `redacted_thinking` block\"\n *    Strip them — the UI/client already showed the thinking; replay does not\n *    need the signed blob. Same policy as appkit-mastra's serving sanitize.\n *\n * Returns a shallow copy when anything changes; otherwise the input body.\n */\nexport function sanitizeOpenResponsesInput(body: Record<string, unknown>): Record<string, unknown> {\n  if (!Array.isArray(body.input) || body.input.length === 0) return body;\n\n  let changed = false;\n  const input: unknown[] = [];\n\n  for (const raw of body.input) {\n    if (!raw || typeof raw !== \"object\") {\n      input.push(raw);\n      continue;\n    }\n    const item = raw as Record<string, unknown>;\n\n    // Top-level Responses reasoning items (not message content parts).\n    if (typeof item.type === \"string\" && REASONING_TYPES.has(item.type)) {\n      changed = true;\n      continue;\n    }\n\n    if (!Array.isArray(item.content)) {\n      input.push(raw);\n      continue;\n    }\n\n    let partChanged = false;\n    const content: unknown[] = [];\n    for (const part of item.content) {\n      if (!part || typeof part !== \"object\") {\n        content.push(part);\n        continue;\n      }\n      const p = part as Record<string, unknown>;\n      if (typeof p.type === \"string\" && REASONING_TYPES.has(p.type)) {\n        partChanged = true;\n        continue;\n      }\n      if (typeof p.type === \"string\" && p.type.startsWith(\"output_\")) {\n        partChanged = true;\n        content.push({ ...p, type: `input_${p.type.slice(\"output_\".length)}` });\n        continue;\n      }\n      content.push(part);\n    }\n\n    if (!partChanged) {\n      input.push(raw);\n      continue;\n    }\n    changed = true;\n    // Drop assistant turns that only carried thinking (nothing left to replay).\n    if (content.length === 0 && item.role === \"assistant\") continue;\n    input.push({ ...item, content });\n  }\n\n  return changed ? { ...body, input } : body;\n}\n\n/**\n * Full Open Responses request sanitizer: strip non-`function` tools, rewrite\n * `output_*` content parts, and drop thinking / reasoning blocks. Safe no-op\n * when nothing needs changing.\n */\nexport function sanitizeOpenResponsesRequest(\n  body: Record<string, unknown>,\n): Record<string, unknown> {\n  return sanitizeOpenResponsesInput(sanitizeResponsesTools(body));\n}\n"]}