@wacry/codeks-bridge 0.0.0-stage → 0.0.1

package/dist/auth.js

@@ -0,0 +1,42 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { BridgeError } from "./errors.js";
+import { forwardRequestHeaders } from "./headers.js";
+const execute = promisify(execFile);
+export async function upstreamHeaders(config, api, signal, clientHeaders) {
+    const headers = forwardRequestHeaders(clientHeaders, config.auth_header);
+    for (const [name, value] of Object.entries(config.headers ?? {}))
+        headers.set(name, value);
+    if (!headers.has("content-type"))
+        headers.set("content-type", "application/json");
+    if (api === "anthropic" && !headers.has("anthropic-version"))
+        headers.set("anthropic-version", "2023-06-01");
+    let credential;
+    if (config.api_key_env) {
+        credential = process.env[config.api_key_env]?.trim();
+        if (!credential)
+            throw new BridgeError(`Missing credential environment variable: ${config.api_key_env}`);
+    }
+    else if (config.api_key_command) {
+        const [command, ...args] = config.api_key_command;
+        try {
+            const result = await execute(command, args, { encoding: "utf8", timeout: 30_000, maxBuffer: 64 * 1024, signal });
+            credential = result.stdout.trim();
+        }
+        catch {
+            if (signal.aborted)
+                throw signal.reason;
+            // execFile errors include stdout/stderr. Never forward those to a client.
+            throw new BridgeError("Credential command failed");
+        }
+        if (!credential)
+            throw new BridgeError("Credential command returned an empty credential");
+    }
+    if (credential) {
+        if (/[\r\n]/.test(credential))
+            throw new BridgeError("Credential must be a single line");
+        const header = config.auth_header ?? (api === "anthropic" ? "x-api-key" : "authorization");
+        headers.set(header, header.toLowerCase() === "authorization" ? `Bearer ${credential}` : credential);
+    }
+    return headers;
+}

package/dist/backends/anthropic.d.ts

@@ -0,0 +1,8 @@
+import type { ToolSet } from "../tools.ts";
+import type { Backend, BackendContext } from "../types.ts";
+/** Convert only request-owned copies; stored history remains unchanged. */
+export declare function buildAnthropicRequest(context: BackendContext): {
+    body: Record<string, any>;
+    tools: ToolSet;
+};
+export declare const runAnthropic: Backend;

package/dist/backends/anthropic.js

