clauderipple 0.2.0

package/dist/router/src/providers/openai/translate.js

@@ -0,0 +1,504 @@
+// Anthropic Messages ⇄ OpenAI-compatible Chat Completions / Responses. Pure translation
+// and streaming mapping. The generated prefix is deterministic so vendors that cache a
+// stable prompt prefix can retain their native prompt-cache behavior.
+import crypto from "node:crypto";
+import { clampEffort } from "../../compat.js";
+import { conversationKey, estimateTokens, normalizeSchema, systemText } from "../chatgpt/translate.js";
+import { identityPrefix, instructionsSuffix } from "../../identity.js";
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .flatMap((block) => block.type === "text" ? [String(block.text ?? "")] : block.type === "image" ? ["[image omitted]"] : [])
+        .filter((text) => text.length > 0)
+        .join("\n");
+}
+function imageUrl(block) {
+    const source = block.source;
+    if (!source || typeof source !== "object")
+        return null;
+    if (source.type === "base64" && typeof source.data === "string")
+        return `data:${typeof source.media_type === "string" ? source.media_type : "image/png"};base64,${source.data}`;
+    if (source.type === "url" && typeof source.url === "string")
+        return source.url;
+    return null;
+}
+function functionTools(tools) {
+    return (tools ?? [])
+        .filter((tool) => typeof tool.name === "string")
+        .map((tool) => ({ type: "function", function: { name: tool.name, description: tool.description ?? "", parameters: normalizeSchema(tool.input_schema) } }));
+}
+function mapToolChoice(req, tools) {
+    if (!tools.length)
+        return undefined;
+    const choice = req.tool_choice;
+    if (!choice || choice.type === "auto")
+        return "auto";
+    if (choice.type === "any")
+        return "required";
+    if (choice.type === "none")
+        return "none";
+    return choice.type === "tool" && choice.name ? { type: "function", function: { name: choice.name } } : undefined;
+}
+function mapResponsesToolChoice(req, tools) {
+    if (!tools.length)
+        return undefined;
+    const choice = req.tool_choice;
+    if (!choice || choice.type === "auto")
+        return "auto";
+    if (choice.type === "any")
+        return "required";
+    if (choice.type === "none")
+        return "none";
+    return choice.type === "tool" && choice.name ? { type: "function", name: choice.name } : undefined;
+}
+/** The system text this provider should see: what it is, the caller's prompt, the configured addendum. */
+function systemWithIdentity(sys, opts) {
+    // The effort named is the one that survives the capability mapping; a provider that takes no
+    // reasoning effort is told none, rather than a level it will never see.
+    return [identityPrefix({ model: opts.model, effort: mappedEffort(opts), identity: opts.identity }), sys, instructionsSuffix({ model: opts.model, instructionsAppend: opts.instructionsAppend })]
+        .filter(Boolean)
+        .join("\n\n");
+}
+function mappedEffort(opts) {
+    if (opts.caps?.reasoning !== "effort" || !opts.effort)
+        return undefined;
+    const levels = opts.caps.effortLevels;
+    return levels && levels.length > 0 ? clampEffort(opts.effort, levels) : opts.effort;
+}
+/** Convert every Anthropic message into OpenAI Chat Completion messages without inventing unstable text. */
+export function toChatMessages(req, opts) {
+    const messages = [];
+    const sys = systemText(req.system);
+    const content = opts ? systemWithIdentity(sys, opts) : sys;
+    if (content)
+        messages.push({ role: "system", content });
+    const knownCalls = new Set();
+    for (const message of req.messages) {
+        const role = message.role === "assistant" ? "assistant" : "user";
+        if (typeof message.content === "string") {
+            if (message.content)
+                messages.push({ role, content: message.content });
+            continue;
+        }
+        if (!Array.isArray(message.content))
+            continue;
+        if (role === "assistant") {
+            const text = [];
+            const calls = [];
+            for (const block of message.content) {
+                if (block.type === "text")
+                    text.push(String(block.text ?? ""));
+                if (block.type === "tool_use") {
+                    const call = block;
+                    knownCalls.add(call.id);
+                    calls.push({ id: call.id, type: "function", function: { name: call.name, arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}) } });
+                }
+            }
+            if (text.some(Boolean) || calls.length)
+                messages.push({ role: "assistant", content: text.join("\n") || null, ...(calls.length ? { tool_calls: calls } : {}) });
+            continue;
+        }
+        let parts = [];
+        const flush = () => {
+            if (!parts.length)
+                return;
+            const onlyText = parts.every((part) => part.type === "text");
+            messages.push({ role: "user", content: onlyText ? parts.map((part) => part.text).join("\n") : parts });
+            parts = [];
+        };
+        for (const block of message.content) {
+            if (block.type === "text") {
+                const text = String(block.text ?? "");
+                if (text)
+                    parts.push({ type: "text", text });
+            }
+            else if (block.type === "image") {
+                const url = imageUrl(block);
+                if (url)
+                    parts.push({ type: "image_url", image_url: { url } });
+            }
+            else if (block.type === "tool_result") {
+                flush();
+                const result = block;
+                let output = textOf(result.content);
+                if (result.is_error && !output)
+                    output = "Tool execution failed";
+                if (knownCalls.has(result.tool_use_id))
+                    messages.push({ role: "tool", tool_call_id: result.tool_use_id, content: output });
+                else
+                    parts.push({ type: "text", text: `[Tool result]\n${output}` });
+            }
+        }
+        flush();
+    }
+    return messages;
+}
+/** Translate to the stateless OpenAI Responses input grammar. */
+export function toResponsesInput(req) {
+    const input = [];
+    const knownCalls = new Set();
+    for (const message of req.messages) {
+        const role = message.role === "assistant" ? "assistant" : "user";
+        if (typeof message.content === "string") {
+            if (message.content)
+                input.push({ type: "message", role, content: [{ type: role === "user" ? "input_text" : "output_text", text: message.content }] });
+            continue;
+        }
+        if (!Array.isArray(message.content))
+            continue;
+        let parts = [];
+        const flush = () => {
+            if (parts.length)
+                input.push({ type: "message", role, content: parts });
+            parts = [];
+        };
+        for (const block of message.content) {
+            if (block.type === "text") {
+                const text = String(block.text ?? "");
+                if (text)
+                    parts.push({ type: role === "user" ? "input_text" : "output_text", text });
+            }
+            else if (block.type === "image" && role === "user") {
+                const url = imageUrl(block);
+                if (url)
+                    parts.push({ type: "input_image", image_url: url });
+            }
+            else if (block.type === "tool_use") {
+                flush();
+                const call = block;
+                knownCalls.add(call.id);
+                input.push({ type: "function_call", call_id: call.id, name: call.name, arguments: typeof call.input === "string" ? call.input : JSON.stringify(call.input ?? {}) });
+            }
+            else if (block.type === "tool_result") {
+                flush();
+                const result = block;
+                let output = textOf(result.content);
+                if (result.is_error && !output)
+                    output = "Tool execution failed";
+                if (knownCalls.has(result.tool_use_id))
+                    input.push({ type: "function_call_output", call_id: result.tool_use_id, output });
+                else
+                    parts.push({ type: "input_text", text: `[Tool result]\n${output}` });
+            }
+        }
+        flush();
+    }
+    return input;
+}
+export function toOpenAiRequest(req, opts) {
+    const effort = mappedEffort(opts);
+    const tools = functionTools(req.tools);
+    const parallel = !(req.tool_choice?.disable_parallel_tool_use ?? false);
+    if (opts.wire === "chat") {
+        const out = {
+            model: opts.model,
+            messages: toChatMessages(req, opts),
+            stream: true,
+            stream_options: { include_usage: true },
+        };
+        if (tools.length) {
+            out.tools = tools;
+            out.parallel_tool_calls = parallel;
+            const choice = mapToolChoice(req, tools);
+            if (choice)
+                out.tool_choice = choice;
+        }
+        if (typeof req.max_tokens === "number")
+            out.max_tokens = req.max_tokens;
+        if (typeof req.temperature === "number")
+            out.temperature = req.temperature;
+        if (Array.isArray(req.stop_sequences) && req.stop_sequences.every((value) => typeof value === "string"))
+            out.stop = req.stop_sequences;
+        if (effort)
+            out.reasoning_effort = effort;
+        return out;
+    }
+    const responseTools = tools.map(({ function: fn }) => ({ type: "function", ...fn }));
+    const out = {
+        model: opts.model,
+        input: toResponsesInput(req),
+        stream: true,
+    };
+    const instructions = systemWithIdentity(systemText(req.system), opts);
+    if (instructions)
+        out.instructions = instructions;
+    if (responseTools.length) {
+        out.tools = responseTools;
+        out.parallel_tool_calls = parallel;
+        const choice = mapResponsesToolChoice(req, responseTools);
+        if (choice)
+            out.tool_choice = choice;
+    }
+    if (typeof req.max_tokens === "number")
+        out.max_output_tokens = req.max_tokens;
+    if (typeof req.temperature === "number")
+        out.temperature = req.temperature;
+    if (effort)
+        out.reasoning = { effort };
+    return out;
+}
+export { conversationKey, estimateTokens };
+/** Maps standard OpenAI Chat Completion and Responses SSE records to Anthropic Messages SSE. */
+export class OpenAiStreamMapper {
+    started = false;
+    finished = false;
+    blockIndex = -1;
+    open = null;
+    sawTool = false;
+    finishReason;
+    responseItems = [];
+    responseItemsById = new Map();
+    messageId = `msg_${crypto.randomBytes(12).toString("hex")}`;
+    content = [];
+    usage = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 };
+    stopReason = "end_turn";
+    model;
+    startInput;
+    constructor(model, startInput = 0) {
+        this.model = model;
+        this.startInput = startInput;
+    }
+    get isFinished() { return this.finished; }
+    start() {
+        if (this.started)
+            return [];
+        this.started = true;
+        return [{ event: "message_start", data: { type: "message_start", message: { id: this.messageId, type: "message", role: "assistant", model: this.model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: this.startInput, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } } } }];
+    }
+    closeBlock() {
+        if (!this.open)
+            return [];
+        const index = this.open.index;
+        this.open = null;
+        return [{ event: "content_block_stop", data: { type: "content_block_stop", index } }];
+    }
+    openBlock(kind, contentBlock, toolIndex) {
+        const out = this.closeBlock();
+        const index = ++this.blockIndex;
+        this.open = { kind, index, ...(toolIndex === undefined ? {} : { toolIndex }) };
+        out.push({ event: "content_block_start", data: { type: "content_block_start", index, content_block: contentBlock } });
+        return out;
+    }
+    setUsage(value) {
+        if (!value || typeof value !== "object")
+            return;
+        const usage = value;
+        const input = typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : typeof usage.input_tokens === "number" ? usage.input_tokens : undefined;
+        const output = typeof usage.completion_tokens === "number" ? usage.completion_tokens : typeof usage.output_tokens === "number" ? usage.output_tokens : undefined;
+        if (input === undefined && output === undefined)
+            return;
+        const cachedValue = usage.prompt_tokens_details?.cached_tokens ?? usage.input_tokens_details?.cached_tokens;
+        const cached = typeof cachedValue === "number" && Number.isFinite(cachedValue) ? Math.max(0, cachedValue) : 0;
+        this.usage = { input_tokens: Math.max(0, (input ?? this.usage.input_tokens + cached) - cached), output_tokens: Math.max(0, output ?? this.usage.output_tokens), cache_read_input_tokens: cached, cache_creation_input_tokens: 0 };
+    }
+    toolFor(index, delta) {
+        let tool = this.content.find((block) => block.type === "tool_use" && block.index === index);
+        if (!tool) {
+            const id = typeof delta.id === "string" ? delta.id : `call_${crypto.randomBytes(8).toString("hex")}`;
+            const name = typeof delta.function?.name === "string" ? delta.function.name : "tool";
+            tool = { type: "tool_use", id, name, input: {}, args: "", index };
+            this.content.push(tool);
+            this.sawTool = true;
+        }
+        if (typeof delta.id === "string")
+            tool.id = delta.id;
+        if (typeof delta.function?.name === "string")
+            tool.name = delta.function.name;
+        return tool;
+    }
+    feedChat(ev) {
+        const out = [...this.start()];
+        const usage = ev.usage;
+        if (usage)
+            this.setUsage(usage);
+        const choices = Array.isArray(ev.choices) ? ev.choices : [];
+        for (const choice of choices) {
+            const delta = choice.delta ?? {};
+            if (typeof delta.content === "string" && delta.content) {
+                if (!this.open || this.open.kind !== "text") {
+                    this.content.push({ type: "text", text: "" });
+                    out.push(...this.openBlock("text", { type: "text", text: "" }));
+                }
+                const last = this.content[this.content.length - 1];
+                if (last?.type === "text")
+                    last.text += delta.content;
+                out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "text_delta", text: delta.content } } });
+            }
+            if (Array.isArray(delta.tool_calls)) {
+                for (const raw of delta.tool_calls) {
+                    if (!raw || typeof raw !== "object")
+                        continue;
+                    const call = raw;
+                    const index = typeof call.index === "number" ? call.index : 0;
+                    const tool = this.toolFor(index, call);
+                    if (!this.open || this.open.kind !== "tool" || this.open.toolIndex !== index)
+                        out.push(...this.openBlock("tool", { type: "tool_use", id: tool.id, name: tool.name, input: {} }, index));
+                    const args = call.function?.arguments;
+                    if (typeof args === "string" && args) {
+                        tool.args += args;
+                        out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "input_json_delta", partial_json: args } } });
+                    }
+                }
+            }
+            if (typeof choice.finish_reason === "string" && choice.finish_reason)
+                this.finishReason = choice.finish_reason;
+        }
+        return out;
+    }
+    responseItem(id, kind) {
+        if (typeof id === "string")
+            return this.responseItemsById.get(id);
+        // Standard Responses SSE includes item_id. A few compatible servers omit it for
+        // a single in-flight item; support only the unambiguous form, never guess across
+        // parallel calls.
+        const candidates = this.responseItems.filter((item) => !item.done && (!kind || item.kind === kind));
+        return candidates.length === 1 ? candidates[0] : undefined;
+    }
+    flushResponses() {
+        const out = [];
+        for (const item of this.responseItems) {
+            if (item.emitted) {
+                if (!item.done)
+                    break;
+                if (!item.closed) {
+                    out.push(...this.closeBlock());
+                    item.closed = true;
+                }
+                continue;
+            }
+            if (item.kind === "text") {
+                const text = item.block;
+                out.push(...this.openBlock("text", { type: "text", text: "" }));
+                if (text.text) {
+                    out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "text_delta", text: text.text } } });
+                }
+                item.emittedText = text.text.length;
+                item.emitted = true;
+                if (!item.done)
+                    break;
+                out.push(...this.closeBlock());
+                item.closed = true;
+                continue;
+            }
+            const tool = item.block;
+            out.push(...this.openBlock("tool", { type: "tool_use", id: tool.id, name: tool.name, input: {} }, tool.index));
+            if (tool.args) {
+                out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "input_json_delta", partial_json: tool.args } } });
+            }
+            item.emittedText = tool.args.length;
+            item.emitted = true;
+            if (!item.done)
+                break;
+            out.push(...this.closeBlock());
+            item.closed = true;
+        }
+        return out;
+    }
+    feedResponses(ev) {
+        const out = [...this.start()];
+        const type = typeof ev.type === "string" ? ev.type : "";
+        if (type === "response.output_item.added") {
+            const item = ev.item;
+            const id = typeof item?.id === "string" ? item.id : undefined;
+            if (id && item?.type === "message") {
+                const block = { type: "text", text: "" };
+                this.content.push(block);
+                const responseItem = { id, kind: "text", block, done: false, emitted: false, closed: false, emittedText: 0 };
+                this.responseItems.push(responseItem);
+                this.responseItemsById.set(id, responseItem);
+            }
+            else if (id && item?.type === "function_call") {
+                const index = this.content.filter((block) => block.type === "tool_use").length;
+                const tool = this.toolFor(index, { id: item.call_id ?? item.id, function: { name: item.name } });
+                const responseItem = { id, kind: "tool", block: tool, done: false, emitted: false, closed: false, emittedText: 0 };
+                this.responseItems.push(responseItem);
+                this.responseItemsById.set(id, responseItem);
+            }
+        }
+        else if (type === "response.output_text.delta") {
+            const text = typeof ev.delta === "string" ? ev.delta : "";
+            const item = this.responseItem(ev.item_id, "text");
+            if (item?.kind === "text" && text) {
+                const block = item.block;
+                block.text += text;
+                if (item.emitted && this.open?.kind === "text") {
+                    out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "text_delta", text } } });
+                    item.emittedText += text.length;
+                }
+            }
+        }
+        else if (type === "response.function_call_arguments.delta") {
+            const text = typeof ev.delta === "string" ? ev.delta : "";
+            const item = this.responseItem(ev.item_id, "tool");
+            if (item?.kind === "tool" && text) {
+                const tool = item.block;
+                tool.args += text;
+                if (item.emitted && this.open?.kind === "tool" && this.open.toolIndex === tool.index) {
+                    out.push({ event: "content_block_delta", data: { type: "content_block_delta", index: this.open.index, delta: { type: "input_json_delta", partial_json: text } } });
+                    item.emittedText += text.length;
+                }
+            }
+        }
+        else if (type === "response.output_item.done") {
+            const item = this.responseItem(ev.item_id ?? ev.item?.id);
+            if (item)
+                item.done = true;
+        }
+        else if (type === "response.completed" || type === "response.incomplete") {
+            const response = ev.response;
+            this.setUsage(response?.usage);
+            if (response?.incomplete_details?.reason === "max_output_tokens")
+                this.finishReason = "length";
+        }
+        else if (type === "response.failed" || type === "error") {
+            const error = (type === "error" ? ev.error : ev.response?.error);
+            return [...out, ...this.fail(typeof error?.message === "string" ? error.message : "upstream response failed", typeof error?.code === "string" ? error.code : undefined)];
+        }
+        out.push(...this.flushResponses());
+        return out;
+    }
+    feed(ev, wire) {
+        if (this.finished)
+            return [];
+        // Some OpenAI-compatible servers emit an ordinary `{error:{...}}` JSON SSE payload
+        // instead of the Responses `error` event shape. Do not finish it as a successful answer.
+        if (ev.error && typeof ev.error === "object") {
+            const error = ev.error;
+            return [...this.start(), ...this.fail(typeof error.message === "string" ? error.message : "upstream error", typeof error.code === "string" ? error.code : undefined)];
+        }
+        return wire === "chat" ? this.feedChat(ev) : this.feedResponses(ev);
+    }
+    finish() {
+        if (this.finished)
+            return [];
+        this.finished = true;
+        this.stopReason = this.sawTool || this.finishReason === "tool_calls" ? "tool_use" : this.finishReason === "length" || this.finishReason === "max_output_tokens" ? "max_tokens" : "end_turn";
+        return [...this.start(), ...this.closeBlock(), { event: "message_delta", data: { type: "message_delta", delta: { stop_reason: this.stopReason, stop_sequence: null }, usage: this.usage } }, { event: "message_stop", data: { type: "message_stop" } }];
+    }
+    fail(message, code) {
+        if (this.finished)
+            return [];
+        this.finished = true;
+        const type = code === "rate_limit_exceeded" ? "rate_limit_error" : "api_error";
+        return [...this.start(), ...this.closeBlock(), { event: "error", data: { type: "error", error: { type, message } } }];
+    }
+    message() {
+        const content = this.content.map((block) => {
+            if (block.type !== "tool_use")
+                return block;
+            let input = {};
+            try {
+                input = block.args ? JSON.parse(block.args) : {};
+            }
+            catch { /* malformed vendor arguments become an empty tool input */ }
+            return { type: "tool_use", id: block.id, name: block.name, input };
+        });
+        return { id: this.messageId, type: "message", role: "assistant", model: this.model, content, stop_reason: this.stopReason, stop_sequence: null, usage: this.usage };
+    }
+}
+export function formatSse(event) {
+    return `event: ${event.event}\ndata: ${JSON.stringify(event.data)}\n\n`;
+}