aicodeswitch 4.0.4 → 5.0.0

package/dist/server/conversions/pairs/completions-claude/response.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * Claude Messages → OpenAI Chat Completions response conversion.
+ *
+ * Converts a Claude Messages response into a Chat Completions response.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeResponseToCompletions = claudeResponseToCompletions;
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const usage_js_1 = require("../../utils/usage.js");
+const id_js_1 = require("../../utils/id.js");
+/**
+ * Convert a Claude Messages response into an OpenAI Chat Completions response.
+ */
+function claudeResponseToCompletions(response) {
+    const content = response.content || [];
+    let textContent = '';
+    let reasoningContent;
+    const toolCalls = [];
+    for (const block of content) {
+        if (block.type === 'thinking') {
+            // Extract thinking text into reasoning_content field
+            reasoningContent = (reasoningContent || '') + (block.thinking || '');
+        }
+        else if (block.type === 'text') {
+            textContent += block.text;
+        }
+        else if (block.type === 'tool_use') {
+            toolCalls.push({
+                id: block.id,
+                type: 'function',
+                function: {
+                    name: block.name,
+                    arguments: typeof block.input === 'string'
+                        ? block.input
+                        : JSON.stringify(block.input),
+                },
+            });
+        }
+    }
+    const message = {
+        role: 'assistant',
+        content: textContent || null,
+    };
+    if (reasoningContent) {
+        message.reasoning_content = reasoningContent;
+    }
+    if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+    }
+    const finishReason = (0, stop_reasons_js_1.claudeToCompletionsStopReason)(response.stop_reason);
+    const usage = (0, usage_js_1.claudeToCompletionsUsage)(response.usage);
+    return {
+        id: response.id || (0, id_js_1.generateCompletionsId)(),
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: response.model,
+        choices: [
+            {
+                index: 0,
+                message,
+                finish_reason: finishReason,
+            },
+        ],
+        usage,
+    };
+}

package/dist/server/conversions/pairs/completions-claude/streaming.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Claude Messages → OpenAI Chat Completions streaming conversion.
+ *
+ * Stateless converter that processes Claude SSE events and produces
+ * OpenAI Chat Completions SSE chunks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeToCompletionsConverter = void 0;
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const id_js_1 = require("../../utils/id.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * Convert Claude Messages SSE events into OpenAI Chat Completions SSE chunks.
+ */
+class ClaudeToCompletionsConverter {
+    convertEvent(event) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!event.data || event.data === '[DONE]' || ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'done') {
+            return [{ data: '[DONE]', event: '' }];
+        }
+        try {
+            const parsed = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            const chunks = [];
+            switch (parsed.type) {
+                case 'message_start': {
+                    chunks.push({
+                        id: ((_b = parsed.message) === null || _b === void 0 ? void 0 : _b.id) || (0, id_js_1.generateCompletionsId)(),
+                        object: 'chat.completion.chunk',
+                        created: Math.floor(Date.now() / 1000),
+                        model: ((_c = parsed.message) === null || _c === void 0 ? void 0 : _c.model) || '',
+                        choices: [
+                            {
+                                index: 0,
+                                delta: { role: 'assistant', content: '' },
+                                finish_reason: null,
+                            },
+                        ],
+                    });
+                    break;
+                }
+                case 'content_block_start': {
+                    if (((_d = parsed.content_block) === null || _d === void 0 ? void 0 : _d.type) === 'tool_use') {
+                        chunks.push({
+                            id: (0, id_js_1.generateCompletionsId)(),
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model: '',
+                            choices: [
+                                {
+                                    index: 0,
+                                    delta: {
+                                        tool_calls: [
+                                            {
+                                                index: parsed.index || 0,
+                                                id: parsed.content_block.id,
+                                                type: 'function',
+                                                function: {
+                                                    name: parsed.content_block.name || '',
+                                                    arguments: '',
+                                                },
+                                            },
+                                        ],
+                                    },
+                                    finish_reason: null,
+                                },
+                            ],
+                        });
+                    }
+                    // text and thinking blocks do not emit on start — deltas follow
+                    break;
+                }
+                case 'content_block_delta': {
+                    if (((_e = parsed.delta) === null || _e === void 0 ? void 0 : _e.type) === 'thinking_delta') {
+                        // thinking delta → reasoning_content
+                        chunks.push({
+                            id: (0, id_js_1.generateCompletionsId)(),
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model: '',
+                            choices: [
+                                {
+                                    index: 0,
+                                    delta: { reasoning_content: parsed.delta.thinking },
+                                    finish_reason: null,
+                                },
+                            ],
+                        });
+                    }
+                    else if (((_f = parsed.delta) === null || _f === void 0 ? void 0 : _f.type) === 'text_delta') {
+                        chunks.push({
+                            id: (0, id_js_1.generateCompletionsId)(),
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model: '',
+                            choices: [
+                                {
+                                    index: 0,
+                                    delta: { content: parsed.delta.text },
+                                    finish_reason: null,
+                                },
+                            ],
+                        });
+                    }
+                    else if (((_g = parsed.delta) === null || _g === void 0 ? void 0 : _g.type) === 'input_json_delta') {
+                        chunks.push({
+                            id: (0, id_js_1.generateCompletionsId)(),
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model: '',
+                            choices: [
+                                {
+                                    index: 0,
+                                    delta: {
+                                        tool_calls: [
+                                            {
+                                                index: parsed.index || 0,
+                                                function: { arguments: parsed.delta.partial_json },
+                                            },
+                                        ],
+                                    },
+                                    finish_reason: null,
+                                },
+                            ],
+                        });
+                    }
+                    break;
+                }
+                case 'message_delta': {
+                    const finishReason = (0, stop_reasons_js_1.claudeToCompletionsStopReason)((_h = parsed.delta) === null || _h === void 0 ? void 0 : _h.stop_reason);
+                    chunks.push({
+                        id: (0, id_js_1.generateCompletionsId)(),
+                        object: 'chat.completion.chunk',
+                        created: Math.floor(Date.now() / 1000),
+                        model: '',
+                        choices: [
+                            {
+                                index: 0,
+                                delta: {},
+                                finish_reason: finishReason,
+                            },
+                        ],
+                        usage: parsed.usage
+                            ? {
+                                prompt_tokens: 0,
+                                completion_tokens: parsed.usage.output_tokens || 0,
+                                total_tokens: parsed.usage.output_tokens || 0,
+                            }
+                            : undefined,
+                    });
+                    break;
+                }
+                // message_stop, content_block_stop, ping — no OpenAI equivalent
+                default:
+                    break;
+            }
+            // OpenAI SSE does not use named events (event: is empty string)
+            return chunks.map((data) => ({ data, event: '' }));
+        }
+        catch (_j) {
+            return [event];
+        }
+    }
+}
+exports.ClaudeToCompletionsConverter = ClaudeToCompletionsConverter;