@@ -0,0 +1,309 @@
+import { encodeReasoning } from "../carrier.js";
+import { BridgeError, upstreamError } from "../errors.js";
+import { prepareHistory } from "../history.js";
+import { reasoningEffort, reasoningSummaryRequested } from "../profiles.js";
+import { parseJsonSse } from "../sse.js";
+import { buildToolSet, normalizeToolDeclarations, safeCallId } from "../tools.js";
+import { upstreamFetch } from "../upstream.js";
+function contentBlocks(content) {
+    if (typeof content === "string")
+        return content ? [{ type: "text", text: content }] : [];
+    if (!Array.isArray(content))
+        throw new BridgeError("Messages content must be text or an array.");
+    return content.flatMap((part) => {
+        if (["input_text", "output_text", "text"].includes(part.type)) {
+            return part.text ? [{ type: "text", text: part.text }] : [];
+        }
+        if (part.type === "input_image" || part.type === "image_url") {
+            const url = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
+            if (typeof url !== "string")
+                throw new BridgeError("An image needs an image_url.");
+            const data = /^data:(image\/(?:jpeg|png|gif|webp));base64,([\s\S]+)$/.exec(url);
+            if (data)
+                return [{ type: "image", source: { type: "base64", media_type: data[1], data: data[2] } }];
+            if (/^https?:\/\//.test(url))
+                return [{ type: "image", source: { type: "url", url } }];
+            throw new BridgeError("Messages images must use an HTTP URL or a JPEG, PNG, GIF, or WebP base64 data URL.");
+        }
+        if (part.type === "refusal")
+            return [{ type: "text", text: String(part.refusal ?? "") }];
+        throw new BridgeError(`Unsupported Messages content type: ${String(part.type)}.`);
+    });
+}
+function parseArguments(value) {
+    let parsed;
+    try {
+        parsed = typeof value === "string" ? JSON.parse(value) : value;
+    }
+    catch {
+        throw new BridgeError("A tool call contains invalid JSON arguments.");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new BridgeError("Messages tool arguments must be an object.");
+    }
+    return parsed;
+}
+function toolChoice(value, tools) {
+    if (value === undefined)
+        return undefined;
+    if (value === "auto")
+        return { type: "auto" };
+    if (value === "none")
+        return { type: "none" };
+    if (value === "required")
+        return { type: "any" };
+    if (value && ["function", "custom"].includes(value.type) && typeof value.name === "string") {
+        const selected = tools.get(value.namespace, value.name);
+        if (!selected || selected.kind !== value.type) {
+            throw new BridgeError("The selected tool is not available on the Messages backend.");
+        }
+        return { type: "tool", name: selected.flatName };
+    }
+    throw new BridgeError("Unsupported Messages tool_choice.");
+}
+/** Convert only request-owned copies; stored history remains unchanged. */
+export function buildAnthropicRequest(context) {
+    const { route } = context;
+    const request = normalizeToolDeclarations(context.request);
+    const tools = buildToolSet(request.tools);
+    const system = request.instructions ? [{ type: "text", text: request.instructions }] : [];
+    const messages = [];
+    const append = (role, blocks) => {
+        if (!blocks.length)
+            return;
+        const last = messages.at(-1);
+        if (last?.role === role)
+            last.content.push(...blocks);
+        else
+            messages.push({ role, content: blocks });
+    };
+    for (const item of prepareHistory(request.input, route)) {
+        if (item.type === "bridge_reasoning") {
+            const block = item.state.data;
+            if (!block || !["thinking", "redacted_thinking"].includes(block.type)) {
+                throw new BridgeError("Invalid Messages reasoning carrier.");
+            }
+            append("assistant", [block]);
+        }
+        else if (item.type === "function_call" || item.type === "custom_tool_call") {
+            append("assistant", [{
+                    type: "tool_use", id: safeCallId(item.call_id), name: tools.flatFor(item.namespace, item.name),
+                    input: item.type === "custom_tool_call" ? { input: item.input } : parseArguments(item.arguments),
+                }]);
+        }
+        else if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
+            const content = contentBlocks(item.output);
+            append("user", [{ type: "tool_result", tool_use_id: safeCallId(item.call_id), ...(content.length ? { content } : {}) }]);
+        }
+        else if (item.type === "message" || item.role) {
+            const blocks = contentBlocks(item.content);
+            if (item.role === "developer" || item.role === "system") {
+                if (blocks.some((block) => block.type !== "text"))
+                    throw new BridgeError("System messages must contain text.");
+                if (!messages.length)
+                    system.push(...blocks);
+                // Inline system roles have placement restrictions that arbitrary Responses
+                // history cannot satisfy. Keep reminders in order without rewriting a
+                // signed assistant prefix or moving new instructions to the beginning.
+                else
+                    append("user", [{ type: "text", text: `<system-reminder>\n${blocks.map((block) => block.text).join("\n\n")}\n</system-reminder>` }]);
+            }
+            else if (item.role === "assistant" || item.role === "user") {
+                append(item.role, blocks);
+            }
+            else
+                throw new BridgeError(`Unsupported Messages role: ${String(item.role)}.`);
+        }
+        else
+            throw new BridgeError(`Unsupported Messages history item: ${String(item.type)}.`);
+    }
+    const definitions = tools.entries.map((tool) => ({
+        name: tool.flatName, description: tool.description, input_schema: tool.parameters,
+    }));
+    // Keep stable prefixes at 1h. The one-off compaction suffix uses 5m.
+    const cache = (block, ttl = "1h") => {
+        if (block)
+            block.cache_control = { type: "ephemeral", ttl };
+    };
+    cache(definitions.at(-1));
+    cache(system.at(-1));
+    const userMessages = messages.filter((message) => message.role === "user");
+    for (const message of userMessages.slice(-2)) {
+        cache(message.content.at(-1), context.compacting && message === userMessages.at(-1) ? "5m" : "1h");
+    }
+    const effort = reasoningEffort(route, request.reasoning?.effort);
+    const body = {
+        thinking: effort === "none" ? { type: "disabled" } : {
+            type: "adaptive", display: reasoningSummaryRequested(request) ? "summarized" : "omitted",
+        },
+        ...(effort !== "none" ? { output_config: { effort } } : {}),
+        max_tokens: request.max_output_tokens ?? route.profile.max_output_tokens,
+    };
+    for (const name of ["temperature", "top_p"]) {
+        if (request[name] !== undefined)
+            body[name] = request[name];
+    }
+    let choice = toolChoice(request.tool_choice, tools);
+    if (tools.entries.length && typeof request.parallel_tool_calls === "boolean" && choice?.type !== "none") {
+        choice = { ...(choice ?? { type: "auto" }), disable_parallel_tool_use: !request.parallel_tool_calls };
+    }
+    if (choice)
+        body.tool_choice = choice;
+    const format = request.text?.format;
+    if (format !== undefined && format.type !== "text") {
+        if (format.type !== "json_schema")
+            throw new BridgeError(`Messages does not support text format ${String(format.type)}.`);
+        body.output_config = { ...body.output_config, format: { type: "json_schema", schema: format.schema } };
+    }
+    Object.assign(body, route.upstream.options, route.config.options, {
+        model: route.config.model, messages, stream: true,
+    });
+    if (system.length)
+        body.system = system;
+    else
+        delete body.system;
+    if (definitions.length)
+        body.tools = definitions;
+    else
+        delete body.tools;
+    if (context.compacting) {
+        if (body.output_config) {
+            body.output_config = { ...body.output_config };
+            delete body.output_config.format;
+        }
+    }
+    return { body, tools };
+}
+function tokenCount(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new BridgeError("Messages stream has invalid or missing token usage.", "upstream_error", 502);
+    }
+    return value;
+}
+function validateUsage(value, required) {
+    for (const field of required)
+        tokenCount(value?.[field]);
+    for (const field of ["input_tokens", "output_tokens", "cache_read_input_tokens", "cache_creation_input_tokens"]) {
+        if (value?.[field] !== undefined)
+            tokenCount(value[field]);
+    }
+    if (value?.output_tokens_details?.thinking_tokens !== undefined)
+        tokenCount(value.output_tokens_details.thinking_tokens);
+}
+export const runAnthropic = async (context, writer) => {
+    const { body, tools } = buildAnthropicRequest(context);
+    const response = await upstreamFetch(context.route, "/messages", body, context.signal, context.requestHeaders);
+    context.onAccepted?.(response.headers);
+    if (!response.body)
+        throw new BridgeError("Messages returned an empty stream.", "upstream_error", 502);
+    const blocks = new Map();
+    let rawUsage = {};
+    let started = false;
+    let finalUsage = false;
+    let stopReason;
+    let stopped = false;
+    for await (const { json: event } of parseJsonSse(response.body)) {
+        if (event.type === "error")
+            throw upstreamError(undefined, event, response.headers);
+        if (event.type === "ping") {
+            writer.keepalive();
+            continue;
+        }
+        if (event.type === "message_start") {
+            validateUsage(event.message?.usage, ["input_tokens", "output_tokens"]);
+            started = true;
+            rawUsage = { ...rawUsage, ...event.message?.usage };
+        }
+        else if (event.type === "content_block_start") {
+            const value = { ...event.content_block };
+            if (!["text", "thinking", "redacted_thinking", "tool_use"].includes(value.type)) {
+                throw new BridgeError(`Unsupported Messages output block: ${String(value.type)}.`);
+            }
+            blocks.set(event.index, { value, json: "" });
+            if (value.type === "text" && value.text)
+                writer.textDelta(value.text);
+            if (value.type === "thinking")
+                writer.reasoningDelta(value.thinking ?? "");
+        }
+        else if (event.type === "content_block_delta") {
+            const block = blocks.get(event.index);
+            if (!block)
+                throw new BridgeError("Messages sent a delta before its block.", "upstream_error", 502);
+            const delta = event.delta;
+            if (delta.type === "text_delta") {
+                block.value.text = (block.value.text ?? "") + delta.text;
+                writer.textDelta(delta.text);
+            }
+            else if (delta.type === "thinking_delta") {
+                block.value.thinking = (block.value.thinking ?? "") + delta.thinking;
+                writer.reasoningDelta(delta.thinking);
+            }
+            else if (delta.type === "signature_delta") {
+                block.value.signature = (block.value.signature ?? "") + delta.signature;
+            }
+            else if (delta.type === "input_json_delta")
+                block.json += delta.partial_json;
+            else if (delta.type !== "citations_delta")
+                throw new BridgeError(`Unsupported Messages delta: ${String(delta.type)}.`);
+        }
+        else if (event.type === "content_block_stop") {
+            const block = blocks.get(event.index);
+            if (!block)
+                throw new BridgeError("Messages stopped an unknown block.", "upstream_error", 502);
+            if (block.value.type === "thinking" || block.value.type === "redacted_thinking") {
+                writer.endReasoning(encodeReasoning({ source: context.route.origin, format: context.route.profile.reasoning_format, data: block.value }));
+            }
+            else if (block.value.type === "tool_use") {
+                if (block.json)
+                    block.value.input = parseArguments(block.json);
+                const call = block.value;
+                const tool = tools.resolve(call.name);
+                if (!tool)
+                    throw new BridgeError(`Messages called an unknown tool: ${String(call.name)}.`);
+                if (tool.kind === "custom") {
+                    if (typeof call.input?.input !== "string")
+                        throw new BridgeError("A custom tool call needs a string input.");
+                    writer.addCustomToolCall({ call_id: call.id, name: tool.name, namespace: tool.namespace, input: call.input.input });
+                }
+                else
+                    writer.addFunctionCall({ call_id: call.id, name: tool.name, namespace: tool.namespace, arguments: JSON.stringify(call.input ?? {}) });
+            }
+            else if (block.value.type === "text")
+                writer.closeMessage();
+            blocks.delete(event.index);
+        }
+        else if (event.type === "message_delta") {
+            stopReason = event.delta?.stop_reason ?? stopReason;
+            validateUsage(event.usage, ["output_tokens"]);
+            finalUsage = true;
+            rawUsage = { ...rawUsage, ...event.usage };
+        }
+        else if (event.type === "message_stop")
+            stopped = true;
+    }
+    if (!started || !stopped || blocks.size || !stopReason) {
+        throw new BridgeError("Messages stream ended before the message was complete.", "upstream_error", 502);
+    }
+    if (stopReason === "model_context_window_exceeded") {
+        throw new BridgeError("Messages reached the model context window before completing the response.", "context_length_exceeded");
+    }
+    if (stopReason === "max_tokens" || stopReason === "refusal") {
+        throw new BridgeError(stopReason === "max_tokens" ? "Messages reached max_tokens before completing the response." : "Messages refused the request.");
+    }
+    if (!["end_turn", "stop_sequence", "tool_use", "pause_turn"].includes(stopReason)) {
+        throw new BridgeError(`Unsupported Messages stop reason: ${stopReason}.`);
+    }
+    if (!finalUsage)
+        throw new BridgeError("Messages stream ended without final token usage.", "upstream_error", 502);
+    const usage = {
+        input_tokens: tokenCount(rawUsage.input_tokens + (rawUsage.cache_read_input_tokens ?? 0) + (rawUsage.cache_creation_input_tokens ?? 0)),
+        cached_tokens: rawUsage.cache_read_input_tokens ?? 0,
+        cache_write_tokens: rawUsage.cache_creation_input_tokens ?? 0,
+        output_tokens: tokenCount(rawUsage.output_tokens),
+        ...(rawUsage.output_tokens_details?.thinking_tokens != null ? { reasoning_tokens: rawUsage.output_tokens_details.thinking_tokens } : {}),
+    };
+    return {
+        usage,
+        endTurn: stopReason !== "tool_use" && stopReason !== "pause_turn",
+    };
+};

