aicodeswitch 4.0.4 → 5.0.0

package/dist/server/conversions/thinking/providers.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Multi-provider reasoning configuration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.getReasoningConfig = getReasoningConfig;
+exports.applyReasoningConfig = applyReasoningConfig;
+const PROVIDER_CONFIGS = [
+    { patterns: ['deepseek'], config: { supportsThinking: true, supportsEffort: true, thinkingParam: 'thinking', effortParam: 'reasoning_effort', effortValueMode: 'deepseek', outputFormat: 'reasoning_content' } },
+    { patterns: ['moonshot', 'kimi'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['qwen', 'dashscope'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'enable_thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['zhipu', 'glm', 'bigmodel'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['minimax'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'reasoning_split', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_details' } },
+    { patterns: ['mimo', 'xiaomimimo'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['openrouter'], config: { supportsThinking: false, supportsEffort: true, thinkingParam: 'none', effortParam: 'reasoning.effort', effortValueMode: 'openrouter', outputFormat: 'reasoning' } },
+    { patterns: ['siliconflow'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'enable_thinking', effortParam: 'none', effortValueMode: 'passthrough', outputFormat: 'reasoning_content' } },
+    { patterns: ['stepfun', 'step'], config: { supportsThinking: true, supportsEffort: false, thinkingParam: 'none', effortParam: 'reasoning_effort', effortValueMode: 'low_high', outputFormat: 'reasoning' } },
+];
+const DEFAULT_CONFIG = {
+    supportsThinking: false,
+    supportsEffort: false,
+    thinkingParam: 'none',
+    effortParam: 'none',
+    effortValueMode: 'passthrough',
+    outputFormat: 'reasoning_content',
+};
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+/** Detect reasoning config for a given provider */
+function getReasoningConfig(providerName, baseUrl, model) {
+    const haystack = `${providerName} ${baseUrl} ${model}`.toLowerCase();
+    for (const { patterns, config } of PROVIDER_CONFIGS) {
+        if (patterns.some(p => haystack.includes(p))) {
+            return config;
+        }
+    }
+    return DEFAULT_CONFIG;
+}
+/** Apply reasoning config to a request body */
+function applyReasoningConfig(body, config, effort) {
+    if (!effort)
+        return body;
+    const result = Object.assign({}, body);
+    if (config.supportsThinking && config.thinkingParam !== 'none') {
+        switch (config.thinkingParam) {
+            case 'thinking':
+                result.thinking = { type: 'enabled' };
+                break;
+            case 'enable_thinking':
+                result.enable_thinking = true;
+                break;
+            case 'reasoning_split':
+                result.reasoning_split = true;
+                break;
+        }
+    }
+    if (config.supportsEffort && config.effortParam !== 'none' && effort) {
+        const mappedEffort = mapEffortValue(effort, config.effortValueMode);
+        if (config.effortParam === 'reasoning.effort') {
+            result.reasoning = result.reasoning || {};
+            result.reasoning.effort = mappedEffort;
+        }
+        else {
+            result[config.effortParam] = mappedEffort;
+        }
+    }
+    return result;
+}
+function mapEffortValue(effort, mode) {
+    switch (mode) {
+        case 'deepseek': return 'high'; // DeepSeek only supports high/max
+        case 'low_high': return ['low', 'medium'].includes(effort) ? 'low' : 'high';
+        case 'openrouter': return ['xhigh', 'max'].includes(effort) ? 'xhigh' : effort;
+        default: return effort;
+    }
+}

package/dist/server/conversions/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Core type definitions for the format conversion system.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/conversions/url-normalizer.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * API URL 规范化工具
+ *
+ * 解决用户填写的 apiUrl 可能已包含版本路径（如 /v1、/v3、/v4、/v1beta），
+ * 而系统又会硬编码拼接版本路径，导致出现双重版本路径的问题。
+ *
+ * 例如：
+ * - https://xxx.com/api/anthropic/v1 + /v1/messages → https://xxx.com/api/anthropic/v1/messages
+ * - https://xxx.com/api/anthropic/v4 + /v1/messages → https://xxx.com/api/anthropic/v4/messages
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUpstreamUrl = buildUpstreamUrl;
+exports.normalizeApiUrl = normalizeApiUrl;
+// 匹配末尾的版本路径，如 /v1, /v4, /v1beta, /v2alpha 等
+const VERSION_SUFFIX_REGEX = /(\/v\d+[a-z]*)$/;
+// 匹配路径开头的版本段，如 /v1/, /v4/, /v1beta/ 等
+const VERSION_PREFIX_REGEX = /^\/v\d+[a-z]*\//;
+/**
+ * 智能构建上游请求 URL
+ *
+ * 检测 apiUrl 末尾的版本路径，智能处理版本冲突：
+ * - 若 apiUrl 无版本后缀：直接拼接 appendPath
+ * - 若 apiUrl 有版本后缀：剥离后用该版本替换 appendPath 中的版本段
+ *
+ * @param apiUrl 用户配置的 API 地址（可能包含末尾版本路径）
+ * @param appendPath 需要拼接的路径（如 /v1/messages, /v1/chat/completions）
+ * @returns 规范化后的完整 URL
+ */
+function buildUpstreamUrl(apiUrl, appendPath) {
+    // 去除末尾斜杠
+    const url = apiUrl.replace(/\/+$/, '');
+    // 检测 apiUrl 末尾是否包含版本路径
+    const versionMatch = url.match(VERSION_SUFFIX_REGEX);
+    if (!versionMatch) {
+        // 无版本后缀，直接拼接
+        return `${url}${appendPath}`;
+    }
+    // 剥离版本后缀得到 baseUrl
+    const baseUrl = url.slice(0, -versionMatch[1].length);
+    const extractedVersion = versionMatch[1]; // 如 '/v4'
+    // 将 appendPath 中开头的版本段替换为提取到的版本
+    const normalizedPath = appendPath.replace(VERSION_PREFIX_REGEX, `${extractedVersion}/`);
+    return `${baseUrl}${normalizedPath}`;
+}
+/**
+ * 规范化 API URL，去除末尾斜杠和版本后缀
+ *
+ * @param apiUrl 用户配置的 API 地址
+ * @returns 去除末尾斜杠和版本路径后的基础 URL
+ */
+function normalizeApiUrl(apiUrl) {
+    // 去除末尾斜杠
+    let url = apiUrl.replace(/\/+$/, '');
+    // 去除末尾版本路径
+    url = url.replace(VERSION_SUFFIX_REGEX, '');
+    return url;
+}

package/dist/server/conversions/utils/format-mappers.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Shared format mapping helpers for Gemini ↔ Completions conversions.
+ * Eliminates duplication between response.ts and streaming.ts within the pair.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapGeminiFinishReason = mapGeminiFinishReason;
+exports.mapCompletionsFinishReason = mapCompletionsFinishReason;
+exports.mapGeminiUsage = mapGeminiUsage;
+exports.mapCompletionsUsage = mapCompletionsUsage;
+/** Map Gemini finishReason to Completions finish_reason. */
+function mapGeminiFinishReason(reason) {
+    switch (reason) {
+        case 'STOP': return 'stop';
+        case 'MAX_TOKENS': return 'length';
+        case 'SAFETY': return 'content_filter';
+        case 'RECITATION': return 'content_filter';
+        case 'FINISH_REASON_UNSPECIFIED': return 'stop';
+        default: return 'stop';
+    }
+}
+/** Map Completions finish_reason to Gemini finishReason. */
+function mapCompletionsFinishReason(reason) {
+    switch (reason) {
+        case 'stop': return 'STOP';
+        case 'length': return 'MAX_TOKENS';
+        case 'content_filter': return 'SAFETY';
+        case 'tool_calls': return 'STOP';
+        default: return 'STOP';
+    }
+}
+/** Map Gemini usageMetadata to Completions usage. */
+function mapGeminiUsage(metadata) {
+    var _a, _b, _c;
+    if (!metadata)
+        return { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    const prompt = (_a = metadata.promptTokenCount) !== null && _a !== void 0 ? _a : 0;
+    const completion = (_b = metadata.candidatesTokenCount) !== null && _b !== void 0 ? _b : 0;
+    return {
+        prompt_tokens: prompt,
+        completion_tokens: completion,
+        total_tokens: (_c = metadata.totalTokenCount) !== null && _c !== void 0 ? _c : (prompt + completion),
+    };
+}
+/** Map Completions usage to Gemini usageMetadata. */
+function mapCompletionsUsage(usage) {
+    var _a, _b, _c;
+    if (!usage)
+        return { promptTokenCount: 0, candidatesTokenCount: 0, totalTokenCount: 0 };
+    const prompt = (_a = usage.prompt_tokens) !== null && _a !== void 0 ? _a : 0;
+    const completion = (_b = usage.completion_tokens) !== null && _b !== void 0 ? _b : 0;
+    return {
+        promptTokenCount: prompt,
+        candidatesTokenCount: completion,
+        totalTokenCount: (_c = usage.total_tokens) !== null && _c !== void 0 ? _c : (prompt + completion),
+    };
+}

package/dist/server/conversions/utils/id.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMessageId = generateMessageId;
+exports.generateToolUseId = generateToolUseId;
+exports.generateCompletionsId = generateCompletionsId;
+exports.generateResponseId = generateResponseId;
+exports.generateCallId = generateCallId;
+exports.generateGeminiSynthId = generateGeminiSynthId;
+const crypto_1 = require("crypto");
+/** Generate a Claude message ID: msg_<uuid> */
+function generateMessageId() {
+    return `msg_${(0, crypto_1.randomUUID)().replace(/-/g, '').slice(0, 24)}`;
+}
+/** Generate a Claude tool use ID: toolu_<uuid> */
+function generateToolUseId() {
+    return `toolu_${(0, crypto_1.randomUUID)().replace(/-/g, '').slice(0, 24)}`;
+}
+/** Generate an OpenAI Chat completion ID: chatcmpl-<uuid> */
+function generateCompletionsId() {
+    return `chatcmpl-${(0, crypto_1.randomUUID)().replace(/-/g, '')}`;
+}
+/** Generate an OpenAI Responses API ID: resp_<uuid> */
+function generateResponseId() {
+    return `resp_${(0, crypto_1.randomUUID)().replace(/-/g, '').slice(0, 24)}`;
+}
+/** Generate a generic call ID for Responses API function calls */
+function generateCallId() {
+    return `call_${(0, crypto_1.randomUUID)().replace(/-/g, '').slice(0, 24)}`;
+}
+/** Generate a Gemini synthetic tool call ID */
+function generateGeminiSynthId() {
+    return `gemini_synth_${(0, crypto_1.randomUUID)().replace(/-/g, '').slice(0, 16)}`;
+}

package/dist/server/conversions/utils/stop-reasons.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Stop reason / finish reason / status mapping across all API formats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionsToClaudeStopReason = completionsToClaudeStopReason;
+exports.claudeToCompletionsStopReason = claudeToCompletionsStopReason;
+exports.geminiToClaudeStopReason = geminiToClaudeStopReason;
+exports.claudeToGeminiStopReason = claudeToGeminiStopReason;
+exports.responsesToClaudeStopReason = responsesToClaudeStopReason;
+exports.claudeToResponsesStatus = claudeToResponsesStatus;
+exports.completionsToResponsesFinishReason = completionsToResponsesFinishReason;
+exports.responsesToCompletionsFinishReason = responsesToCompletionsFinishReason;
+// --- OpenAI Chat Completions ↔ Claude Messages ---
+function completionsToClaudeStopReason(reason) {
+    if (!reason)
+        return 'end_turn';
+    switch (reason) {
+        case 'tool_calls':
+        case 'function_call':
+            return 'tool_use';
+        case 'length':
+            return 'max_tokens';
+        default:
+            return 'end_turn';
+    }
+}
+function claudeToCompletionsStopReason(reason) {
+    if (!reason)
+        return 'stop';
+    switch (reason) {
+        case 'tool_use':
+            return 'tool_calls';
+        case 'max_tokens':
+            return 'length';
+        case 'end_turn':
+            return 'stop';
+        default:
+            return 'stop';
+    }
+}
+// --- Gemini ↔ Claude Messages ---
+function geminiToClaudeStopReason(reason) {
+    if (!reason)
+        return 'end_turn';
+    switch (reason) {
+        case 'MAX_TOKENS':
+            return 'max_tokens';
+        case 'STOP':
+        default:
+            return 'end_turn';
+    }
+}
+function claudeToGeminiStopReason(reason) {
+    if (!reason)
+        return 'STOP';
+    switch (reason) {
+        case 'max_tokens':
+            return 'MAX_TOKENS';
+        case 'end_turn':
+        case 'tool_use':
+        default:
+            return 'STOP';
+    }
+}
+// --- OpenAI Responses API ↔ Claude Messages ---
+function responsesToClaudeStopReason(status, incompleteReason, hasToolUse) {
+    if (!status || status === 'completed') {
+        return hasToolUse ? 'tool_use' : 'end_turn';
+    }
+    if (status === 'incomplete') {
+        if (incompleteReason === 'max_output_tokens' || incompleteReason === 'max_tokens') {
+            return 'max_tokens';
+        }
+        return 'end_turn';
+    }
+    return 'end_turn';
+}
+function claudeToResponsesStatus(reason) {
+    if (reason === 'max_tokens') {
+        return { status: 'incomplete', incomplete_details: { reason: 'max_output_tokens' } };
+    }
+    return { status: 'completed' };
+}
+// --- OpenAI Chat ↔ Responses API ---
+function completionsToResponsesFinishReason(reason) {
+    if (reason === 'length')
+        return 'incomplete';
+    return 'completed';
+}
+function responsesToCompletionsFinishReason(status) {
+    if (status === 'incomplete')
+        return 'length';
+    return 'stop';
+}

package/dist/server/conversions/utils/streaming-helpers.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Shared streaming helper utilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flushConverter = flushConverter;
+exports.normalizeToolArgumentsFragment = normalizeToolArgumentsFragment;
+exports.serializeSSE = serializeSSE;
+exports.parseEventData = parseEventData;
+exports.createOutputEvent = createOutputEvent;
+/** Flush a converter's internal buffer, returning any remaining events. */
+function flushConverter(converter) {
+    var _a, _b;
+    return (_b = (_a = converter.flush) === null || _a === void 0 ? void 0 : _a.call(converter)) !== null && _b !== void 0 ? _b : [];
+}
+/** Normalize tool arguments fragment to string. */
+function normalizeToolArgumentsFragment(argumentsValue) {
+    if (argumentsValue === undefined || argumentsValue === null)
+        return '';
+    if (typeof argumentsValue === 'string')
+        return argumentsValue;
+    return JSON.stringify(argumentsValue);
+}
+/** Serialize an SSEEvent into wire-format SSE text block. */
+function serializeSSE(event) {
+    let result = '';
+    if (event.event !== undefined && event.event !== null) {
+        result += `event: ${event.event}\n`;
+    }
+    if (event.id) {
+        result += `id: ${event.id}\n`;
+    }
+    const dataStr = typeof event.data === 'string' ? event.data : JSON.stringify(event.data);
+    result += `data: ${dataStr}\n\n`;
+    return result;
+}
+/**
+ * 解析 SSE event data：如果已是对象直接返回，否则 JSON.parse。
+ * 兼容 legacy SSEParserTransform 输出的对象 data 和字符串 data。
+ */
+function parseEventData(data) {
+    if (data === undefined || data === null)
+        return data;
+    if (typeof data === 'string') {
+        if (data === '[DONE]')
+            return { type: 'done' };
+        try {
+            return JSON.parse(data);
+        }
+        catch (_a) {
+            return data;
+        }
+    }
+    return data; // 已经是对象
+}
+/** 创建输出 SSEEvent：data 直接设为对象 */
+function createOutputEvent(type, data, id) {
+    return { event: type, data, id };
+}

package/dist/server/conversions/utils/tool-schema.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Tool schema conversion utilities across API formats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeToCompletionsTools = claudeToCompletionsTools;
+exports.completionsToClaudeTools = completionsToClaudeTools;
+exports.claudeToResponsesTools = claudeToResponsesTools;
+exports.responsesToClaudeTools = responsesToClaudeTools;
+exports.claudeToGeminiTools = claudeToGeminiTools;
+exports.geminiToClaudeTools = geminiToClaudeTools;
+exports.completionsToGeminiTools = completionsToGeminiTools;
+exports.convertSchemaToGemini = convertSchemaToGemini;
+exports.convertSchemaFromGemini = convertSchemaFromGemini;
+/** Claude tools → OpenAI Chat tools */
+function claudeToCompletionsTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length))
+        return [];
+    return tools.map(tool => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description || '',
+            parameters: tool.input_schema || {},
+        },
+    }));
+}
+/** OpenAI Chat tools → Claude tools */
+function completionsToClaudeTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length))
+        return [];
+    return tools
+        .filter(t => t.type === 'function' && t.function)
+        .map(t => ({
+        name: t.function.name,
+        description: t.function.description || '',
+        input_schema: t.function.parameters || {},
+    }));
+}
+/** Claude tools → Responses API tools */
+function claudeToResponsesTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length))
+        return [];
+    return tools.map(tool => ({
+        type: 'function',
+        name: tool.name,
+        description: tool.description || '',
+        parameters: cleanSchema(tool.input_schema || {}),
+    }));
+}
+/** Responses API tools → Claude tools */
+function responsesToClaudeTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length))
+        return [];
+    return tools
+        .filter(t => t.type === 'function')
+        .map(t => ({
+        name: t.name,
+        description: t.description || '',
+        input_schema: cleanSchema(t.parameters || {}),
+    }));
+}
+/** Claude tools → Gemini functionDeclarations */
+function claudeToGeminiTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length))
+        return [];
+    return tools.map(tool => ({
+        name: tool.name,
+        description: tool.description || '',
+        parameters: convertSchemaToGemini(tool.input_schema || {}),
+    }));
+}
+/** Gemini functionDeclarations → Claude tools */
+function geminiToClaudeTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length))
+        return [];
+    return tools.map(tool => ({
+        name: tool.name,
+        description: tool.description || '',
+        input_schema: convertSchemaFromGemini(tool.parameters || {}),
+    }));
+}
+/** OpenAI Chat tools → Gemini functionDeclarations */
+function completionsToGeminiTools(tools) {
+    if (!(tools === null || tools === void 0 ? void 0 : tools.length))
+        return [];
+    return tools
+        .filter(t => t.type === 'function' && t.function)
+        .map(t => ({
+        name: t.function.name,
+        description: t.function.description || '',
+        parameters: convertSchemaToGemini(t.function.parameters || {}),
+    }));
+}
+/** Clean/normalize a JSON Schema (strip cache_control, etc.) */
+function cleanSchema(schema) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    const result = Array.isArray(schema) ? [] : {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'cache_control' || key === 'x-cache-control')
+            continue;
+        if (key === 'additionalProperties' && value === false)
+            continue;
+        result[key] = typeof value === 'object' && value !== null ? cleanSchema(value) : value;
+    }
+    return result;
+}
+/** Recursively convert JSON Schema to Gemini format (type strings uppercased) */
+function convertSchemaToGemini(schema) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(convertSchemaToGemini);
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'type' && typeof value === 'string') {
+            result[key] = value.toUpperCase();
+        }
+        else if (key === 'properties') {
+            result[key] = {};
+            for (const [propName, propVal] of Object.entries(value)) {
+                result[key][propName] = convertSchemaToGemini(propVal);
+            }
+        }
+        else if (key === 'items') {
+            result[key] = convertSchemaToGemini(value);
+        }
+        else if (key === 'anyOf' || key === 'oneOf' || key === 'allOf') {
+            result[key] = value.map(convertSchemaToGemini);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            result[key] = convertSchemaToGemini(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/** Recursively convert Gemini schema back to JSON Schema (type strings lowercased) */
+function convertSchemaFromGemini(schema) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    if (Array.isArray(schema))
+        return schema.map(convertSchemaFromGemini);
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        if (key === 'type' && typeof value === 'string') {
+            result[key] = value.toLowerCase();
+        }
+        else if (key === 'properties') {
+            result[key] = {};
+            for (const [propName, propVal] of Object.entries(value)) {
+                result[key][propName] = convertSchemaFromGemini(propVal);
+            }
+        }
+        else if (key === 'items') {
+            result[key] = convertSchemaFromGemini(value);
+        }
+        else if (typeof value === 'object' && value !== null) {
+            result[key] = convertSchemaFromGemini(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/dist/server/conversions/utils/usage.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Usage/token count mapping across all API formats.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionsToClaudeUsage = completionsToClaudeUsage;
+exports.claudeToCompletionsUsage = claudeToCompletionsUsage;
+exports.geminiToClaudeUsage = geminiToClaudeUsage;
+exports.claudeToGeminiUsage = claudeToGeminiUsage;
+exports.responsesToClaudeUsage = responsesToClaudeUsage;
+exports.completionsToResponsesUsage = completionsToResponsesUsage;
+/** Map OpenAI Chat usage to Claude usage */
+function completionsToClaudeUsage(usage) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!usage)
+        return { input_tokens: 0, output_tokens: 0 };
+    return {
+        input_tokens: (_b = (_a = usage.input_tokens) !== null && _a !== void 0 ? _a : usage.prompt_tokens) !== null && _b !== void 0 ? _b : 0,
+        output_tokens: (_d = (_c = usage.output_tokens) !== null && _c !== void 0 ? _c : usage.completion_tokens) !== null && _d !== void 0 ? _d : 0,
+        cache_read_input_tokens: (_e = usage.cache_read_input_tokens) !== null && _e !== void 0 ? _e : (_f = usage.prompt_tokens_details) === null || _f === void 0 ? void 0 : _f.cached_tokens,
+        cache_creation_input_tokens: usage.cache_creation_input_tokens,
+    };
+}
+/** Map Claude usage to OpenAI Chat usage */
+function claudeToCompletionsUsage(usage) {
+    var _a, _b;
+    if (!usage)
+        return { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    const prompt = (_a = usage.input_tokens) !== null && _a !== void 0 ? _a : 0;
+    const completion = (_b = usage.output_tokens) !== null && _b !== void 0 ? _b : 0;
+    return {
+        prompt_tokens: prompt,
+        completion_tokens: completion,
+        total_tokens: prompt + completion,
+    };
+}
+/** Map Gemini usageMetadata to Claude usage */
+function geminiToClaudeUsage(metadata) {
+    var _a, _b, _c;
+    if (!metadata)
+        return { input_tokens: 0, output_tokens: 0 };
+    return {
+        input_tokens: (_a = metadata.promptTokenCount) !== null && _a !== void 0 ? _a : 0,
+        output_tokens: ((_b = metadata.totalTokenCount) !== null && _b !== void 0 ? _b : 0) - ((_c = metadata.promptTokenCount) !== null && _c !== void 0 ? _c : 0),
+    };
+}
+/** Map Claude usage to Gemini usageMetadata */
+function claudeToGeminiUsage(usage) {
+    var _a, _b;
+    if (!usage)
+        return {};
+    const input = (_a = usage.input_tokens) !== null && _a !== void 0 ? _a : 0;
+    const output = (_b = usage.output_tokens) !== null && _b !== void 0 ? _b : 0;
+    return {
+        promptTokenCount: input,
+        candidatesTokenCount: output,
+        totalTokenCount: input + output,
+    };
+}
+/** Map Responses API usage to Claude usage */
+function responsesToClaudeUsage(usage) {
+    var _a, _b, _c, _d;
+    if (!usage)
+        return { input_tokens: 0, output_tokens: 0 };
+    return {
+        input_tokens: (_a = usage.input_tokens) !== null && _a !== void 0 ? _a : 0,
+        output_tokens: (_b = usage.output_tokens) !== null && _b !== void 0 ? _b : 0,
+        cache_read_input_tokens: (_c = usage.cache_read_input_tokens) !== null && _c !== void 0 ? _c : (_d = usage.input_tokens_details) === null || _d === void 0 ? void 0 : _d.cached_tokens,
+        cache_creation_input_tokens: usage.cache_creation_input_tokens,
+    };
+}
+/** Map OpenAI Chat usage to Responses API usage */
+function completionsToResponsesUsage(usage) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    if (!usage)
+        return {};
+    return {
+        input_tokens: (_b = (_a = usage.input_tokens) !== null && _a !== void 0 ? _a : usage.prompt_tokens) !== null && _b !== void 0 ? _b : 0,
+        output_tokens: (_d = (_c = usage.output_tokens) !== null && _c !== void 0 ? _c : usage.completion_tokens) !== null && _d !== void 0 ? _d : 0,
+        total_tokens: (_e = usage.total_tokens) !== null && _e !== void 0 ? _e : (((_g = (_f = usage.input_tokens) !== null && _f !== void 0 ? _f : usage.prompt_tokens) !== null && _g !== void 0 ? _g : 0) + ((_j = (_h = usage.output_tokens) !== null && _h !== void 0 ? _h : usage.completion_tokens) !== null && _j !== void 0 ? _j : 0)),
+    };
+}