aicodeswitch 3.0.3 → 3.0.4

package/dist/server/transformers/streaming.js

@@ -1,11 +1,41 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaudeToOpenAIChatEventTransform = exports.OpenAIToClaudeEventTransform = exports.rewriteStream = exports.SSESerializerTransform = exports.SSEParserTransform = void 0;
+exports.GeminiToOpenAIChatEventTransform = exports.GeminiToClaudeEventTransform = exports.ClaudeToOpenAIChatEventTransform = exports.OpenAIToClaudeEventTransform = exports.rewriteStream = exports.SSESerializerTransform = exports.SSEParserTransform = void 0;
 const stream_1 = require("stream");
-const crypto_1 = __importDefault(require("crypto"));
+const crypto = __importStar(require("crypto"));
 const claude_openai_1 = require("./claude-openai");
 class SSEParserTransform extends stream_1.Transform {
     constructor() {
@@ -349,7 +379,7 @@ class OpenAIToClaudeEventTransform extends stream_1.Transform {
         if (this.hasMessageStart)
             return;
         const message = {
-            id: this.messageId || `msg_${crypto_1.default.randomUUID()}`,
+            id: this.messageId || `msg_${crypto.randomUUID()}`,
             type: 'message',
             role: 'assistant',
             content: [],
@@ -561,7 +591,7 @@ class OpenAIToClaudeEventTransform extends stream_1.Transform {
         if (this.finalized)
             return;
         this.ensureMessageStart();
-        for (const toolBlockIndex of this.toolCallIndexToBlockIndex.values()) {
+        for (const toolBlockIndex of Array.from(this.toolCallIndexToBlockIndex.values())) {
             this.pushEvent('content_block_stop', {
                 type: 'content_block_stop',
                 index: toolBlockIndex,
@@ -818,3 +848,529 @@ class ClaudeToOpenAIChatEventTransform extends stream_1.Transform {
     }
 }
 exports.ClaudeToOpenAIChatEventTransform = ClaudeToOpenAIChatEventTransform;
+// ============================================================================
+// Gemini 流式转换器
+// ============================================================================
+/**
+ * 将 Gemini SSE 流式事件转换为 Claude 格式
+ */
+class GeminiToClaudeEventTransform extends stream_1.Transform {
+    constructor(options) {
+        var _a;
+        super({ objectMode: true });
+        Object.defineProperty(this, "contentIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "textBlockIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "toolCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "toolCallIndexToBlockIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "hasMessageStart", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "stopReason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'end_turn'
+        });
+        Object.defineProperty(this, "usage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "messageId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "finalized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "errorEmitted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "accumulatedText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        }); // 累积每个候选的文本
+        Object.defineProperty(this, "accumulatedToolCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.model = (_a = options === null || options === void 0 ? void 0 : options.model) !== null && _a !== void 0 ? _a : null;
+        this.on('error', (err) => {
+            console.error('[GeminiToClaudeEventTransform] Stream error:', err);
+            this.errorEmitted = true;
+        });
+    }
+    getUsage() {
+        if (!this.usage)
+            return undefined;
+        return Object.assign({}, this.usage);
+    }
+    _transform(event, _encoding, callback) {
+        var _a;
+        if (this.errorEmitted) {
+            callback();
+            return;
+        }
+        try {
+            if (this.finalized) {
+                callback();
+                return;
+            }
+            if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'done') {
+                this.finalize();
+                callback();
+                return;
+            }
+            const chunk = event.data;
+            if (!chunk) {
+                callback();
+                return;
+            }
+            // Gemini 流式响应格式: { candidates: [{ content: { parts: [...] }, finishReason: ... }], usageMetadata: {...} }
+            const candidates = Array.isArray(chunk.candidates) ? chunk.candidates : [];
+            const usageMetadata = chunk.usageMetadata;
+            // 处理 usage
+            if (usageMetadata) {
+                this.usage = {
+                    input_tokens: usageMetadata.promptTokenCount || 0,
+                    output_tokens: usageMetadata.candidatesTokenCount || 0,
+                    cache_read_input_tokens: usageMetadata.cachedContentTokenCount || 0,
+                };
+            }
+            // 处理 candidates
+            for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) {
+                const candidate = candidates[candidateIndex];
+                const content = candidate.content;
+                // 处理 finishReason
+                if (candidate.finishReason) {
+                    this.stopReason = this.mapGeminiFinishReason(candidate.finishReason);
+                }
+                if (!content || !Array.isArray(content.parts)) {
+                    continue;
+                }
+                this.ensureMessageStart();
+                // 处理 parts
+                for (const part of content.parts) {
+                    // 处理文本
+                    if (part.text && typeof part.text === 'string') {
+                        if (this.textBlockIndex === null) {
+                            this.textBlockIndex = this.assignContentBlockIndex();
+                            this.pushEvent('content_block_start', {
+                                type: 'content_block_start',
+                                index: this.textBlockIndex,
+                                content_block: { type: 'text' },
+                            });
+                        }
+                        // 累积文本
+                        const currentText = this.accumulatedText.get(candidateIndex) || '';
+                        this.accumulatedText.set(candidateIndex, currentText + part.text);
+                        this.pushEvent('content_block_delta', {
+                            type: 'content_block_delta',
+                            index: this.textBlockIndex,
+                            delta: {
+                                type: 'text_delta',
+                                text: part.text,
+                            },
+                        });
+                    }
+                    // 处理 functionCall -> tool_use
+                    if (part.functionCall) {
+                        const toolCalls = this.accumulatedToolCalls.get(candidateIndex) || [];
+                        toolCalls.push({
+                            name: part.functionCall.name || 'tool',
+                            args: part.functionCall.args || {},
+                        });
+                        this.accumulatedToolCalls.set(candidateIndex, toolCalls);
+                        const toolBlockIndex = this.assignContentBlockIndex();
+                        this.toolCalls.set(toolCalls.length - 1, {
+                            id: `tool_${toolCalls.length}_${Date.now()}`,
+                            name: part.functionCall.name || 'tool',
+                            arguments: JSON.stringify(part.functionCall.args || {}),
+                        });
+                        this.toolCallIndexToBlockIndex.set(toolCalls.length - 1, toolBlockIndex);
+                        this.pushEvent('content_block_start', {
+                            type: 'content_block_start',
+                            index: toolBlockIndex,
+                            content_block: {
+                                type: 'tool_use',
+                                id: this.toolCalls.get(toolCalls.length - 1).id,
+                                name: part.functionCall.name || 'tool',
+                            },
+                        });
+                        // 发送完整的参数
+                        this.pushEvent('content_block_delta', {
+                            type: 'content_block_delta',
+                            index: toolBlockIndex,
+                            delta: {
+                                type: 'input_json_delta',
+                                partial_json: JSON.stringify(part.functionCall.args || {}),
+                            },
+                        });
+                    }
+                    // 处理 inlineData (图像输出，罕见)
+                    if (part.inlineData) {
+                        // 图像输出作为单独的内容块
+                        const imageBlockIndex = this.assignContentBlockIndex();
+                        this.pushEvent('content_block_start', {
+                            type: 'content_block_start',
+                            index: imageBlockIndex,
+                            content_block: {
+                                type: 'image',
+                                source: {
+                                    type: 'base64',
+                                    media_type: part.inlineData.mimeType,
+                                    data: part.inlineData.data,
+                                },
+                            },
+                        });
+                        this.pushEvent('content_block_stop', {
+                            type: 'content_block_stop',
+                            index: imageBlockIndex,
+                        });
+                    }
+                }
+            }
+            callback();
+        }
+        catch (error) {
+            console.error('[GeminiToClaudeEventTransform] Error in _transform:', error);
+            callback();
+        }
+    }
+    _flush(callback) {
+        try {
+            this.finalize();
+            callback();
+        }
+        catch (error) {
+            console.error('[GeminiToClaudeEventTransform] Error in _flush:', error);
+            callback();
+        }
+    }
+    assignContentBlockIndex() {
+        const index = this.contentIndex;
+        this.contentIndex += 1;
+        return index;
+    }
+    pushEvent(type, data) {
+        this.push({ event: type, data });
+    }
+    ensureMessageStart() {
+        if (this.hasMessageStart)
+            return;
+        const message = {
+            id: this.messageId || `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            type: 'message',
+            role: 'assistant',
+            content: [],
+            model: this.model || 'gemini',
+            stop_reason: null,
+            stop_sequence: null,
+            usage: {
+                input_tokens: 0,
+                output_tokens: 0,
+            },
+        };
+        this.pushEvent('message_start', { type: 'message_start', message });
+        this.hasMessageStart = true;
+    }
+    mapGeminiFinishReason(finishReason) {
+        switch (finishReason) {
+            case 'STOP':
+                return 'end_turn';
+            case 'MAX_TOKENS':
+                return 'max_tokens';
+            case 'SAFETY':
+            case 'RECITATION':
+                return 'content_filter';
+            case 'MALFORMED_FUNCTION_CALL':
+                return 'tool_use';
+            default:
+                return 'end_turn';
+        }
+    }
+    finalize() {
+        if (this.finalized)
+            return;
+        this.ensureMessageStart();
+        // 关闭所有工具调用块
+        for (const toolBlockIndex of Array.from(this.toolCallIndexToBlockIndex.values())) {
+            this.pushEvent('content_block_stop', {
+                type: 'content_block_stop',
+                index: toolBlockIndex,
+            });
+        }
+        // 关闭文本块
+        if (this.textBlockIndex !== null) {
+            this.pushEvent('content_block_stop', {
+                type: 'content_block_stop',
+                index: this.textBlockIndex,
+            });
+            this.textBlockIndex = null;
+        }
+        const usage = this.usage || {
+            input_tokens: 0,
+            output_tokens: 0,
+            cache_read_input_tokens: 0,
+        };
+        this.pushEvent('message_delta', {
+            type: 'message_delta',
+            delta: {
+                stop_reason: this.stopReason,
+                stop_sequence: null,
+            },
+            usage,
+        });
+        this.pushEvent('message_stop', { type: 'message_stop' });
+        this.finalized = true;
+    }
+}
+exports.GeminiToClaudeEventTransform = GeminiToClaudeEventTransform;
+/**
+ * 将 Gemini SSE 流式事件转换为 OpenAI Chat 格式
+ */
+class GeminiToOpenAIChatEventTransform extends stream_1.Transform {
+    constructor(options) {
+        var _a;
+        super({ objectMode: true });
+        Object.defineProperty(this, "pendingToolCalls", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "usage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "finished", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "model", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "stopReason", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'stop'
+        });
+        Object.defineProperty(this, "errorEmitted", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "accumulatedText", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        this.model = (_a = options === null || options === void 0 ? void 0 : options.model) !== null && _a !== void 0 ? _a : null;
+        this.on('error', (err) => {
+            console.error('[GeminiToOpenAIChatEventTransform] Stream error:', err);
+            this.errorEmitted = true;
+        });
+    }
+    getUsage() {
+        return this.usage;
+    }
+    _transform(event, _encoding, callback) {
+        var _a;
+        if (this.errorEmitted) {
+            callback();
+            return;
+        }
+        try {
+            if (this.finished) {
+                callback();
+                return;
+            }
+            if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === 'done') {
+                this.finished = true;
+                this.push({ event: null, data: { id: '', model: this.model, choices: [{ index: 0, delta: {}, finish_reason: this.stopReason }] } });
+                this.push({ event: 'done', data: { type: 'done' } });
+                callback();
+                return;
+            }
+            const chunk = event.data;
+            if (!chunk) {
+                callback();
+                return;
+            }
+            // 处理 usage
+            if (chunk.usageMetadata) {
+                this.usage = {
+                    prompt_tokens: chunk.usageMetadata.promptTokenCount || 0,
+                    completion_tokens: chunk.usageMetadata.candidatesTokenCount || 0,
+                    total_tokens: chunk.usageMetadata.totalTokenCount || 0,
+                };
+            }
+            const candidates = Array.isArray(chunk.candidates) ? chunk.candidates : [];
+            for (const candidate of candidates) {
+                // 处理 finishReason
+                if (candidate.finishReason) {
+                    this.stopReason = this.mapGeminiFinishReason(candidate.finishReason);
+                }
+                if (!candidate.content || !Array.isArray(candidate.content.parts)) {
+                    continue;
+                }
+                // 处理 parts
+                for (const part of candidate.content.parts) {
+                    // 处理文本
+                    if (part.text && typeof part.text === 'string') {
+                        this.accumulatedText += part.text;
+                        this.push({ event: null, data: { id: '', model: this.model, choices: [{ index: 0, delta: { content: part.text } }] } });
+                    }
+                    // 处理 functionCall -> tool_calls
+                    if (part.functionCall) {
+                        const toolCallId = `call_${this.pendingToolCalls.length}_${Date.now()}`;
+                        this.pendingToolCalls.push({
+                            id: toolCallId,
+                            name: part.functionCall.name || 'tool',
+                            arguments: JSON.stringify(part.functionCall.args || {}),
+                        });
+                        this.push({
+                            event: null,
+                            data: {
+                                id: '',
+                                model: this.model,
+                                choices: [{
+                                        index: 0,
+                                        delta: {
+                                            tool_calls: [{
+                                                    id: toolCallId,
+                                                    type: 'function',
+                                                    function: {
+                                                        name: part.functionCall.name || 'tool',
+                                                        arguments: JSON.stringify(part.functionCall.args || {}),
+                                                    },
+                                                }],
+                                        },
+                                    }],
+                            },
+                        });
+                    }
+                    // 处理 inlineData (图像输出，罕见)
+                    if (part.inlineData) {
+                        // 图像作为 content 的一部分发送
+                        const imageDataUrl = `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`;
+                        this.push({
+                            event: null,
+                            data: {
+                                id: '',
+                                model: this.model,
+                                choices: [{
+                                        index: 0,
+                                        delta: {
+                                            content: [{
+                                                    type: 'image_url',
+                                                    image_url: { url: imageDataUrl },
+                                                }],
+                                        },
+                                    }],
+                            },
+                        });
+                    }
+                }
+            }
+            callback();
+        }
+        catch (error) {
+            console.error('[GeminiToOpenAIChatEventTransform] Error in _transform:', error);
+            callback();
+        }
+    }
+    _flush(callback) {
+        try {
+            if (!this.finished) {
+                this.finished = true;
+                this.push({
+                    event: null,
+                    data: {
+                        id: '',
+                        model: this.model,
+                        choices: [{
+                                index: 0,
+                                delta: {},
+                                finish_reason: this.stopReason,
+                            }],
+                    },
+                });
+                this.push({ event: 'done', data: { type: 'done' } });
+            }
+            callback();
+        }
+        catch (error) {
+            console.error('[GeminiToOpenAIChatEventTransform] Error in _flush:', error);
+            callback();
+        }
+    }
+    mapGeminiFinishReason(finishReason) {
+        switch (finishReason) {
+            case 'STOP':
+                return 'stop';
+            case 'MAX_TOKENS':
+                return 'length';
+            case 'SAFETY':
+            case 'RECITATION':
+                return 'content_filter';
+            case 'MALFORMED_FUNCTION_CALL':
+                return 'tool_calls';
+            default:
+                return 'stop';
+        }
+    }
+}
+exports.GeminiToOpenAIChatEventTransform = GeminiToOpenAIChatEventTransform;

package/dist/types/index.js

@@ -6,6 +6,7 @@ var AuthType;
 (function (AuthType) {
     AuthType["AUTH_TOKEN"] = "authorization";
     AuthType["API_KEY"] = "x-api-key";
+    AuthType["G_API_KEY"] = "x-goog-api-key";
     AuthType["AUTO"] = "auto";
 })(AuthType || (exports.AuthType = AuthType = {}));
 ;