aicodeswitch 4.0.3 → 5.0.0

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

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * OpenAI Chat Completions → OpenAI Responses API request conversion.
+ *
+ * Handles the mapping from Chat Completions' role-based messages array
+ * to the Responses API's flat input items (message, function_call,
+ * function_call_output, reasoning).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionsToResponses = completionsToResponses;
+const id_js_1 = require("../../utils/id.js");
+/**
+ * Convert a Chat Completions request body to an OpenAI Responses API request body.
+ */
+function completionsToResponses(body) {
+    var _a, _b, _c;
+    const input = [];
+    let instructions;
+    // --- Extract system messages -> instructions ---
+    for (const msg of body.messages) {
+        if (msg.role === 'system' || msg.role === 'developer') {
+            const text = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+            instructions = instructions ? instructions + '\n' + text : text;
+        }
+    }
+    // --- Convert messages -> input array ---
+    for (const msg of body.messages) {
+        if (msg.role === 'system' || msg.role === 'developer') {
+            continue; // already extracted as instructions
+        }
+        if (msg.role === 'user') {
+            input.push({
+                type: 'message',
+                role: 'user',
+                content: [{ type: 'input_text', text: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content) }],
+            });
+        }
+        else if (msg.role === 'assistant') {
+            // reasoning_content -> reasoning item
+            if (msg.reasoning_content) {
+                input.push({
+                    type: 'reasoning',
+                    id: (0, id_js_1.generateCallId)().replace('call_', 'rs_'),
+                    summary: [{ type: 'summary_text', text: msg.reasoning_content }],
+                });
+            }
+            // tool_calls -> function_call items
+            if (msg.tool_calls && msg.tool_calls.length > 0) {
+                for (const tc of msg.tool_calls) {
+                    input.push({
+                        type: 'function_call',
+                        call_id: tc.id,
+                        name: ((_a = tc.function) === null || _a === void 0 ? void 0 : _a.name) || '',
+                        arguments: ((_b = tc.function) === null || _b === void 0 ? void 0 : _b.arguments) || '{}',
+                    });
+                }
+                // If there is also text content, emit a message item first
+                if (msg.content) {
+                    // Insert message before the function_calls we just added
+                    const msgItem = {
+                        type: 'message',
+                        role: 'assistant',
+                        content: [{ type: 'output_text', text: msg.content }],
+                    };
+                    // Find where tool_calls start and insert the message there
+                    const firstToolIdx = input.length - msg.tool_calls.length;
+                    input.splice(firstToolIdx, 0, msgItem);
+                }
+            }
+            else if (msg.content) {
+                // Plain assistant message
+                input.push({
+                    type: 'message',
+                    role: 'assistant',
+                    content: [{ type: 'output_text', text: msg.content }],
+                });
+            }
+        }
+        else if (msg.role === 'tool') {
+            input.push({
+                type: 'function_call_output',
+                call_id: msg.tool_call_id,
+                content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            });
+        }
+    }
+    // --- Build result ---
+    const result = {
+        model: body.model,
+        input,
+        stream: (_c = body.stream) !== null && _c !== void 0 ? _c : false,
+    };
+    if (instructions)
+        result.instructions = instructions;
+    if (body.max_tokens !== undefined)
+        result.max_output_tokens = body.max_tokens;
+    if (body.max_completion_tokens !== undefined)
+        result.max_output_tokens = body.max_completion_tokens;
+    if (body.temperature !== undefined)
+        result.temperature = body.temperature;
+    if (body.top_p !== undefined)
+        result.top_p = body.top_p;
+    // --- Reasoning effort ---
+    if (body.reasoning_effort) {
+        result.reasoning = { effort: body.reasoning_effort };
+    }
+    // --- Tools ---
+    if (body.tools && body.tools.length > 0) {
+        result.tools = body.tools
+            .filter((t) => t.type === 'function' && t.function)
+            .map((t) => ({
+            type: 'function',
+            name: t.function.name,
+            description: t.function.description || '',
+            parameters: t.function.parameters || {},
+        }));
+    }
+    // --- Tool choice reverse mapping ---
+    if (body.tool_choice !== undefined) {
+        result.tool_choice = completionsToResponsesToolChoice(body.tool_choice);
+    }
+    return result;
+}
+/**
+ * Map Chat Completions tool_choice to Responses API tool_choice.
+ */
+function completionsToResponsesToolChoice(toolChoice) {
+    if (typeof toolChoice === 'string') {
+        switch (toolChoice) {
+            case 'any':
+            case 'required': return 'required';
+            case 'auto': return 'auto';
+            case 'none': return 'none';
+            default: return 'auto';
+        }
+    }
+    if (typeof toolChoice === 'object') {
+        if (toolChoice.type === 'function' && toolChoice.function) {
+            return { type: 'function', name: toolChoice.function.name };
+        }
+        if (toolChoice.type === 'any')
+            return 'required';
+        if (toolChoice.type === 'auto')
+            return 'auto';
+        if (toolChoice.type === 'none')
+            return 'none';
+    }
+    return 'auto';
+}

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

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * OpenAI Responses API → OpenAI Chat Completions response conversion.
+ *
+ * Converts a Responses API response into a Chat Completions response.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsesToCompletionsResponse = responsesToCompletionsResponse;
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const id_js_1 = require("../../utils/id.js");
+/**
+ * Convert a Responses API response to a Chat Completions response.
+ */
+function responsesToCompletionsResponse(response) {
+    var _a;
+    const output = response.output || [];
+    let content = '';
+    let reasoningContent;
+    const toolCalls = [];
+    for (const item of output) {
+        if (item.type === 'message') {
+            // Join output_text texts
+            const texts = (item.content || [])
+                .filter((c) => c.type === 'output_text')
+                .map((c) => c.text || '');
+            content += texts.join('');
+        }
+        else if (item.type === 'reasoning') {
+            // Join summary texts
+            const summaries = (item.summary || [])
+                .map((s) => s.text || '')
+                .filter(Boolean);
+            if (summaries.length > 0) {
+                reasoningContent = (reasoningContent || '') + summaries.join('\n');
+            }
+        }
+        else if (item.type === 'function_call') {
+            toolCalls.push({
+                id: item.call_id,
+                type: 'function',
+                function: {
+                    name: item.name || '',
+                    arguments: item.arguments || '{}',
+                },
+            });
+        }
+    }
+    const message = {
+        role: 'assistant',
+        content: content || null,
+    };
+    if (reasoningContent) {
+        message.reasoning_content = reasoningContent;
+    }
+    if (toolCalls.length > 0) {
+        message.tool_calls = toolCalls;
+    }
+    const finishReason = (0, stop_reasons_js_1.responsesToCompletionsFinishReason)(response.status);
+    const usage = response.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+    return {
+        id: ((_a = response.id) === null || _a === void 0 ? void 0 : _a.startsWith('chatcmpl-')) ? response.id : (0, id_js_1.generateCompletionsId)(),
+        object: 'chat.completion',
+        created: response.created_at || Math.floor(Date.now() / 1000),
+        model: response.model,
+        choices: [
+            {
+                index: 0,
+                message,
+                finish_reason: finishReason,
+            },
+        ],
+        usage,
+    };
+}

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

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * OpenAI Responses API → OpenAI Chat Completions streaming conversion.
+ *
+ * Stateless converter that processes Responses API SSE events and produces
+ * Chat Completions SSE chunks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsesToCompletionsConverter = 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 Responses API SSE events into Chat Completions SSE chunks.
+ */
+class ResponsesToCompletionsConverter {
+    constructor() {
+        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: ''
+        });
+    }
+    convertEvent(event) {
+        var _a, _b;
+        if (!event.data)
+            return [];
+        if (event.data === '[DONE]' || ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'done') {
+            return [{ data: '[DONE]', event: '' }];
+        }
+        try {
+            const eventName = event.event;
+            const parsed = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            const chunks = [];
+            switch (eventName) {
+                case 'response.created': {
+                    // First chunk with id, model
+                    this.chatId = ((_b = parsed.id) === null || _b === void 0 ? void 0 : _b.startsWith('chatcmpl-')) ? parsed.id : (0, id_js_1.generateCompletionsId)();
+                    this.model = parsed.model || '';
+                    chunks.push({
+                        event: '',
+                        data: {
+                            id: this.chatId,
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model: this.model,
+                            choices: [{
+                                    index: 0,
+                                    delta: { role: 'assistant', content: '' },
+                                    finish_reason: null,
+                                }],
+                        },
+                    });
+                    break;
+                }
+                case 'response.output_text.delta': {
+                    // Text content delta
+                    chunks.push({
+                        event: '',
+                        data: {
+                            id: this.chatId,
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model: this.model,
+                            choices: [{
+                                    index: 0,
+                                    delta: { content: parsed.text || '' },
+                                    finish_reason: null,
+                                }],
+                        },
+                    });
+                    break;
+                }
+                case 'response.reasoning.delta':
+                case 'response.reasoning_summary_text.delta': {
+                    // Reasoning content delta
+                    const text = parsed.text || parsed.delta || '';
+                    if (text) {
+                        chunks.push({
+                            event: '',
+                            data: {
+                                id: this.chatId,
+                                object: 'chat.completion.chunk',
+                                created: Math.floor(Date.now() / 1000),
+                                model: this.model,
+                                choices: [{
+                                        index: 0,
+                                        delta: { reasoning_content: text },
+                                        finish_reason: null,
+                                    }],
+                            },
+                        });
+                    }
+                    break;
+                }
+                case 'response.output_item.added': {
+                    // function_call added
+                    if (parsed.type === 'function_call') {
+                        chunks.push({
+                            event: '',
+                            data: {
+                                id: this.chatId,
+                                object: 'chat.completion.chunk',
+                                created: Math.floor(Date.now() / 1000),
+                                model: this.model,
+                                choices: [{
+                                        index: 0,
+                                        delta: {
+                                            tool_calls: [{
+                                                    id: parsed.call_id || parsed.id,
+                                                    type: 'function',
+                                                    function: {
+                                                        name: parsed.name || '',
+                                                        arguments: '',
+                                                    },
+                                                }],
+                                        },
+                                        finish_reason: null,
+                                    }],
+                            },
+                        });
+                    }
+                    break;
+                }
+                case 'response.function_call_arguments.delta': {
+                    // Function call arguments fragment
+                    const argsDelta = parsed.delta || '';
+                    if (argsDelta) {
+                        chunks.push({
+                            event: '',
+                            data: {
+                                id: this.chatId,
+                                object: 'chat.completion.chunk',
+                                created: Math.floor(Date.now() / 1000),
+                                model: this.model,
+                                choices: [{
+                                        index: 0,
+                                        delta: {
+                                            tool_calls: [{
+                                                    function: { arguments: argsDelta },
+                                                }],
+                                        },
+                                        finish_reason: null,
+                                    }],
+                            },
+                        });
+                    }
+                    break;
+                }
+                case 'response.completed': {
+                    // Final chunk with finish_reason and usage
+                    const finishReason = (0, stop_reasons_js_1.responsesToCompletionsFinishReason)(parsed.status);
+                    const usage = parsed.usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
+                    chunks.push({
+                        event: '',
+                        data: {
+                            id: this.chatId,
+                            object: 'chat.completion.chunk',
+                            created: Math.floor(Date.now() / 1000),
+                            model: this.model || parsed.model || '',
+                            choices: [{
+                                    index: 0,
+                                    delta: {},
+                                    finish_reason: finishReason,
+                                }],
+                            usage,
+                        },
+                    });
+                    break;
+                }
+                // Events not mapped to Chat format: silently skip
+                default:
+                    break;
+            }
+            return chunks;
+        }
+        catch (_c) {
+            return [event];
+        }
+    }
+}
+exports.ResponsesToCompletionsConverter = ResponsesToCompletionsConverter;

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

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Gemini generateContent → Claude Messages request conversion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiToClaude = geminiToClaude;
+const tool_schema_js_1 = require("../../utils/tool-schema.js");
+const id_js_1 = require("../../utils/id.js");
+/**
+ * Convert a Gemini generateContent request body to a Claude Messages request body.
+ */
+function geminiToClaude(body) {
+    var _a, _b;
+    const messages = [];
+    // --- System instruction → system ------------------------------------------
+    let system;
+    if (body.systemInstruction) {
+        const parts = body.systemInstruction.parts || [];
+        system = parts.map((p) => p.text || '').join('\n\n');
+    }
+    // --- Contents → messages --------------------------------------------------
+    if (body.contents) {
+        for (const entry of body.contents) {
+            const role = entry.role === 'model' ? 'assistant' : 'user';
+            const content = convertGeminiPartsToClaudeContent(entry.parts);
+            messages.push({ role, content });
+        }
+    }
+    // --- Build result ---------------------------------------------------------
+    const result = {
+        messages,
+        stream: false,
+    };
+    if (system)
+        result.system = system;
+    // --- Generation config reverse mapping ------------------------------------
+    const gc = body.generationConfig || {};
+    if (gc.maxOutputTokens)
+        result.max_tokens = gc.maxOutputTokens;
+    if (gc.temperature !== undefined)
+        result.temperature = gc.temperature;
+    if (gc.topP !== undefined)
+        result.top_p = gc.topP;
+    if (gc.stopSequences)
+        result.stop_sequences = gc.stopSequences;
+    // --- Tools reverse mapping ------------------------------------------------
+    const functionDeclarations = ((_a = body.tools) === null || _a === void 0 ? void 0 : _a.flatMap((t) => t.functionDeclarations || t)) || [];
+    if (functionDeclarations.length > 0) {
+        result.tools = (0, tool_schema_js_1.geminiToClaudeTools)(functionDeclarations);
+    }
+    // --- ToolConfig reverse mapping -------------------------------------------
+    if ((_b = body.toolConfig) === null || _b === void 0 ? void 0 : _b.functionCallingConfig) {
+        const fcc = body.toolConfig.functionCallingConfig;
+        if (fcc.mode === 'ANY') {
+            if (fcc.allowedFunctionNames && fcc.allowedFunctionNames.length === 1) {
+                result.tool_choice = { type: 'tool', name: fcc.allowedFunctionNames[0] };
+            }
+            else {
+                result.tool_choice = { type: 'any' };
+            }
+        }
+        else if (fcc.mode === 'AUTO') {
+            result.tool_choice = { type: 'auto' };
+        }
+        else if (fcc.mode === 'NONE') {
+            result.tool_choice = { type: 'none' };
+        }
+    }
+    return result;
+}
+/**
+ * Convert Gemini parts array into Claude content (string or content block array).
+ */
+function convertGeminiPartsToClaudeContent(parts) {
+    var _a;
+    if (!parts || parts.length === 0)
+        return '';
+    const blocks = [];
+    for (const part of parts) {
+        if (part.text !== undefined && part.text !== null) {
+            blocks.push({ type: 'text', text: part.text });
+        }
+        else if (part.functionCall) {
+            blocks.push({
+                type: 'tool_use',
+                id: (0, id_js_1.generateToolUseId)(),
+                name: part.functionCall.name,
+                input: part.functionCall.args || {},
+            });
+        }
+        else if (part.functionResponse) {
+            const content = ((_a = part.functionResponse.response) === null || _a === void 0 ? void 0 : _a.content) ||
+                JSON.stringify(part.functionResponse.response);
+            blocks.push({
+                type: 'tool_result',
+                tool_use_id: part.functionResponse.name,
+                content,
+            });
+        }
+        else if (part.inlineData) {
+            blocks.push({
+                type: 'image',
+                source: {
+                    type: 'base64',
+                    media_type: part.inlineData.mimeType,
+                    data: part.inlineData.data,
+                },
+            });
+        }
+    }
+    if (blocks.length === 0)
+        return '';
+    // If there is a single text block, return as plain string
+    if (blocks.length === 1 && blocks[0].type === 'text') {
+        return blocks[0].text;
+    }
+    return blocks;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Claude Messages → Gemini generateContent response conversion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeToGeminiResponse = claudeToGeminiResponse;
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const usage_js_1 = require("../../utils/usage.js");
+/**
+ * Convert a Claude Messages response into a Gemini generateContent response.
+ */
+function claudeToGeminiResponse(response) {
+    const parts = [];
+    for (const block of response.content || []) {
+        if (block.type === 'text') {
+            parts.push({ text: block.text });
+        }
+        else if (block.type === 'tool_use') {
+            parts.push({
+                functionCall: {
+                    name: block.name,
+                    args: block.input,
+                },
+            });
+        }
+        else if (block.type === 'thinking') {
+            // Skip thinking blocks — Gemini has no equivalent
+            continue;
+        }
+    }
+    const finishReason = (0, stop_reasons_js_1.claudeToGeminiStopReason)(response.stop_reason);
+    const usageMetadata = (0, usage_js_1.claudeToGeminiUsage)(response.usage);
+    return {
+        candidates: [
+            {
+                content: {
+                    parts,
+                    role: 'model',
+                },
+                finishReason,
+            },
+        ],
+        usageMetadata,
+    };
+}