package/dist/server/conversions/pairs/completions-gemini/request.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * OpenAI Chat Completions → Gemini generateContent request conversion.
+ *
+ * Direct mapping without Claude intermediate — preserves all fields:
+ * - function_call / tool_calls ↔ functionCall / functionResponse
+ * - system message → systemInstruction
+ * - generationConfig mapping
+ * - tool_choice ↔ toolConfig
+ * - images (inlineData) ↔ base64 image content
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionsToGemini = completionsToGemini;
+const tool_schema_js_1 = require("../../utils/tool-schema.js");
+/**
+ * Convert a Chat Completions request body to a Gemini generateContent request body.
+ */
+function completionsToGemini(body) {
+    var _a;
+    const contents = [];
+    let systemInstruction = undefined;
+    for (const msg of body.messages || []) {
+        if (msg.role === 'system' || msg.role === 'developer') {
+            // System messages → systemInstruction (merge multiple)
+            const text = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+            if (systemInstruction) {
+                systemInstruction.parts[0].text += '\n\n' + text;
+            }
+            else {
+                systemInstruction = { parts: [{ text }] };
+            }
+            continue;
+        }
+        const role = msg.role === 'assistant' ? 'model' : 'user';
+        const parts = convertCompletionsMessageToGeminiParts(msg);
+        contents.push({ role, parts });
+    }
+    // --- Generation config ---
+    const generationConfig = {};
+    if (body.max_tokens)
+        generationConfig.maxOutputTokens = body.max_tokens;
+    if (body.max_completion_tokens)
+        generationConfig.maxOutputTokens = body.max_completion_tokens;
+    if (body.temperature !== undefined)
+        generationConfig.temperature = body.temperature;
+    if (body.top_p !== undefined)
+        generationConfig.topP = body.top_p;
+    if (body.stop) {
+        generationConfig.stopSequences = Array.isArray(body.stop) ? body.stop : [body.stop];
+    }
+    // --- Build result ---
+    const result = {
+        contents,
+        generationConfig,
+    };
+    if (systemInstruction)
+        result.systemInstruction = systemInstruction;
+    if (body.model)
+        result.model = body.model;
+    if (body.stream !== undefined)
+        result.stream = body.stream;
+    // --- Tools ---
+    if (body.tools && body.tools.length > 0) {
+        const functionDeclarations = (0, tool_schema_js_1.completionsToGeminiTools)(body.tools);
+        if (functionDeclarations.length > 0) {
+            result.tools = [{ functionDeclarations }];
+        }
+    }
+    // --- Tool choice → toolConfig ---
+    if (body.tool_choice !== undefined) {
+        const tc = body.tool_choice;
+        if (tc === 'required' || tc === 'any') {
+            result.toolConfig = { functionCallingConfig: { mode: 'ANY' } };
+        }
+        else if (tc === 'auto') {
+            result.toolConfig = { functionCallingConfig: { mode: 'AUTO' } };
+        }
+        else if (tc === 'none') {
+            result.toolConfig = { functionCallingConfig: { mode: 'NONE' } };
+        }
+        else if (typeof tc === 'object') {
+            if (tc.type === 'function' && ((_a = tc.function) === null || _a === void 0 ? void 0 : _a.name)) {
+                result.toolConfig = {
+                    functionCallingConfig: { mode: 'ANY', allowedFunctionNames: [tc.function.name] },
+                };
+            }
+            else if (tc.type === 'required' || tc.type === 'any') {
+                result.toolConfig = { functionCallingConfig: { mode: 'ANY' } };
+            }
+        }
+    }
+    // --- Reasoning effort → thinking config ---
+    if (body.reasoning_effort) {
+        result.generationConfig.thinkingConfig = {
+            thinkingBudget: mapEffortToThinkingBudget(body.reasoning_effort),
+        };
+    }
+    return result;
+}
+/**
+ * Convert a single Completions message to Gemini parts.
+ */
+function convertCompletionsMessageToGeminiParts(msg) {
+    var _a, _b, _c, _d;
+    const parts = [];
+    // reasoning_content → skip (no Gemini equivalent, but we don't lose it
+    // because it stays in the request context as history)
+    // Text content
+    if (msg.content && typeof msg.content === 'string') {
+        parts.push({ text: msg.content });
+    }
+    else if (msg.content && typeof msg.content === 'object') {
+        // Array content (multimodal)
+        for (const item of Array.isArray(msg.content) ? msg.content : [msg.content]) {
+            if (item.type === 'text') {
+                parts.push({ text: item.text });
+            }
+            else if (item.type === 'image_url') {
+                // data URL → inlineData
+                const url = ((_a = item.image_url) === null || _a === void 0 ? void 0 : _a.url) || '';
+                if (url.startsWith('data:')) {
+                    const match = url.match(/^data:([^;]+);base64,(.+)$/);
+                    if (match) {
+                        parts.push({ inlineData: { mimeType: match[1], data: match[2] } });
+                    }
+                }
+                else {
+                    parts.push({ text: url }); // fallback: pass URL as text
+                }
+            }
+        }
+    }
+    // Tool calls → functionCall parts
+    if (msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+            const args = typeof ((_b = tc.function) === null || _b === void 0 ? void 0 : _b.arguments) === 'string'
+                ? JSON.parse(tc.function.arguments)
+                : ((_c = tc.function) === null || _c === void 0 ? void 0 : _c.arguments) || {};
+            parts.push({
+                functionCall: {
+                    name: ((_d = tc.function) === null || _d === void 0 ? void 0 : _d.name) || '',
+                    args,
+                },
+            });
+        }
+    }
+    // Tool result → functionResponse part
+    if (msg.role === 'tool') {
+        const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+        parts.push({
+            functionResponse: {
+                name: msg.name || msg.tool_call_id || '',
+                response: { content },
+            },
+        });
+    }
+    return parts.length > 0 ? parts : [{ text: '' }];
+}
+/**
+ * Map reasoning_effort string to Gemini thinkingBudget number.
+ */
+function mapEffortToThinkingBudget(effort) {
+    switch (effort) {
+        case 'low': return 2048;
+        case 'medium': return 8192;
+        case 'high': return 24576;
+        default: return 8192;
+    }
+}

