aicodeswitch 4.0.4 → 5.1.0

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

@@ -0,0 +1,259 @@
+"use strict";
+/**
+ * OpenAI Chat Completions SSE → Claude Messages SSE streaming conversion.
+ *
+ * Stateful converter that processes SSE events from an OpenAI Chat Completions
+ * upstream and emits Claude Messages SSE events, enhanced with reasoning_content /
+ * thinking block support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompletionsToClaudeConverter = 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");
+/**
+ * Stateful converter: OpenAI Chat SSE → Claude Messages SSE.
+ */
+class CompletionsToClaudeConverter {
+    constructor() {
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "messageStopped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** Tracks which non-tool content block is currently open: null | 'thinking' | 'text' */
+        Object.defineProperty(this, "currentBlockType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** Index of the currently open block; -1 when no block is open */
+        Object.defineProperty(this, "currentBlockIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        /** Monotonically increasing block index counter */
+        Object.defineProperty(this, "nextBlockIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        /** Accumulated tool calls keyed by their OpenAI index */
+        Object.defineProperty(this, "toolCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "nextToolOrder", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "outputTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "pendingStopReason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "messageId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, id_js_1.generateMessageId)()
+        });
+    }
+    // ---- StreamConverter interface ------------------------------------------
+    convertEvent(event) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!event.data)
+            return [];
+        if (event.data === '[DONE]' || ((_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 events = [];
+            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 messageToolCalls = (_h = (_g = (_f = chunk.choices) === null || _f === void 0 ? void 0 : _f[0]) === null || _g === void 0 ? void 0 : _g.message) === null || _h === void 0 ? void 0 : _h.tool_calls;
+            const usage = chunk.usage;
+            if (usage === null || usage === void 0 ? void 0 : usage.completion_tokens) {
+                this.outputTokens = usage.completion_tokens;
+            }
+            // Emit message_start on first chunk
+            if (!this.started) {
+                events.push({
+                    type: 'message_start',
+                    message: {
+                        id: this.messageId,
+                        type: 'message',
+                        role: 'assistant',
+                        content: [],
+                        model: chunk.model || '',
+                        stop_reason: null,
+                        stop_sequence: null,
+                        usage: { input_tokens: 0, output_tokens: 0 },
+                    },
+                });
+                this.started = true;
+            }
+            // --- Reasoning content (NEW) ----------------------------------------
+            if (!this.messageStopped && (delta === null || delta === void 0 ? void 0 : delta.reasoning_content)) {
+                if (this.currentBlockType !== 'thinking') {
+                    this.closeCurrentBlock(events);
+                    this.openBlock(events, 'thinking');
+                }
+                events.push({
+                    type: 'content_block_delta',
+                    index: this.currentBlockIndex,
+                    delta: { type: 'thinking_delta', thinking: delta.reasoning_content },
+                });
+            }
+            // --- Text content ---------------------------------------------------
+            if (!this.messageStopped && (delta === null || delta === void 0 ? void 0 : delta.content)) {
+                if (this.currentBlockType !== 'text') {
+                    this.closeCurrentBlock(events);
+                    this.openBlock(events, 'text');
+                }
+                events.push({
+                    type: 'content_block_delta',
+                    index: this.currentBlockIndex,
+                    delta: { type: 'text_delta', text: delta.content },
+                });
+            }
+            // --- Tool calls (from delta) ----------------------------------------
+            if (!this.messageStopped &&
+                Array.isArray(delta === null || delta === void 0 ? void 0 : delta.tool_calls) &&
+                delta.tool_calls.length > 0) {
+                this.closeCurrentBlock(events);
+                this.captureToolCalls(delta.tool_calls);
+            }
+            // --- Tool calls (from message-level, some providers) ----------------
+            if (!this.messageStopped &&
+                Array.isArray(messageToolCalls) &&
+                messageToolCalls.length > 0) {
+                this.closeCurrentBlock(events);
+                this.captureToolCalls(messageToolCalls);
+            }
+            // --- Finish reason (dedup — skip if already set) --------------------
+            if (finishReason && !this.messageStopped && this.pendingStopReason === null) {
+                this.pendingStopReason = (0, stop_reasons_js_1.completionsToClaudeStopReason)(finishReason);
+            }
+            return events.length > 0
+                ? events.map((data) => ({
+                    data,
+                    event: data.type || event.event,
+                }))
+                : [];
+        }
+        catch (_j) {
+            return [event];
+        }
+    }
+    flush() {
+        if (this.messageStopped || !this.started)
+            return [];
+        const events = [];
+        this.closeCurrentBlock(events);
+        this.flushToolCalls(events);
+        events.push({
+            type: 'message_delta',
+            delta: {
+                stop_reason: this.pendingStopReason || 'end_turn',
+                stop_sequence: null,
+            },
+            usage: { output_tokens: this.outputTokens },
+        });
+        events.push({ type: 'message_stop' });
+        this.messageStopped = true;
+        return events.map((data) => ({ data, event: data.type }));
+    }
+    // ---- Private helpers ---------------------------------------------------
+    /** Open a new content block of the given type */
+    openBlock(events, type) {
+        this.currentBlockIndex = this.nextBlockIndex++;
+        this.currentBlockType = type;
+        if (type === 'thinking') {
+            events.push({
+                type: 'content_block_start',
+                index: this.currentBlockIndex,
+                content_block: { type: 'thinking', thinking: '' },
+            });
+        }
+        else {
+            events.push({
+                type: 'content_block_start',
+                index: this.currentBlockIndex,
+                content_block: { type: 'text', text: '' },
+            });
+        }
+    }
+    /** Close the currently open content block, if any */
+    closeCurrentBlock(events) {
+        if (this.currentBlockIndex >= 0) {
+            events.push({ type: 'content_block_stop', index: this.currentBlockIndex });
+            this.currentBlockIndex = -1;
+            this.currentBlockType = null;
+        }
+    }
+    /** Accumulate tool call fragments from delta */
+    captureToolCalls(toolCalls) {
+        var _a, _b, _c;
+        for (const tc of toolCalls) {
+            const toolIdx = (_a = tc.index) !== null && _a !== void 0 ? _a : 0;
+            const current = this.toolCalls.get(toolIdx) || {
+                argumentsText: '',
+                order: this.nextToolOrder++,
+            };
+            if (tc.id)
+                current.id = tc.id;
+            if ((_b = tc.function) === null || _b === void 0 ? void 0 : _b.name)
+                current.name = tc.function.name;
+            const fragment = (0, streaming_helpers_js_1.normalizeToolArgumentsFragment)((_c = tc.function) === null || _c === void 0 ? void 0 : _c.arguments);
+            if (fragment)
+                current.argumentsText += fragment;
+            this.toolCalls.set(toolIdx, current);
+        }
+    }
+    /** Emit complete tool_use blocks for all accumulated tool calls */
+    flushToolCalls(events) {
+        const sorted = [...this.toolCalls.entries()].sort((a, b) => a[1].order - b[1].order);
+        for (const [, toolCall] of sorted) {
+            const idx = this.nextBlockIndex++;
+            const id = toolCall.id || (0, id_js_1.generateToolUseId)();
+            events.push({
+                type: 'content_block_start',
+                index: idx,
+                content_block: { type: 'tool_use', id, name: toolCall.name || '', input: {} },
+            });
+            if (toolCall.argumentsText) {
+                events.push({
+                    type: 'content_block_delta',
+                    index: idx,
+                    delta: { type: 'input_json_delta', partial_json: toolCall.argumentsText },
+                });
+            }
+            events.push({ type: 'content_block_stop', index: idx });
+        }
+        this.toolCalls.clear();
+    }
+}
+exports.CompletionsToClaudeConverter = CompletionsToClaudeConverter;

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

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * Claude Messages → Gemini generateContent request conversion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeToGemini = claudeToGemini;
+const tool_schema_js_1 = require("../../utils/tool-schema.js");
+/**
+ * Convert a Claude Messages request body to a Gemini generateContent request body.
+ */
+function claudeToGemini(body) {
+    const contents = [];
+    // --- System instruction ---------------------------------------------------
+    const systemInstruction = body.system
+        ? {
+            parts: [
+                {
+                    text: typeof body.system === 'string'
+                        ? body.system
+                        : Array.isArray(body.system)
+                            ? body.system
+                                .filter((s) => s.type === 'text' || typeof s.text === 'string')
+                                .map((s) => s.text || '')
+                                .join('\n\n')
+                            : '',
+                },
+            ],
+        }
+        : undefined;
+    // --- Messages → contents --------------------------------------------------
+    if (body.messages) {
+        for (const msg of body.messages) {
+            const role = msg.role === 'assistant' ? 'model' : 'user';
+            const parts = convertClaudeContentToGeminiParts(msg.content);
+            contents.push({ role, parts });
+        }
+    }
+    // --- Generation config ----------------------------------------------------
+    const generationConfig = {};
+    if (body.max_tokens)
+        generationConfig.maxOutputTokens = body.max_tokens;
+    if (body.temperature !== undefined)
+        generationConfig.temperature = body.temperature;
+    if (body.top_p !== undefined)
+        generationConfig.topP = body.top_p;
+    if (body.stop_sequences)
+        generationConfig.stopSequences = body.stop_sequences;
+    // --- Build result ---------------------------------------------------------
+    const result = {
+        contents,
+        generationConfig,
+    };
+    if (systemInstruction)
+        result.systemInstruction = systemInstruction;
+    // --- Tools ----------------------------------------------------------------
+    if (body.tools && body.tools.length > 0) {
+        const functionDeclarations = (0, tool_schema_js_1.claudeToGeminiTools)(body.tools);
+        if (functionDeclarations.length > 0) {
+            result.tools = [{ functionDeclarations }];
+        }
+    }
+    // --- Tool choice → toolConfig ---------------------------------------------
+    if (body.tool_choice) {
+        const tc = body.tool_choice;
+        if (tc.type === 'any') {
+            result.toolConfig = { functionCallingConfig: { mode: 'ANY' } };
+        }
+        else if (tc.type === 'auto') {
+            result.toolConfig = { functionCallingConfig: { mode: 'AUTO' } };
+        }
+        else if (tc.type === 'none') {
+            result.toolConfig = { functionCallingConfig: { mode: 'NONE' } };
+        }
+        else if (tc.type === 'tool' && tc.name) {
+            result.toolConfig = {
+                functionCallingConfig: { mode: 'ANY', allowedFunctionNames: [tc.name] },
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Convert Claude content blocks (or string) into Gemini parts array.
+ */
+function convertClaudeContentToGeminiParts(content) {
+    if (typeof content === 'string') {
+        return [{ text: content }];
+    }
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const block of content) {
+            if (block.type === 'text') {
+                parts.push({ text: block.text });
+            }
+            else if (block.type === 'image') {
+                parts.push({
+                    inlineData: {
+                        mimeType: block.source.media_type,
+                        data: block.source.data,
+                    },
+                });
+            }
+            else if (block.type === 'tool_use') {
+                parts.push({
+                    functionCall: {
+                        name: block.name,
+                        args: block.input,
+                    },
+                });
+            }
+            else if (block.type === 'tool_result') {
+                const resultContent = typeof block.content === 'string'
+                    ? block.content
+                    : JSON.stringify(block.content);
+                parts.push({
+                    functionResponse: {
+                        name: block.tool_use_id,
+                        response: { content: resultContent },
+                    },
+                });
+            }
+            else if (block.type === 'thinking') {
+                // Skip thinking blocks
+                continue;
+            }
+        }
+        return parts.length > 0 ? parts : [{ text: '' }];
+    }
+    return [{ text: String(content) }];
+}

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

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Gemini generateContent → Claude Messages response conversion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiToClaudeResponse = geminiToClaudeResponse;
+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 Gemini generateContent response into a Claude Messages response.
+ */
+function geminiToClaudeResponse(response) {
+    var _a, _b, _c;
+    const candidate = (_a = response.candidates) === null || _a === void 0 ? void 0 : _a[0];
+    // Handle prompt feedback / blocked response
+    if (!candidate) {
+        const blockReason = (_b = response.promptFeedback) === null || _b === void 0 ? void 0 : _b.blockReason;
+        if (blockReason) {
+            return {
+                id: (0, id_js_1.generateMessageId)(),
+                type: 'message',
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'text',
+                        text: `Response blocked: ${blockReason}`,
+                    },
+                ],
+                model: '',
+                stop_reason: 'end_turn',
+                stop_sequence: null,
+                usage: { input_tokens: 0, output_tokens: 0 },
+            };
+        }
+        return response;
+    }
+    const content = [];
+    const parts = ((_c = candidate.content) === null || _c === void 0 ? void 0 : _c.parts) || [];
+    for (const part of parts) {
+        if (part.text) {
+            content.push({ type: 'text', text: part.text });
+        }
+        if (part.functionCall) {
+            content.push({
+                type: 'tool_use',
+                id: (0, id_js_1.generateToolUseId)(),
+                name: part.functionCall.name,
+                input: part.functionCall.args || {},
+            });
+        }
+    }
+    const stopReason = (0, stop_reasons_js_1.geminiToClaudeStopReason)(candidate.finishReason);
+    const usage = (0, usage_js_1.geminiToClaudeUsage)(response.usageMetadata);
+    return {
+        id: (0, id_js_1.generateMessageId)(),
+        type: 'message',
+        role: 'assistant',
+        content,
+        model: response.modelVersion || '',
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage,
+    };
+}

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

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * Gemini SSE → Claude Messages SSE streaming conversion.
+ *
+ * Stateful converter that transforms Gemini streaming chunks into Claude SSE events.
+ * Gemini streams using cumulative snapshots (each chunk contains the full text so
+ * far), so the converter must track the previously-seen text and emit only the diff
+ * as `text_delta` events in the Claude protocol.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiToClaudeConverter = 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");
+/**
+ * Stateful converter: Gemini SSE → Claude Messages SSE.
+ */
+class GeminiToClaudeConverter {
+    constructor() {
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "messageStopped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "currentBlockType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "currentBlockIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: -1
+        });
+        Object.defineProperty(this, "nextBlockIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "outputTokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "messageId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (0, id_js_1.generateMessageId)()
+        });
+        Object.defineProperty(this, "previousText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+    }
+    convertEvent(event) {
+        var _a, _b, _c;
+        // [DONE] passthrough
+        if (!event.data || event.data === '[DONE]' || ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'done') {
+            return [{ data: '[DONE]', event: event.event }];
+        }
+        try {
+            const chunk = (0, streaming_helpers_js_1.parseEventData)(event.data);
+            const events = [];
+            const candidates = chunk.candidates || [];
+            const usage = chunk.usageMetadata || {};
+            if (usage.candidatesTokenCount) {
+                this.outputTokens = usage.candidatesTokenCount;
+            }
+            // Emit message_start on first chunk
+            if (!this.started) {
+                events.push({
+                    type: 'message_start',
+                    message: {
+                        id: this.messageId,
+                        type: 'message',
+                        role: 'assistant',
+                        content: [],
+                        model: chunk.modelVersion || '',
+                        stop_reason: null,
+                        stop_sequence: null,
+                        usage: { input_tokens: 0, output_tokens: 0 },
+                    },
+                });
+                this.started = true;
+            }
+            for (const candidate of candidates) {
+                const parts = ((_b = candidate.content) === null || _b === void 0 ? void 0 : _b.parts) || [];
+                for (const part of parts) {
+                    // Text part — handle cumulative snapshots via diffing
+                    if (!this.messageStopped && part.text !== undefined && part.text !== null) {
+                        const diff = part.text.substring(this.previousText.length);
+                        this.previousText = part.text;
+                        if (diff) {
+                            this.ensureTextBlock(events);
+                            events.push({
+                                type: 'content_block_delta',
+                                index: this.currentBlockIndex,
+                                delta: { type: 'text_delta', text: diff },
+                            });
+                        }
+                    }
+                    // Function call — close text block first, then emit complete tool_use block
+                    if (!this.messageStopped && part.functionCall) {
+                        this.closeTextBlock(events);
+                        emitToolUseBlock(events, {
+                            index: this.nextBlockIndex++,
+                            id: (0, id_js_1.generateToolUseId)(),
+                            name: part.functionCall.name || '',
+                            inputJson: JSON.stringify((_c = part.functionCall.args) !== null && _c !== void 0 ? _c : {}),
+                        });
+                    }
+                }
+                // Finish reason → close and finalize
+                if (candidate.finishReason && !this.messageStopped) {
+                    this.closeTextBlock(events);
+                    events.push({
+                        type: 'message_delta',
+                        delta: {
+                            stop_reason: (0, stop_reasons_js_1.geminiToClaudeStopReason)(candidate.finishReason),
+                            stop_sequence: null,
+                        },
+                        usage: { output_tokens: this.outputTokens },
+                    });
+                    events.push({ type: 'message_stop' });
+                    this.messageStopped = true;
+                }
+            }
+            return events.length > 0
+                ? events.map((data) => ({
+                    data,
+                    event: data.type || event.event,
+                }))
+                : [];
+        }
+        catch (_d) {
+            return [event];
+        }
+    }
+    // --- Helpers --------------------------------------------------------------
+    ensureTextBlock(events) {
+        if (this.currentBlockType === 'text' && this.currentBlockIndex >= 0)
+            return;
+        this.currentBlockIndex = this.nextBlockIndex++;
+        this.currentBlockType = 'text';
+        events.push({
+            type: 'content_block_start',
+            index: this.currentBlockIndex,
+            content_block: { type: 'text', text: '' },
+        });
+    }
+    closeTextBlock(events) {
+        if (this.currentBlockType === 'text' && this.currentBlockIndex >= 0) {
+            events.push({ type: 'content_block_stop', index: this.currentBlockIndex });
+            this.currentBlockType = null;
+            this.currentBlockIndex = -1;
+        }
+    }
+}
+exports.GeminiToClaudeConverter = GeminiToClaudeConverter;
+// ---------------------------------------------------------------------------
+// Shared helpers
+// ---------------------------------------------------------------------------
+/**
+ * Emit a complete tool_use block (start + delta + stop) into the events array.
+ */
+function emitToolUseBlock(events, tool) {
+    events.push({
+        type: 'content_block_start',
+        index: tool.index,
+        content_block: {
+            type: 'tool_use',
+            id: tool.id,
+            name: tool.name,
+            input: {},
+        },
+    });
+    if (tool.inputJson) {
+        events.push({
+            type: 'content_block_delta',
+            index: tool.index,
+            delta: { type: 'input_json_delta', partial_json: tool.inputJson },
+        });
+    }
+    events.push({ type: 'content_block_stop', index: tool.index });
+}