aicodeswitch 4.0.3 → 5.0.0

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

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Claude SSE → Gemini SSE streaming converter.
+ *
+ * ClaudeToGeminiConverter: Stateful converter for Claude SSE → Gemini SSE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeToGeminiConverter = void 0;
+const stop_reasons_js_1 = require("../../utils/stop-reasons.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * Stateful converter that transforms Claude SSE events into Gemini streaming
+ * chunks. Gemini streaming uses cumulative snapshots, so the converter
+ * accumulates Claude content and outputs Gemini cumulative candidate objects.
+ */
+class ClaudeToGeminiConverter {
+    constructor() {
+        Object.defineProperty(this, "textContent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "toolCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "currentToolJson", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+    }
+    convertEvent(event) {
+        var _a, _b, _c;
+        if (!event.data)
+            return [];
+        // Pass through [DONE]
+        if (event.data === '[DONE]' || (typeof event.data === 'object' && ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'done')) {
+            return [{ data: '[DONE]', event: event.event }];
+        }
+        try {
+            const parsed = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            const type = parsed.type;
+            const results = [];
+            switch (type) {
+                case 'message_start':
+                    // Nothing to emit for Gemini on start
+                    break;
+                case 'content_block_start': {
+                    const block = parsed.content_block;
+                    if ((block === null || block === void 0 ? void 0 : block.type) === 'text') {
+                        this.textContent = '';
+                    }
+                    else if ((block === null || block === void 0 ? void 0 : block.type) === 'tool_use') {
+                        this.currentToolJson = '';
+                    }
+                    break;
+                }
+                case 'content_block_delta': {
+                    const delta = parsed.delta;
+                    if ((delta === null || delta === void 0 ? void 0 : delta.type) === 'text_delta' && delta.text) {
+                        this.textContent += delta.text;
+                        // Emit cumulative snapshot
+                        results.push({
+                            data: this.buildCumulativeChunk(),
+                        });
+                    }
+                    else if ((delta === null || delta === void 0 ? void 0 : delta.type) === 'input_json_delta' && delta.partial_json) {
+                        this.currentToolJson += delta.partial_json;
+                    }
+                    break;
+                }
+                case 'content_block_stop': {
+                    // If we were accumulating a tool call, finalize it
+                    if (this.currentToolJson) {
+                        try {
+                            const args = JSON.parse(this.currentToolJson);
+                            this.toolCalls.push(args);
+                        }
+                        catch (_d) {
+                            this.toolCalls.push({ name: '', args: {}, raw: this.currentToolJson });
+                        }
+                        this.currentToolJson = '';
+                        // Emit snapshot with the new tool call included
+                        results.push({
+                            data: this.buildCumulativeChunk(),
+                        });
+                    }
+                    break;
+                }
+                case 'message_delta': {
+                    const stopReason = (0, stop_reasons_js_1.claudeToGeminiStopReason)((_b = parsed.delta) === null || _b === void 0 ? void 0 : _b.stop_reason);
+                    const usage = parsed.usage;
+                    const chunk = this.buildCumulativeChunk();
+                    // Set finishReason on the first candidate
+                    if ((_c = chunk.candidates) === null || _c === void 0 ? void 0 : _c[0]) {
+                        chunk.candidates[0].finishReason = stopReason;
+                    }
+                    if (usage === null || usage === void 0 ? void 0 : usage.output_tokens) {
+                        chunk.usageMetadata = chunk.usageMetadata || {};
+                        chunk.usageMetadata.candidatesTokenCount = usage.output_tokens;
+                    }
+                    results.push({ data: chunk });
+                    break;
+                }
+                case 'message_stop':
+                    // Nothing extra to emit
+                    break;
+            }
+            return results;
+        }
+        catch (_e) {
+            return [event];
+        }
+    }
+    // --- Helpers --------------------------------------------------------------
+    buildCumulativeChunk() {
+        const parts = [];
+        if (this.textContent) {
+            parts.push({ text: this.textContent });
+        }
+        for (const tc of this.toolCalls) {
+            parts.push({
+                functionCall: {
+                    name: tc.name || '',
+                    args: tc.args || tc,
+                },
+            });
+        }
+        return {
+            candidates: [
+                {
+                    content: {
+                        parts: parts.length > 0 ? parts : [],
+                        role: 'model',
+                    },
+                },
+            ],
+        };
+    }
+}
+exports.ClaudeToGeminiConverter = ClaudeToGeminiConverter;

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

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * Gemini generateContent → OpenAI Chat Completions request conversion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiToCompletions = geminiToCompletions;
+/**
+ * Convert a Gemini generateContent request body to a Chat Completions request body.
+ */
+function geminiToCompletions(body) {
+    var _a, _b, _c, _d;
+    const messages = [];
+    // --- System instruction → system message ---
+    if (body.systemInstruction) {
+        const text = (body.systemInstruction.parts || [])
+            .map((p) => p.text || '')
+            .join('\n\n');
+        if (text) {
+            messages.push({ role: 'system', content: text });
+        }
+    }
+    // --- Contents → messages ---
+    if (body.contents) {
+        for (const entry of body.contents) {
+            const role = entry.role === 'model' ? 'assistant' : 'user';
+            const converted = convertGeminiPartsToCompletionsMessage(entry.parts, role);
+            if (converted)
+                messages.push(converted);
+        }
+    }
+    // --- Build result ---
+    const result = {
+        messages,
+        stream: false,
+    };
+    // --- 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 = gc.stopSequences;
+    // --- Tools reverse mapping ---
+    const funcDecls = ((_a = body.tools) === null || _a === void 0 ? void 0 : _a.flatMap((t) => t.functionDeclarations || t)) || [];
+    if (funcDecls.length > 0) {
+        result.tools = funcDecls.map((fd) => ({
+            type: 'function',
+            function: {
+                name: fd.name,
+                description: fd.description || '',
+                parameters: fd.parameters || {},
+            },
+        }));
+    }
+    // --- 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 (((_c = fcc.allowedFunctionNames) === null || _c === void 0 ? void 0 : _c.length) === 1) {
+                result.tool_choice = { type: 'function', function: { name: fcc.allowedFunctionNames[0] } };
+            }
+            else {
+                result.tool_choice = 'required';
+            }
+        }
+        else if (fcc.mode === 'AUTO') {
+            result.tool_choice = 'auto';
+        }
+        else if (fcc.mode === 'NONE') {
+            result.tool_choice = 'none';
+        }
+    }
+    // --- Thinking config → reasoning_effort ---
+    if ((_d = gc.thinkingConfig) === null || _d === void 0 ? void 0 : _d.thinkingBudget) {
+        result.reasoning_effort = mapThinkingBudgetToEffort(gc.thinkingConfig.thinkingBudget);
+    }
+    return result;
+}
+/**
+ * Convert Gemini parts array to a Completions message object.
+ */
+function convertGeminiPartsToCompletionsMessage(parts, role) {
+    var _a;
+    if (!parts || parts.length === 0)
+        return { role, content: '' };
+    const texts = [];
+    const toolCalls = [];
+    let hasFunctionResponse = false;
+    let functionResponseContent;
+    let functionResponseName;
+    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 || {}),
+                },
+            });
+        }
+        else if (part.functionResponse) {
+            hasFunctionResponse = true;
+            functionResponseName = part.functionResponse.name;
+            functionResponseContent = ((_a = part.functionResponse.response) === null || _a === void 0 ? void 0 : _a.content)
+                || JSON.stringify(part.functionResponse.response);
+        }
+        else if (part.inlineData) {
+            texts.push(`data:${part.inlineData.mimeType};base64,${part.inlineData.data}`);
+        }
+    }
+    // Tool result message
+    if (hasFunctionResponse) {
+        return {
+            role: 'tool',
+            tool_call_id: functionResponseName || '',
+            content: functionResponseContent || '',
+        };
+    }
+    // Assistant message with tool calls
+    if (role === 'assistant' && toolCalls.length > 0) {
+        return {
+            role: 'assistant',
+            content: texts.join('') || null,
+            tool_calls: toolCalls,
+        };
+    }
+    // Plain message
+    return {
+        role,
+        content: texts.join('') || '',
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function mapThinkingBudgetToEffort(budget) {
+    if (budget <= 4096)
+        return 'low';
+    if (budget <= 16384)
+        return 'medium';
+    return 'high';
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Completions → Gemini response conversion for gemini-completions pair.
+ *
+ * Client=gemini, upstream=completions.
+ * Converts upstream Chat Completions response → client Gemini generateContent response.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionsToGeminiResponse = completionsToGeminiResponse;
+const format_mappers_js_1 = require("../../utils/format-mappers.js");
+/**
+ * Convert a Chat Completions response to a Gemini generateContent response.
+ */
+function completionsToGeminiResponse(response) {
+    var _a, _b, _c, _d, _e, _f;
+    const choice = (_a = response.choices) === null || _a === void 0 ? void 0 : _a[0];
+    if (!choice)
+        return response;
+    const parts = [];
+    // Text content
+    if ((_b = choice.message) === null || _b === void 0 ? void 0 : _b.content) {
+        parts.push({ text: choice.message.content });
+    }
+    // Tool calls → functionCall parts
+    if ((_c = choice.message) === null || _c === void 0 ? void 0 : _c.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+            const args = typeof ((_d = tc.function) === null || _d === void 0 ? void 0 : _d.arguments) === 'string'
+                ? JSON.parse(tc.function.arguments)
+                : ((_e = tc.function) === null || _e === void 0 ? void 0 : _e.arguments) || {};
+            parts.push({
+                functionCall: {
+                    name: ((_f = tc.function) === null || _f === void 0 ? void 0 : _f.name) || '',
+                    args,
+                },
+            });
+        }
+    }
+    if (parts.length === 0) {
+        parts.push({ text: '' });
+    }
+    const finishReason = (0, format_mappers_js_1.mapCompletionsFinishReason)(choice.finish_reason);
+    const usage = (0, format_mappers_js_1.mapCompletionsUsage)(response.usage);
+    return {
+        candidates: [{
+                content: {
+                    role: 'model',
+                    parts,
+                },
+                finishReason,
+            }],
+        usageMetadata: usage,
+        modelVersion: response.model || '',
+    };
+}

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

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * OpenAI Chat Completions → Gemini generateContent streaming conversion.
+ *
+ * Stateful converter that processes Chat Completions SSE events and produces
+ * Gemini SSE events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionsToGeminiConverter = void 0;
+const format_mappers_js_1 = require("../../utils/format-mappers.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * Convert Chat Completions SSE events into Gemini generateContent SSE events.
+ *
+ * Accumulates text content and tool calls, emitting cumulative Gemini snapshots.
+ */
+class CompletionsToGeminiConverter {
+    constructor() {
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "textContent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "toolCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    convertEvent(event) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        if (!event.data)
+            return [];
+        if (event.data === '[DONE]' || (typeof event.data === 'object' && ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'done'))
+            return this.flush();
+        try {
+            const chunk = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            const delta = (_c = (_b = chunk.choices) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.delta;
+            const finishReason = (_e = (_d = chunk.choices) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.finish_reason;
+            const parts = [];
+            // Text delta → accumulate and emit cumulative text
+            if (delta === null || delta === void 0 ? void 0 : delta.content) {
+                this.textContent += delta.content;
+                parts.push({ text: this.textContent });
+            }
+            // Reasoning content → no Gemini equivalent, skip
+            // Tool calls → accumulate arguments and emit functionCall
+            if (Array.isArray(delta === null || delta === void 0 ? void 0 : delta.tool_calls)) {
+                for (const tc of delta.tool_calls) {
+                    const idx = (_f = tc.index) !== null && _f !== void 0 ? _f : 0;
+                    const existing = this.toolCalls.get(idx);
+                    if (!existing && ((_g = tc.function) === null || _g === void 0 ? void 0 : _g.name)) {
+                        this.toolCalls.set(idx, {
+                            name: tc.function.name,
+                            argumentsText: ((_h = tc.function) === null || _h === void 0 ? void 0 : _h.arguments) || '',
+                        });
+                    }
+                    else if (existing && ((_j = tc.function) === null || _j === void 0 ? void 0 : _j.arguments)) {
+                        existing.argumentsText += tc.function.arguments;
+                    }
+                }
+                // Emit accumulated tool calls as functionCall parts
+                for (const [, tc] of this.toolCalls) {
+                    parts.push({
+                        functionCall: {
+                            name: tc.name,
+                            args: JSON.parse(tc.argumentsText || '{}'),
+                        },
+                    });
+                }
+            }
+            if (parts.length > 0 || !this.started) {
+                const candidate = {
+                    content: { role: 'model', parts: parts.length > 0 ? parts : [{ text: '' }] },
+                };
+                if (finishReason) {
+                    candidate.finishReason = (0, format_mappers_js_1.mapCompletionsFinishReason)(finishReason);
+                }
+                const result = { candidates: [candidate] };
+                if (chunk.usage) {
+                    result.usageMetadata = {
+                        promptTokenCount: (_k = chunk.usage.prompt_tokens) !== null && _k !== void 0 ? _k : 0,
+                        candidatesTokenCount: (_l = chunk.usage.completion_tokens) !== null && _l !== void 0 ? _l : 0,
+                        totalTokenCount: (_m = chunk.usage.total_tokens) !== null && _m !== void 0 ? _m : 0,
+                    };
+                }
+                this.started = true;
+                return [{ data: result, event: '' }];
+            }
+            return [];
+        }
+        catch (_o) {
+            return [event];
+        }
+    }
+    flush() {
+        return [];
+    }
+}
+exports.CompletionsToGeminiConverter = CompletionsToGeminiConverter;

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

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Gemini → Responses API composite request conversion.
+ *
+ * Composes: gemini → completions → responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiToResponsesRequest = geminiToResponsesRequest;
+const request_js_1 = require("../gemini-completions/request.js");
+const request_js_2 = require("../completions-responses/request.js");
+/**
+ * Convert a Gemini request to a Responses API request.
+ * Path: gemini → completions → responses
+ */
+function geminiToResponsesRequest(body) {
+    const completionsBody = (0, request_js_1.geminiToCompletions)(body);
+    return (0, request_js_2.completionsToResponses)(completionsBody);
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Responses API → Gemini composite response conversion.
+ *
+ * Composes: responses → completions → gemini
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responsesToGeminiResponse = responsesToGeminiResponse;
+const response_js_1 = require("../completions-responses/response.js");
+const response_js_2 = require("../gemini-completions/response.js");
+/**
+ * Convert a Responses API response to a Gemini response.
+ * Path: responses → completions → gemini
+ */
+function responsesToGeminiResponse(response) {
+    const completionsResponse = (0, response_js_1.responsesToCompletionsResponse)(response);
+    return (0, response_js_2.completionsToGeminiResponse)(completionsResponse);
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Composite streaming converter: Responses API SSE → Gemini SSE.
+ *
+ * Chains: ResponsesToCompletionsConverter → CompletionsToGeminiConverter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsesToGeminiConverter = void 0;
+const streaming_js_1 = require("../completions-responses/streaming.js");
+const streaming_js_2 = require("../gemini-completions/streaming.js");
+const streaming_helpers_js_1 = require("../../utils/streaming-helpers.js");
+/**
+ * Composite converter: Responses API SSE → Completions SSE → Gemini SSE
+ */
+class ResponsesToGeminiConverter {
+    constructor() {
+        Object.defineProperty(this, "first", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "second", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.first = new streaming_js_1.ResponsesToCompletionsConverter();
+        this.second = new streaming_js_2.CompletionsToGeminiConverter();
+    }
+    convertEvent(event) {
+        const intermediate = this.first.convertEvent(event);
+        return intermediate.flatMap((e) => this.second.convertEvent(e));
+    }
+    flush() {
+        const intermediate = (0, streaming_helpers_js_1.flushConverter)(this.first);
+        const secondFromIntermediate = intermediate.flatMap((e) => this.second.convertEvent(e));
+        const secondFlush = (0, streaming_helpers_js_1.flushConverter)(this.second);
+        return [...secondFromIntermediate, ...secondFlush];
+    }
+}
+exports.ResponsesToGeminiConverter = ResponsesToGeminiConverter;