package/dist/server/conversions/pairs/completions-gemini/response.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Gemini generateContent → OpenAI Chat Completions response conversion.
+ *
+ * Converts a Gemini response into a Chat Completions response.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiToCompletionsResponse = geminiToCompletionsResponse;
+const id_js_1 = require("../../utils/id.js");
+const format_mappers_js_1 = require("../../utils/format-mappers.js");
+/**
+ * Convert a Gemini generateContent response to a Chat Completions response.
+ */
+function geminiToCompletionsResponse(response) {
+    var _a, _b;
+    const candidate = (_a = response.candidates) === null || _a === void 0 ? void 0 : _a[0];
+    if (!candidate) {
+        return {
+            id: (0, id_js_1.generateCompletionsId)(),
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: response.modelVersion || '',
+            choices: [{
+                    index: 0,
+                    message: { role: 'assistant', content: '' },
+                    finish_reason: 'stop',
+                }],
+            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+        };
+    }
+    const parts = ((_b = candidate.content) === null || _b === void 0 ? void 0 : _b.parts) || [];
+    const message = { role: 'assistant', content: null };
+    const texts = [];
+    const toolCalls = [];
+    for (const part of parts) {
+        if (part.text !== undefined && part.text !== null) {
+            texts.push(part.text);
+        }
+        else if (part.functionCall) {
+            toolCalls.push({
+                id: `call_${Math.random().toString(36).slice(2, 14)}`,
+                type: 'function',
+                function: {
+                    name: part.functionCall.name || '',
+                    arguments: typeof part.functionCall.args === 'string'
+                        ? part.functionCall.args
+                        : JSON.stringify(part.functionCall.args || {}),
+                },
+            });
+        }
+    }
+    message.content = texts.join('') || null;
+    if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+    }
+    const finishReason = (0, format_mappers_js_1.mapGeminiFinishReason)(candidate.finishReason);
+    const usage = (0, format_mappers_js_1.mapGeminiUsage)(response.usageMetadata);
+    return {
+        id: (0, id_js_1.generateCompletionsId)(),
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: response.modelVersion || '',
+        choices: [{
+                index: 0,
+                message,
+                finish_reason: finishReason,
+            }],
+        usage,
+    };
+}