package/dist/backends/chat.d.ts

@@ -0,0 +1,16 @@
+import { BridgeError } from "../errors.ts";
+import type { ToolSet } from "../tools.ts";
+import type { BackendContext, BackendResult } from "../types.ts";
+import type { ResponseWriter, Usage } from "../writer.ts";
+/** A wire dialect supplies only the parts that differ from Chat Completions. */
+export interface ChatDialect {
+    reasoningField: string;
+    requestParameters(context: BackendContext): Record<string, unknown>;
+    readUsage(value: any): Usage;
+    failureReason(reason: string): BridgeError | undefined;
+}
+export declare function buildChatRequest(context: BackendContext, dialect: ChatDialect): {
+    body: Record<string, any>;
+    tools: ToolSet;
+};
+export declare function runChat(context: BackendContext, writer: ResponseWriter, dialect: ChatDialect): Promise<BackendResult>;

package/dist/backends/chat.js

@@ -0,0 +1,284 @@
+import { encodeReasoning } from "../carrier.js";
+import { BridgeError, transportError, upstreamError } from "../errors.js";
+import { prepareHistory } from "../history.js";
+import { parseJsonSse } from "../sse.js";
+import { buildToolSet, normalizeToolDeclarations } from "../tools.js";
+import { upstreamFetch } from "../upstream.js";
+function contentParts(content) {
+    if (typeof content === "string")
+        return [{ type: "text", text: content }];
+    if (!Array.isArray(content))
+        throw new BridgeError("Chat message content must be text or a content array.");
+    return content.map((part) => {
+        if (["input_text", "output_text", "text"].includes(part?.type) && typeof part.text === "string") {
+            return { type: "text", text: part.text };
+        }
+        if (part?.type === "refusal" && typeof part.refusal === "string")
+            return { type: "text", text: part.refusal };
+        if (part?.type === "input_image" && typeof part.image_url === "string") {
+            if (!/^(https?:\/\/|data:image\/)/.test(part.image_url)) {
+                throw new BridgeError("Chat images require an HTTP(S) URL or an image data URL.");
+            }
+            return { type: "image_url", image_url: {
+                    url: part.image_url,
+                    ...(part.detail ? { detail: part.detail === "original" ? "high" : part.detail } : {}),
+                } };
+        }
+        throw new BridgeError(`Chat does not support content part ${String(part?.type)}.`);
+    });
+}
+function messageContent(parts) {
+    return parts.every((p) => p.type === "text") ? parts.map((p) => p.text).join("\n") : parts;
+}
+function convertHistory(context, tools, reasoningField) {
+    const messages = [];
+    let assistant;
+    let pendingImages = [];
+    const flushAssistant = () => {
+        if (assistant)
+            messages.push(assistant);
+        assistant = undefined;
+    };
+    const flushImages = () => {
+        if (pendingImages.length)
+            messages.push({ role: "user", content: pendingImages });
+        pendingImages = [];
+    };
+    const getAssistant = () => assistant ??= { role: "assistant", content: "", [reasoningField]: "" };
+    if (context.request.instructions)
+        messages.push({ role: "system", content: context.request.instructions });
+    for (const item of prepareHistory(context.request.input, context.route)) {
+        if (item.type === "bridge_reasoning") {
+            flushImages();
+            // A reasoning item starts the next assistant response, even if the
+            // previous response ended without a tool or user message.
+            flushAssistant();
+            if (typeof item.state.data !== "string")
+                throw new BridgeError("Invalid Chat reasoning data.");
+            getAssistant()[reasoningField] = item.state.data;
+        }
+        else if (item.type === "message" || (!item.type && item.role)) {
+            const parts = contentParts(item.content);
+            if (item.role === "assistant") {
+                flushImages();
+                if (parts.some((p) => p.type !== "text"))
+                    throw new BridgeError("Chat assistant history cannot contain images.");
+                const a = getAssistant();
+                const text = messageContent(parts);
+                a.content += (a.content && text ? "\n" : "") + text;
+            }
+            else {
+                flushAssistant();
+                flushImages();
+                if (!["system", "developer", "user"].includes(item.role)) {
+                    throw new BridgeError(`Chat does not support message role ${String(item.role)}.`);
+                }
+                if (item.role !== "user" && parts.some((p) => p.type !== "text")) {
+                    throw new BridgeError("Chat system and developer messages must contain text only.");
+                }
+                messages.push({ role: item.role === "developer" ? "system" : item.role, content: messageContent(parts) });
+            }
+        }
+        else if (item.type === "function_call" || item.type === "custom_tool_call") {
+            flushImages();
+            if (typeof item.call_id !== "string" || typeof item.name !== "string")
+                throw new BridgeError("Invalid Chat tool call history.");
+            const a = getAssistant();
+            a.tool_calls ??= [];
+            a.tool_calls.push({
+                id: item.call_id, type: "function", function: {
+                    name: tools.flatFor(item.namespace, item.name),
+                    arguments: item.type === "custom_tool_call" ? JSON.stringify({ input: item.input }) : item.arguments,
+                },
+            });
+        }
+        else if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
+            flushAssistant();
+            if (typeof item.call_id !== "string")
+                throw new BridgeError("Chat tool output has no call_id.");
+            const parts = contentParts(item.output);
+            const images = parts.filter((p) => p.type === "image_url");
+            messages.push({ role: "tool", tool_call_id: item.call_id, content: messageContent(parts.filter((p) => p.type === "text")) });
+            if (images.length) {
+                pendingImages.push({ type: "text", text: `Images from tool call ${item.call_id}:` }, ...images);
+            }
+        }
+        else {
+            throw new BridgeError(`Chat does not support history item ${String(item.type)}.`);
+        }
+    }
+    flushAssistant();
+    flushImages();
+    return messages;
+}
+function toolChoice(choice, tools) {
+    if (choice === undefined)
+        return undefined;
+    if (["auto", "none", "required"].includes(choice))
+        return choice;
+    if (choice && typeof choice === "object") {
+        const selected = choice;
+        if (["function", "custom"].includes(selected.type) && typeof selected.name === "string") {
+            const tool = tools.get(selected.namespace, selected.name);
+            if (!tool || tool.kind !== selected.type) {
+                throw new BridgeError("The selected tool is not available on the Chat backend.");
+            }
+            return { type: "function", function: { name: tool.flatName } };
+        }
+    }
+    throw new BridgeError("Chat does not support this tool_choice.");
+}
+export function buildChatRequest(context, dialect) {
+    context = { ...context, request: normalizeToolDeclarations(context.request) };
+    const { request, route } = context;
+    const tools = buildToolSet(request.tools);
+    const body = { ...dialect.requestParameters(context) };
+    const limit = request.max_output_tokens ?? route.profile.max_output_tokens;
+    if (limit !== undefined)
+        body.max_tokens = limit;
+    for (const name of ["temperature", "top_p", "parallel_tool_calls"]) {
+        if (request[name] !== undefined)
+            body[name] = request[name];
+    }
+    const choice = toolChoice(request.tool_choice, tools);
+    if (choice !== undefined)
+        body.tool_choice = choice;
+    const format = request.text?.format;
+    if (format?.type === "json_object")
+        body.response_format = { type: "json_object" };
+    else if (format?.type === "json_schema") {
+        body.response_format = { type: "json_schema", json_schema: { name: format.name, schema: format.schema, strict: format.strict } };
+    }
+    else if (format && format.type !== "text")
+        throw new BridgeError(`Chat does not support text format ${String(format.type)}.`);
+    Object.assign(body, route.upstream.options, route.config.options, {
+        model: route.config.model,
+        messages: convertHistory(context, tools, dialect.reasoningField),
+        stream: true,
+    });
+    body.stream_options = { ...body.stream_options, include_usage: true };
+    if (tools.entries.length)
+        body.tools = tools.entries.map((tool) => ({
+            type: "function", function: { name: tool.flatName, description: tool.description, parameters: tool.parameters },
+        }));
+    else
+        delete body.tools;
+    if (context.compacting) {
+        delete body.response_format;
+    }
+    return { body, tools };
+}
+async function* chatEvents(body, signal) {
+    try {
+        yield* parseJsonSse(body);
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw signal.reason;
+        throw transportError(error);
+    }
+}
+export async function runChat(context, writer, dialect) {
+    const { body, tools } = buildChatRequest(context, dialect);
+    const { reasoningField } = dialect;
+    const response = await upstreamFetch(context.route, "chat/completions", body, context.signal, context.requestHeaders);
+    context.onAccepted?.(response.headers);
+    if (!response.body)
+        throw new BridgeError("Chat upstream returned no stream.", "upstream_error", 502);
+    let reasoning = "";
+    let reasoningSeen = false;
+    let reasoningClosed = false;
+    let finish;
+    let usage;
+    let visible = false;
+    const calls = new Map();
+    const closeReasoning = () => {
+        if (reasoningSeen && !reasoningClosed) {
+            writer.endReasoning(encodeReasoning({ source: context.route.origin, format: context.route.profile.reasoning_format, data: reasoning }));
+            reasoningClosed = true;
+        }
+    };
+    for await (const { json } of chatEvents(response.body, context.signal)) {
+        if (json.error)
+            throw upstreamError(undefined, json, response.headers);
+        if (json.usage)
+            usage = dialect.readUsage(json.usage);
+        for (const choice of json.choices ?? []) {
+            if (choice.index !== 0)
+                throw new BridgeError("Chat returned more than one completion.", "upstream_error", 502);
+            if (choice.finish_reason)
+                finish = choice.finish_reason;
+            const delta = choice.delta ?? {};
+            if (delta.refusal)
+                throw new BridgeError(String(delta.refusal));
+            if (delta[reasoningField] !== undefined && delta[reasoningField] !== null) {
+                if (typeof delta[reasoningField] !== "string" || reasoningClosed)
+                    throw new BridgeError("Chat returned unsupported reasoning ordering or content.", "upstream_error", 502);
+                reasoningSeen = true;
+                reasoning += delta[reasoningField];
+                writer.reasoningDelta(delta[reasoningField]);
+            }
+            if (delta.content !== undefined && delta.content !== null && delta.content !== "") {
+                if (typeof delta.content !== "string")
+                    throw new BridgeError("Chat returned non-text output.", "upstream_error", 502);
+                closeReasoning();
+                writer.textDelta(delta.content);
+                visible = true;
+            }
+            for (const part of delta.tool_calls ?? []) {
+                if (!Number.isInteger(part.index) || part.index < 0 || (part.type && part.type !== "function")) {
+                    throw new BridgeError("Chat returned an invalid tool call.", "upstream_error", 502);
+                }
+                const call = calls.get(part.index) ?? { id: "", name: "", arguments: "" };
+                if (part.id)
+                    call.id += part.id;
+                if (part.function?.name)
+                    call.name += part.function.name;
+                if (part.function?.arguments)
+                    call.arguments += part.function.arguments;
+                calls.set(part.index, call);
+            }
+        }
+    }
+    if (!finish)
+        throw new BridgeError("Chat stream ended before a finish_reason.", "upstream_error", 502);
+    if (finish === "length")
+        throw new BridgeError("Chat output reached its token limit; increase max_output_tokens.");
+    const failure = dialect.failureReason(finish);
+    if (failure)
+        throw failure;
+    if (finish !== "stop" && finish !== "tool_calls")
+        throw new BridgeError(`Chat stopped with ${finish}.`);
+    if (!usage)
+        throw new BridgeError("Chat stream ended without token usage.", "upstream_error", 502);
+    if (finish === "tool_calls" && !calls.size)
+        throw new BridgeError("Chat ended with tool_calls but returned no calls.", "upstream_error", 502);
+    if (!visible && !calls.size)
+        throw new BridgeError("Chat returned no text or tool calls.", "upstream_error", 502);
+    closeReasoning();
+    // Validate every call before exposing any of them for execution.
+    const completed = [...calls.entries()].sort(([a], [b]) => a - b).map(([, call]) => {
+        const tool = tools.resolve(call.name);
+        if (!tool || !call.id)
+            throw new BridgeError("Chat returned an unknown or incomplete tool call.", "upstream_error", 502);
+        let args;
+        try {
+            args = JSON.parse(call.arguments);
+        }
+        catch {
+            throw new BridgeError("Chat returned invalid tool arguments.", "upstream_error", 502);
+        }
+        if (!args || typeof args !== "object" || Array.isArray(args))
+            throw new BridgeError("Chat tool arguments must be an object.", "upstream_error", 502);
+        if (tool.kind === "custom" && typeof args.input !== "string")
+            throw new BridgeError("Chat custom tool call has no string input.", "upstream_error", 502);
+        return { call, tool, args };
+    });
+    for (const { call, tool, args } of completed) {
+        if (tool.kind === "custom")
+            writer.addCustomToolCall({ call_id: call.id, name: tool.name, namespace: tool.namespace, input: args.input });
+        else
+            writer.addFunctionCall({ call_id: call.id, name: tool.name, namespace: tool.namespace, arguments: call.arguments });
+    }
+    return { usage, endTurn: calls.size === 0 };
+}

package/dist/backends/deepseek.d.ts

@@ -0,0 +1,6 @@
+import type { Backend, BackendContext } from "../types.ts";
+export declare function buildDeepSeekRequest(context: BackendContext): {
+    body: Record<string, any>;
+    tools: import("../tools.ts").ToolSet;
+};
+export declare const runDeepSeek: Backend;