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

package/dist/config/manager.js

@@ -110,9 +110,11 @@ export function renameAccountRecordById(oldId, newId) {
     return target;
 }
 function normalizeAccountProvider(record) {
-    return record.provider === "openai_subscription"
-        ? "openai_subscription"
-        : "anthropic_subscription";
+    if (record.provider === "openai_subscription")
+        return "openai_subscription";
+    if (record.provider === "xai_subscription")
+        return "xai_subscription";
+    return "anthropic_subscription";
 }
 export function migrateLegacyAccountProviders(path = ACCOUNTS_PATH) {
     const records = readRawFromPath(path);
@@ -184,6 +186,20 @@ export function saveOpenAIAccountsToPath(accounts, path) {
 export function saveOpenAIAccounts(accounts) {
     saveOpenAIAccountsToPath(accounts, ACCOUNTS_PATH);
 }
+export function loadXaiAccounts(path) {
+    const records = readRawFromPath(path ?? ACCOUNTS_PATH);
+    return records
+        .filter(a => a.provider === "xai_subscription")
+        .map(a => ({
+        id: a.id,
+        provider: "xai_subscription",
+        accessToken: a.accessToken,
+        refreshToken: a.refreshToken,
+        expiresAt: a.expiresAt,
+        enabled: a.enabled !== false,
+        ...(Array.isArray(a.scopes) ? { scopes: a.scopes } : {}),
+    }));
+}
 function parseProxyConfig(raw) {
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {

package/dist/config/paths.js

@@ -5,6 +5,7 @@ export const CONFIG_DIR = path.join(os.homedir(), ".cc-router");
 export const ACCOUNTS_PATH = process.env["ACCOUNTS_PATH"] ??
     path.join(CONFIG_DIR, "accounts.json");
 export const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+export const CODEX_CONFIG_PATH = path.join(os.homedir(), ".codex", "config.toml");
 export const PROXY_PORT = parseInt(process.env["PORT"] ?? "3456", 10);
 export const LITELLM_PORT = 4000;
 // When set, the server forwards to LiteLLM instead of Anthropic directly

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/model-ref.js

@@ -20,7 +20,7 @@ function cleanModel(model) {
  * costs the Anthropic path nothing. Everything else unprefixed still goes to
  * Anthropic, which is what existing setups rely on.
  */
-function isBareOpenAIModel(publicModel) {
+export function isBareOpenAIModel(publicModel) {
     return publicModel.toLowerCase().startsWith("gpt-");
 }
 export function parseModelRef(model, config = {}) {

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/providers/openai/account-state.js

@@ -132,8 +132,11 @@ export function applyCodexRateLimits(account, update, nowMs) {
     }
     if (update.credits)
         limits.credits = update.credits;
-    if (update.buckets.length > 0 || update.credits)
+    if (update.resetCredits)
+        limits.resetCredits = update.resetCredits;
+    if (update.buckets.length > 0 || update.credits || update.resetCredits) {
         limits.lastUpdated = nowMs;
+    }
 }
 function normalizeModelSlug(model) {
     const normalized = model?.trim().toLowerCase();

package/dist/providers/openai/usage.js

@@ -246,7 +246,20 @@ export function parseCodexUsagePayload(value, nowMs) {
             };
         }
     }
-    return { buckets, ...(credits ? { credits } : {}) };
+    let resetCredits;
+    const rawResetCredits = payload["rate_limit_reset_credits"];
+    if (typeof rawResetCredits === "object" && rawResetCredits !== null) {
+        const record = rawResetCredits;
+        const count = usageNumber(record["available_count"]) ?? usageNumber(record["available"]);
+        if (count !== undefined) {
+            resetCredits = { available: Math.max(0, Math.min(99, Math.floor(count))) };
+        }
+    }
+    return {
+        buckets,
+        ...(credits ? { credits } : {}),
+        ...(resetCredits ? { resetCredits } : {}),
+    };
 }
 export function resolveActiveLimit(headers) {
     const raw = headerString(headers, "x-codex-active-limit")?.trim();

package/dist/providers/xai/account-record.js

@@ -0,0 +1,42 @@
+export const XAI_PROVIDER = "xai_subscription";
+export const XAI_DEFAULT_SCOPES = [
+    "openid",
+    "profile",
+    "email",
+    "offline_access",
+    "grok-cli:access",
+    "api:access",
+];
+function parseExpiresAt(value) {
+    const parsed = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error("expiresAt must be a positive Unix timestamp in milliseconds");
+    }
+    return parsed;
+}
+function parseScopes(value) {
+    if (Array.isArray(value))
+        return value.filter(Boolean);
+    if (typeof value === "string")
+        return value.split(/\s+/).filter(Boolean);
+    return [...XAI_DEFAULT_SCOPES];
+}
+export function createXaiAccountRecord(input) {
+    const id = input.id.trim();
+    if (!/^[a-zA-Z0-9_-]+$/.test(id)) {
+        throw new Error("Only letters, numbers, _ and - allowed in account ID");
+    }
+    if (!input.accessToken.trim())
+        throw new Error("Access token is required");
+    if (!input.refreshToken.trim())
+        throw new Error("Refresh token is required");
+    return {
+        id,
+        provider: XAI_PROVIDER,
+        accessToken: input.accessToken.trim(),
+        refreshToken: input.refreshToken.trim(),
+        expiresAt: parseExpiresAt(input.expiresAt),
+        scopes: parseScopes(input.scopes),
+        enabled: input.enabled ?? true,
+    };
+}