@timo972/cc-router 0.12.0-rc.0 → 0.12.0-rc.1

package/README.md

@@ -356,7 +356,7 @@ Examples after the configuration above:
 
 Claude Code can also send a `/v1/messages` request with an `openai/*` model. CC-Router translates that Anthropic Messages request into an OpenAI Responses request and converts JSON or basic text SSE responses back into Anthropic-shaped message responses.
 
-Current limitation: OpenAI-to-Anthropic streaming currently covers text deltas and final usage. Streaming tool-call normalization is still experimental.
+OpenAI-to-Anthropic conversion supports text and function tool calls in both streaming and non-streaming responses.
 
 OpenAI subscription account records are separated from Claude accounts with `provider: "openai_subscription"` so they do not enter the Anthropic token pool:
 

package/dist/protocol/anthropic-to-openai.js

@@ -6,39 +6,51 @@ function stringifySystem(system) {
         return system;
     return system.map(block => block.text).join("\n");
 }
-function contentToOpenAI(content) {
-    if (typeof content === "string")
-        return [{ type: "input_text", text: content }];
-    return content.map(block => {
-        if (block.type === "text")
-            return { type: "input_text", text: block.text };
+function messageToOpenAIItems(role, content) {
+    const textType = role === "assistant" ? "output_text" : "input_text";
+    if (typeof content === "string") {
+        return [{ role, content: [{ type: textType, text: content }] }];
+    }
+    const items = [];
+    let pendingText = [];
+    const flushText = () => {
+        if (pendingText.length === 0)
+            return;
+        items.push({ role, content: pendingText });
+        pendingText = [];
+    };
+    for (const block of content) {
+        if (block.type === "text") {
+            pendingText.push({ type: textType, text: block.text });
+            continue;
+        }
+        flushText();
         if (block.type === "tool_use") {
-            return {
+            items.push({
                 type: "function_call",
                 call_id: block.id,
                 name: block.name,
                 arguments: JSON.stringify(block.input ?? {}),
-            };
+            });
+            continue;
         }
-        const output = typeof block.content === "string"
-            ? block.content
-            : block.content.map(item => item.text).join("\n");
-        return {
+        items.push({
             type: "function_call_output",
             call_id: block.tool_use_id,
-            output,
-        };
-    });
+            output: typeof block.content === "string"
+                ? block.content
+                : block.content.map(item => item.text).join("\n"),
+        });
+    }
+    flushText();
+    return items;
 }
 export function anthropicToOpenAIResponses(req, modelRouting = {}) {
     const parsed = parseModelRef(req.model, modelRouting);
     return {
         model: parsed.upstreamModel,
         instructions: stringifySystem(req.system),
-        input: req.messages.map(message => ({
-            role: message.role,
-            content: contentToOpenAI(message.content),
-        })),
+        input: req.messages.flatMap(message => messageToOpenAIItems(message.role, message.content)),
         tools: req.tools?.map(tool => ({
             type: "function",
             name: tool.name,

package/dist/protocol/openai-function-call.js

@@ -0,0 +1,16 @@
+export class OpenAIProtocolError extends Error {
+    name = "OpenAIProtocolError";
+}
+export function parseOpenAIFunctionArguments(argumentsJson) {
+    let parsed;
+    try {
+        parsed = JSON.parse(argumentsJson);
+    }
+    catch {
+        throw new OpenAIProtocolError("Invalid OpenAI function call arguments");
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new OpenAIProtocolError("Invalid OpenAI function call arguments");
+    }
+    return parsed;
+}

package/dist/protocol/openai-response-to-anthropic.js

@@ -1,3 +1,4 @@
+import { OpenAIProtocolError, parseOpenAIFunctionArguments } from "./openai-function-call.js";
 /**
  * Anthropic stop reason for a terminal Responses payload. Shared by both
  * translation paths — this module for a collected response, and the streaming
@@ -14,18 +15,45 @@ export function anthropicStopReasonForResponse(response) {
     return response?.incomplete_details?.reason === "max_output_tokens" ? "max_tokens" : "end_turn";
 }
 export function openAIResponseToAnthropicMessage(response) {
-    const content = (response.output ?? [])
-        .filter(item => item.type === "message")
-        .flatMap(item => item.content)
-        .filter(item => item.type === "output_text")
-        .map(item => ({ type: "text", text: item.text }));
+    const content = [];
+    let sawRefusal = false;
+    for (const item of response.output ?? []) {
+        if (item.type === "message") {
+            for (const part of item.content) {
+                if (part.type === "output_text") {
+                    content.push({ type: "text", text: part.text });
+                }
+                else if (part.type === "refusal") {
+                    sawRefusal = true;
+                    content.push({ type: "text", text: part.refusal });
+                }
+            }
+            continue;
+        }
+        if (item.type !== "function_call")
+            continue;
+        if (!item.call_id?.trim() || !item.name?.trim()) {
+            throw new OpenAIProtocolError("Invalid OpenAI function call metadata");
+        }
+        content.push({
+            type: "tool_use",
+            id: item.call_id,
+            name: item.name,
+            input: parseOpenAIFunctionArguments(item.arguments),
+        });
+    }
+    const stopReason = content.some(block => block.type === "tool_use")
+        ? "tool_use"
+        : sawRefusal
+            ? "refusal"
+            : anthropicStopReasonForResponse(response);
     return {
         id: response.id,
         type: "message",
         role: "assistant",
         model: response.model ?? "",
         content,
-        stop_reason: anthropicStopReasonForResponse(response),
+        stop_reason: stopReason,
         stop_sequence: null,
         usage: {
             input_tokens: response.usage?.input_tokens ?? 0,

package/dist/protocol/openai-stream-to-anthropic.js

@@ -1,25 +1,39 @@
 import { anthropicStopReasonForResponse } from "./openai-response-to-anthropic.js";
+import { OpenAIProtocolError, parseOpenAIFunctionArguments } from "./openai-function-call.js";
 import { terminalResponsePayload } from "./openai-responses-collect.js";
 export function createOpenAIStreamToAnthropicNormalizer() {
-    let textBlockStarted = false;
-    const ensureTextBlockStarted = () => {
-        if (textBlockStarted)
+    let blocks = new Map();
+    let nextIndex = 0;
+    let sawToolUse = false;
+    let sawRefusal = false;
+    const openTextBlock = (outputIndex) => {
+        if (blocks.has(outputIndex))
             return [];
-        textBlockStarted = true;
-        return [
-            {
+        const block = { index: nextIndex++, kind: "text", sentArguments: false, argumentsJson: "" };
+        blocks.set(outputIndex, block);
+        return [{
                 type: "content_block_start",
-                index: 0,
+                index: block.index,
                 content_block: { type: "text", text: "" },
-            },
-        ];
+            }];
+    };
+    const closeBlock = (outputIndex) => {
+        const block = blocks.get(outputIndex);
+        if (!block)
+            return [];
+        blocks.delete(outputIndex);
+        return [{ type: "content_block_stop", index: block.index }];
     };
     const reset = () => {
-        textBlockStarted = false;
+        blocks = new Map();
+        nextIndex = 0;
+        sawToolUse = false;
+        sawRefusal = false;
     };
     return {
         reset,
         convert(event) {
+            const outputIndex = event.output_index ?? 0;
             if (event.type === "response.created") {
                 reset();
                 return [
@@ -38,16 +52,96 @@ export function createOpenAIStreamToAnthropicNormalizer() {
                     },
                 ];
             }
+            if (event.type === "response.output_item.added") {
+                if (event.item?.type !== "function_call" || blocks.has(outputIndex))
+                    return [];
+                if (!event.item.call_id?.trim() || !event.item.name?.trim()) {
+                    throw new OpenAIProtocolError("Invalid OpenAI function call metadata");
+                }
+                const block = {
+                    index: nextIndex++,
+                    kind: "tool_use",
+                    sentArguments: false,
+                    argumentsJson: "",
+                };
+                blocks.set(outputIndex, block);
+                sawToolUse = true;
+                return [{
+                        type: "content_block_start",
+                        index: block.index,
+                        content_block: {
+                            type: "tool_use",
+                            id: event.item.call_id,
+                            name: event.item.name,
+                            input: {},
+                        },
+                    }];
+            }
             if (event.type === "response.output_text.delta") {
+                const prefix = openTextBlock(outputIndex);
+                const block = blocks.get(outputIndex);
                 return [
-                    ...ensureTextBlockStarted(),
+                    ...prefix,
                     {
                         type: "content_block_delta",
-                        index: 0,
+                        index: block?.index ?? 0,
                         delta: { type: "text_delta", text: event.delta ?? "" },
                     },
                 ];
             }
+            if (event.type === "response.refusal.delta") {
+                sawRefusal = true;
+                const prefix = openTextBlock(outputIndex);
+                const block = blocks.get(outputIndex);
+                return [...prefix, {
+                        type: "content_block_delta",
+                        index: block?.index ?? 0,
+                        delta: { type: "text_delta", text: event.delta ?? "" },
+                    }];
+            }
+            if (event.type === "response.function_call_arguments.delta") {
+                const block = blocks.get(outputIndex);
+                if (!block || block.kind !== "tool_use")
+                    return [];
+                block.sentArguments = true;
+                block.argumentsJson += event.delta ?? "";
+                return [{
+                        type: "content_block_delta",
+                        index: block.index,
+                        delta: { type: "input_json_delta", partial_json: event.delta ?? "" },
+                    }];
+            }
+            if (event.type === "response.function_call_arguments.done") {
+                const block = blocks.get(outputIndex);
+                if (!block || block.kind !== "tool_use" || block.sentArguments || !event.arguments)
+                    return [];
+                block.sentArguments = true;
+                block.argumentsJson = event.arguments;
+                return [{
+                        type: "content_block_delta",
+                        index: block.index,
+                        delta: { type: "input_json_delta", partial_json: event.arguments },
+                    }];
+            }
+            if (event.type === "response.output_item.done") {
+                const block = blocks.get(outputIndex);
+                const atomicArguments = block?.kind === "tool_use" && !block.sentArguments
+                    ? event.item?.arguments ?? ""
+                    : "";
+                if (block?.kind === "tool_use") {
+                    if (atomicArguments)
+                        block.argumentsJson = atomicArguments;
+                    parseOpenAIFunctionArguments(block.argumentsJson);
+                }
+                const argumentEvent = block?.kind === "tool_use" && atomicArguments
+                    ? [{
+                            type: "content_block_delta",
+                            index: block.index,
+                            delta: { type: "input_json_delta", partial_json: atomicArguments },
+                        }]
+                    : [];
+                return [...argumentEvent, ...closeBlock(outputIndex)];
+            }
             // Both terminal Responses events must close the Anthropic message.
             // Emitting nothing for `response.incomplete` would end the HTTP stream
             // without `message_stop`, leaving the client waiting on a turn that is
@@ -63,10 +157,16 @@ export function createOpenAIStreamToAnthropicNormalizer() {
             // a stream that never reached a terminal event looks like, and what
             // clients already detect and surface as an error.
             if (terminalResponsePayload(event) !== undefined) {
+                if ([...blocks.values()].some(block => block.kind === "tool_use")) {
+                    throw new OpenAIProtocolError("OpenAI function call ended before completion");
+                }
                 const usage = event.response?.usage ?? {};
-                const prefix = textBlockStarted
-                    ? [{ type: "content_block_stop", index: 0 }]
-                    : [];
+                const prefix = [...blocks.keys()].flatMap(closeBlock);
+                const stopReason = sawToolUse
+                    ? "tool_use"
+                    : sawRefusal
+                        ? "refusal"
+                        : anthropicStopReasonForResponse(event.response);
                 reset();
                 return [
                     ...prefix,
@@ -74,7 +174,7 @@ export function createOpenAIStreamToAnthropicNormalizer() {
                         type: "message_delta",
                         // Same helper the collected-response translator uses, so an
                         // incomplete turn reports the same stop reason on both paths.
-                        delta: { stop_reason: anthropicStopReasonForResponse(event.response), stop_sequence: null },
+                        delta: { stop_reason: stopReason, stop_sequence: null },
                         usage: { output_tokens: usage.output_tokens ?? 0 },
                     },
                     { type: "message_stop" },

package/dist/protocol/openai-to-anthropic.js

@@ -8,48 +8,73 @@ function parseArguments(args) {
     }
 }
 function textFromOpenAI(block) {
-    if (block.type === "input_text" || block.type === "output_text")
-        return block.text;
-    return null;
+    return block.text;
 }
 function messageContentToAnthropic(message) {
-    const blocks = message.content.map((block) => {
-        const text = textFromOpenAI(block);
-        if (text !== null)
-            return { type: "text", text };
-        if (block.type === "function_call") {
-            return {
-                type: "tool_use",
-                id: block.call_id,
-                name: block.name,
-                input: parseArguments(block.arguments),
-            };
-        }
-        if (block.type === "function_call_output") {
-            return {
-                type: "tool_result",
-                tool_use_id: block.call_id,
-                content: block.output,
-            };
-        }
-        return null;
-    }).filter((block) => block !== null);
-    if (blocks.length === 1 && blocks[0].type === "text")
+    const blocks = message.content.map((block) => ({
+        type: "text",
+        text: textFromOpenAI(block),
+    }));
+    if (blocks.length === 1)
         return blocks[0].text;
     return blocks;
 }
 function normalizeRole(role) {
     return role === "assistant" ? "assistant" : "user";
 }
+function isFunctionCall(item) {
+    return "type" in item && item.type === "function_call";
+}
+function isFunctionCallOutput(item) {
+    return "type" in item && item.type === "function_call_output";
+}
+function inputItemsToAnthropicMessages(input) {
+    const messages = [];
+    const append = (role, blocks) => {
+        if (blocks.length === 0)
+            return;
+        const last = messages.at(-1);
+        if (last?.role === role) {
+            const existing = typeof last.content === "string"
+                ? [{ type: "text", text: last.content }]
+                : last.content;
+            last.content = [...existing, ...blocks];
+            return;
+        }
+        messages.push({ role, content: blocks });
+    };
+    for (const item of input) {
+        if (isFunctionCall(item)) {
+            append("assistant", [{
+                    type: "tool_use",
+                    id: item.call_id,
+                    name: item.name,
+                    input: parseArguments(item.arguments),
+                }]);
+        }
+        else if (isFunctionCallOutput(item)) {
+            append("user", [{ type: "tool_result", tool_use_id: item.call_id, content: item.output }]);
+        }
+        else {
+            const content = messageContentToAnthropic(item);
+            append(normalizeRole(item.role), typeof content === "string"
+                ? [{ type: "text", text: content }]
+                : content);
+        }
+    }
+    return messages.map(message => {
+        if (Array.isArray(message.content) && message.content.length === 1 && message.content[0].type === "text") {
+            return { ...message, content: message.content[0].text };
+        }
+        return message;
+    });
+}
 export function openAIResponsesToAnthropic(req) {
     const parsed = parseModelRef(req.model);
     return {
         model: parsed.upstreamModel,
         system: req.instructions,
-        messages: req.input.map(message => ({
-            role: normalizeRole(message.role),
-            content: messageContentToAnthropic(message),
-        })),
+        messages: inputItemsToAnthropicMessages(req.input),
         tools: req.tools?.map(tool => ({
             name: tool.name,
             description: tool.description,

package/dist/proxy/messages-cross-route.js

@@ -2,6 +2,7 @@ import express from "express";
 import { selectRoute } from "../providers/route-selector.js";
 import { anthropicToOpenAIResponses } from "../protocol/anthropic-to-openai.js";
 import { openAIResponseToAnthropicMessage } from "../protocol/openai-response-to-anthropic.js";
+import { OpenAIProtocolError } from "../protocol/openai-function-call.js";
 import { createOpenAIStreamToAnthropicNormalizer } from "../protocol/openai-stream-to-anthropic.js";
 import { encodeSseEvent, parseSseLines } from "../protocol/sse.js";
 import { forwardOpenAICodexResponse } from "../providers/openai/codex-transport.js";
@@ -143,16 +144,21 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
     let remainder = "";
     let id = "";
     let model = "";
-    let text = "";
     let failure;
     let completed = false;
     let usage = {};
     let status;
     let incompleteDetails;
+    const textByIndex = new Map();
+    const refusalByIndex = new Map();
+    const argumentsByIndex = new Map();
+    const pendingCallsByIndex = new Map();
+    const callsByIndex = new Map();
     const applyEvent = (event) => {
         if (typeof event !== "object" || event === null)
             return;
         const openAIEvent = event;
+        const outputIndex = openAIEvent.output_index ?? 0;
         // Reported the moment it is seen, not when this function returns: the
         // read after it can be cut short by a client disconnect, and losing the
         // verdict there turns a real backend failure into a benign cancellation.
@@ -172,7 +178,57 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
             return;
         }
         if (openAIEvent.type === "response.output_text.delta") {
-            text += openAIEvent.delta ?? "";
+            textByIndex.set(outputIndex, (textByIndex.get(outputIndex) ?? "") + (openAIEvent.delta ?? ""));
+            return;
+        }
+        if (openAIEvent.type === "response.refusal.delta") {
+            refusalByIndex.set(outputIndex, (refusalByIndex.get(outputIndex) ?? "") + (openAIEvent.delta ?? ""));
+            return;
+        }
+        if (openAIEvent.type === "response.output_item.added") {
+            const item = openAIEvent.item;
+            if (item?.type === "function_call") {
+                if (!item.call_id?.trim() || !item.name?.trim()) {
+                    throw new OpenAIProtocolError("Invalid OpenAI function call metadata");
+                }
+                pendingCallsByIndex.set(outputIndex, {
+                    type: "function_call",
+                    call_id: item.call_id,
+                    name: item.name,
+                    arguments: item.arguments ?? "",
+                });
+            }
+            return;
+        }
+        if (openAIEvent.type === "response.function_call_arguments.delta") {
+            if (!pendingCallsByIndex.has(outputIndex))
+                return;
+            argumentsByIndex.set(outputIndex, (argumentsByIndex.get(outputIndex) ?? "") + (openAIEvent.delta ?? ""));
+            return;
+        }
+        if (openAIEvent.type === "response.function_call_arguments.done") {
+            if (pendingCallsByIndex.has(outputIndex) && !argumentsByIndex.has(outputIndex) && openAIEvent.arguments) {
+                argumentsByIndex.set(outputIndex, openAIEvent.arguments);
+            }
+            return;
+        }
+        if (openAIEvent.type === "response.output_item.done") {
+            const item = openAIEvent.item;
+            const pending = pendingCallsByIndex.get(outputIndex);
+            if (item?.type === "function_call" || pending) {
+                const callId = item?.call_id || pending?.call_id;
+                const name = item?.name || pending?.name;
+                if (!callId?.trim() || !name?.trim()) {
+                    throw new OpenAIProtocolError("Invalid OpenAI function call metadata");
+                }
+                callsByIndex.set(outputIndex, {
+                    type: "function_call",
+                    call_id: callId,
+                    name,
+                    arguments: item?.arguments || argumentsByIndex.get(outputIndex) || pending?.arguments || "",
+                });
+                pendingCallsByIndex.delete(outputIndex);
+            }
             return;
         }
         if (terminalResponsePayload(event) !== undefined) {
@@ -199,15 +255,34 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
     if (tail || remainder) {
         parseSseLines(remainder + tail + "\n", { tolerant: true }).events.forEach(applyEvent);
     }
+    const output = [...new Set([
+            ...textByIndex.keys(),
+            ...refusalByIndex.keys(),
+            ...callsByIndex.keys(),
+        ])]
+        .sort((a, b) => a - b)
+        .flatMap((index) => {
+        const call = callsByIndex.get(index);
+        if (call)
+            return [{ ...call, arguments: call.arguments || argumentsByIndex.get(index) || "" }];
+        const text = textByIndex.get(index);
+        const refusal = refusalByIndex.get(index);
+        const content = [
+            ...(text ? [{ type: "output_text", text }] : []),
+            ...(refusal ? [{ type: "refusal", refusal }] : []),
+        ];
+        return content.length > 0 ? [{ type: "message", role: "assistant", content }] : [];
+    });
+    const protocolFailure = pendingCallsByIndex.size > 0
+        ? "OpenAI function call ended before completion"
+        : undefined;
+    if (protocolFailure)
+        report.upstreamReportedFailure = true;
     return {
         message: openAIResponseToAnthropicMessage({
             id,
             model,
-            output: text ? [{
-                    type: "message",
-                    role: "assistant",
-                    content: [{ type: "output_text", text }],
-                }] : [],
+            output,
             usage,
             ...(status ? { status } : {}),
             ...(incompleteDetails ? { incomplete_details: incompleteDetails } : {}),
@@ -222,7 +297,9 @@ async function collectOpenAIStreamAsAnthropicMessage(upstream, report) {
         // mid-flight) is a failure rather than an empty success. An explicit
         // `response.failed`/`error` message wins, since it says more about what
         // went wrong.
-        failure: failure ?? (completed ? undefined : "Upstream stream ended without a terminal response event"),
+        failure: failure
+            ?? protocolFailure
+            ?? (completed ? undefined : "Upstream stream ended without a terminal response event"),
     };
 }
 /** Returns the upstream failure message when the stream ended in one. */
@@ -250,6 +327,16 @@ async function sendOpenAIStreamAsAnthropic(upstream, res, onUsage, report) {
     let totals;
     let failure;
     let completed = false;
+    const pendingToolCalls = new Set();
+    const writeProtocolError = () => {
+        res.write(encodeSseEvent({
+            type: "error",
+            error: {
+                type: "api_error",
+                message: "Invalid or incomplete response from OpenAI",
+            },
+        }));
+    };
     const inspect = (event) => {
         totals = usageFromTerminalEvent(event) ?? totals;
         if (typeof event !== "object" || event === null)
@@ -268,6 +355,12 @@ async function sendOpenAIStreamAsAnthropic(upstream, res, onUsage, report) {
         else if (terminalResponsePayload(event) !== undefined) {
             completed = true;
         }
+        if (typed.type === "response.output_item.added" && typed.item?.type === "function_call") {
+            pendingToolCalls.add(typed.output_index ?? 0);
+        }
+        else if (typed.type === "response.output_item.done") {
+            pendingToolCalls.delete(typed.output_index ?? 0);
+        }
     };
     const relayEvents = (events) => {
         for (const event of events) {
@@ -298,6 +391,18 @@ async function sendOpenAIStreamAsAnthropic(upstream, res, onUsage, report) {
         if (tail || remainder) {
             relayEvents(parseSseLines(remainder + tail + "\n", { tolerant: true }).events);
         }
+        if (!completed && pendingToolCalls.size > 0 && failure === undefined) {
+            failure = "OpenAI function call ended before completion";
+            report.upstreamReportedFailure = true;
+            writeProtocolError();
+        }
+    }
+    catch (error) {
+        if (!(error instanceof OpenAIProtocolError))
+            throw error;
+        failure = error.message;
+        report.upstreamReportedFailure = true;
+        writeProtocolError();
     }
     finally {
         res.end();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timo972/cc-router",
-  "version": "0.12.0-rc.0",
+  "version": "0.12.0-rc.1",
   "description": "Cache-aware session router for Claude Max OAuth tokens — use multiple Claude Max accounts with Claude Code",
   "type": "module",
   "bin": {