package/dist/server/conversions/pairs/completions-gemini/streaming.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Gemini SSE → Completions SSE streaming converter.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiToCompletionsConverter = void 0;
+const id_js_1 = require("../../utils/id.js");
+const format_mappers_js_1 = require("../../utils/format-mappers.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * Stateful converter that transforms Gemini streaming chunks into
+ * Chat Completions SSE events.
+ */
+class GeminiToCompletionsConverter {
+    constructor() {
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "chatId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, id_js_1.generateCompletionsId)()
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "textContent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "toolCallIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    convertEvent(event) {
+        var _a, _b, _c, _d, _e;
+        if (!event.data)
+            return [];
+        try {
+            const parsed = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            const chunks = [];
+            // Gemini streams candidates as cumulative snapshots
+            const candidate = (_a = parsed.candidates) === null || _a === void 0 ? void 0 : _a[0];
+            if (!candidate)
+                return [];
+            const parts = ((_b = candidate.content) === null || _b === void 0 ? void 0 : _b.parts) || [];
+            if (!this.started) {
+                this.model = parsed.modelVersion || '';
+                // Emit initial chunk with role
+                chunks.push(this.makeChunk({ role: 'assistant', content: '' }, null));
+                this.started = true;
+            }
+            // Process parts (diff against what we've already emitted)
+            for (const part of parts) {
+                if (part.text !== undefined && part.text !== null) {
+                    const newText = part.text.substring(this.textContent.length);
+                    if (newText) {
+                        chunks.push(this.makeChunk({ content: newText }, null));
+                    }
+                    this.textContent = part.text;
+                }
+                else if (part.functionCall) {
+                    // Emit tool call start
+                    const tcId = `call_${Math.random().toString(36).slice(2, 14)}`;
+                    chunks.push(this.makeChunk({
+                        tool_calls: [{
+                                index: this.toolCallIndex,
+                                id: tcId,
+                                type: 'function',
+                                function: {
+                                    name: part.functionCall.name || '',
+                                    arguments: typeof part.functionCall.args === 'string'
+                                        ? part.functionCall.args
+                                        : JSON.stringify(part.functionCall.args || {}),
+                                },
+                            }],
+                    }, null));
+                    this.toolCallIndex++;
+                }
+            }
+            // Finish reason
+            if (candidate.finishReason) {
+                const finishReason = (0, format_mappers_js_1.mapGeminiFinishReason)(candidate.finishReason);
+                const usage = parsed.usageMetadata
+                    ? {
+                        prompt_tokens: (_c = parsed.usageMetadata.promptTokenCount) !== null && _c !== void 0 ? _c : 0,
+                        completion_tokens: (_d = parsed.usageMetadata.candidatesTokenCount) !== null && _d !== void 0 ? _d : 0,
+                        total_tokens: (_e = parsed.usageMetadata.totalTokenCount) !== null && _e !== void 0 ? _e : 0,
+                    }
+                    : undefined;
+                chunks.push(this.makeChunk({}, finishReason, usage));
+            }
+            return chunks;
+        }
+        catch (_f) {
+            return [event];
+        }
+    }
+    flush() {
+        // Gemini streaming is cumulative, no state to flush
+        return [];
+    }
+    makeChunk(delta, finishReason, usage) {
+        const chunk = {
+            id: this.chatId,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: this.model,
+            choices: [{
+                    index: 0,
+                    delta,
+                    finish_reason: finishReason,
+                }],
+        };
+        if (usage)
+            chunk.usage = usage;
+        return { data: chunk, event: '' };
+    }
+}
+exports.GeminiToCompletionsConverter = GeminiToCompletionsConverter;