protocol-proxy 2.2.0 → 2.3.4

package/lib/converters/gemini-to-openai.js

@@ -0,0 +1,240 @@
+/**
+ * Gemini → OpenAI 协议转换
+ */
+
+const { encodeOpenAIEvent, encodeOpenAIDone } = require('./sse-helpers');
+
+function generateCallId() {
+  return 'call_' + Math.random().toString(36).slice(2, 14);
+}
+
+// ==================== 请求转换 ====================
+
+function convertRequest(body, targetModel) {
+  const messages = [];
+
+  // system_instruction → system message
+  const sysText = body.systemInstruction?.parts?.map(p => p.text || '').join('') || '';
+  if (sysText) {
+    messages.push({ role: 'system', content: sysText });
+  }
+
+  // tools: functionDeclarations → OpenAI tools
+  let tools = undefined;
+  if (body.tools && Array.isArray(body.tools)) {
+    const allDeclarations = [];
+    for (const tool of body.tools) {
+      if (tool.functionDeclarations) {
+        allDeclarations.push(...tool.functionDeclarations);
+      }
+    }
+    if (allDeclarations.length > 0) {
+      tools = allDeclarations.map(fd => ({
+        type: 'function',
+        function: {
+          name: fd.name,
+          description: fd.description || '',
+          parameters: fd.parameters || { type: 'object', properties: {} },
+        },
+      }));
+    }
+  }
+
+  // contents → messages, functionCall/functionResponse → tool_calls/tool results
+  for (const msg of (body.contents || [])) {
+    const role = msg.role === 'model' ? 'assistant' : 'user';
+    const parts = msg.parts || [];
+
+    // 检查是否有 functionCall
+    const functionCalls = parts.filter(p => p.functionCall);
+    if (functionCalls.length > 0) {
+      const text = parts.filter(p => p.text).map(p => p.text).join('');
+      const tool_calls = functionCalls.map(fc => ({
+        id: generateCallId(),
+        type: 'function',
+        function: { name: fc.functionCall.name, arguments: JSON.stringify(fc.functionCall.args || {}) },
+      }));
+      messages.push({ role: 'assistant', content: text || null, tool_calls });
+      continue;
+    }
+
+    // 检查是否有 functionResponse → tool messages
+    const functionResponses = parts.filter(p => p.functionResponse);
+    for (const fr of functionResponses) {
+      messages.push({
+        role: 'tool',
+        tool_call_id: fr.functionResponse.name || 'unknown',
+        content: typeof fr.functionResponse.response === 'string'
+          ? fr.functionResponse.response
+          : JSON.stringify(fr.functionResponse.response || {}),
+      });
+    }
+
+    // 纯文本 part（跳过已处理 functionCall/functionResponse 的消息）
+    const textParts = parts.filter(p => p.text).map(p => p.text).join('');
+    if (textParts && functionCalls.length === 0 && functionResponses.length === 0) {
+      messages.push({ role, content: textParts });
+    }
+  }
+
+  const result = {
+    model: targetModel,
+    messages,
+    stream: false,
+  };
+
+  if (tools) result.tools = tools;
+
+  // generationConfig → OpenAI params
+  const gc = body.generationConfig || {};
+  if (gc.maxOutputTokens !== undefined) 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;
+
+  return result;
+}
+
+// ==================== 响应转换 ====================
+
+function convertResponse(geminiBody) {
+  const candidate = geminiBody.candidates?.[0];
+  if (!candidate) {
+    return { id: '', object: 'chat.completion', choices: [], usage: convertUsage(geminiBody.usageMetadata) };
+  }
+
+  const parts = candidate.content?.parts || [];
+  const textParts = [];
+  const toolCalls = [];
+
+  for (const part of parts) {
+    if (part.text) textParts.push(part.text);
+    if (part.functionCall) {
+      toolCalls.push({
+        id: generateCallId(),
+        type: 'function',
+        function: { name: part.functionCall.name, arguments: JSON.stringify(part.functionCall.args || {}) },
+      });
+    }
+  }
+
+  const message = { role: 'assistant', content: textParts.join('') || null };
+  if (toolCalls.length > 0) message.tool_calls = toolCalls;
+
+  return {
+    id: '',
+    object: 'chat.completion',
+    choices: [{
+      index: 0,
+      message,
+      finish_reason: toolCalls.length > 0 ? 'tool_calls' : mapFinishReason(candidate.finishReason),
+    }],
+    usage: convertUsage(geminiBody.usageMetadata),
+  };
+}
+
+function convertUsage(meta) {
+  return {
+    prompt_tokens: meta?.promptTokenCount || 0,
+    completion_tokens: meta?.candidatesTokenCount || 0,
+    total_tokens: meta?.totalTokenCount || 0,
+  };
+}
+
+function mapFinishReason(reason) {
+  if (!reason) return null;
+  if (reason === 'STOP') return 'stop';
+  if (reason === 'MAX_TOKENS') return 'length';
+  if (reason === 'SAFETY') return 'content_filter';
+  return 'stop';
+}
+
+// ==================== SSE 流式转换 ====================
+
+function createSSEConverter() {
+  const state = { started: false, sentFunctionCall: new Map(), buffer: '' };
+
+  return {
+    convertChunk(chunkText) {
+      let output = '';
+      state.buffer += chunkText;
+      const lines = state.buffer.split('\n');
+      state.buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data: ')) continue;
+        const dataStr = trimmed.slice(6);
+        if (!dataStr) continue;
+
+        let chunk;
+        try { chunk = JSON.parse(dataStr); } catch { continue; }
+
+        const candidate = chunk.candidates?.[0];
+        if (!candidate) continue;
+
+        const parts = candidate.content?.parts || [];
+
+        // 首个 chunk 发送 role
+        if (!state.started && (parts.length > 0)) {
+          state.started = true;
+          output += encodeOpenAIEvent({
+            id: '',
+            object: 'chat.completion.chunk',
+            choices: [{ index: 0, delta: { role: 'assistant', content: null }, finish_reason: null }],
+          });
+        }
+
+        // 文本增量
+        const text = parts.filter(p => p.text).map(p => p.text).join('') || '';
+        if (text) {
+          output += encodeOpenAIEvent({
+            id: '',
+            object: 'chat.completion.chunk',
+            choices: [{ index: 0, delta: { content: text }, finish_reason: null }],
+          });
+        }
+
+        // functionCall 增量（去重，首次生成 ID 后缓存）
+        for (const part of parts) {
+          if (!part.functionCall) continue;
+          const key = part.functionCall.name + (typeof part.functionCall.args === 'string' ? part.functionCall.args : JSON.stringify(part.functionCall.args || {}));
+          if (state.sentFunctionCall.has(key)) continue;
+          const callId = generateCallId();
+          state.sentFunctionCall.set(key, callId);
+          output += encodeOpenAIEvent({
+            id: '',
+            object: 'chat.completion.chunk',
+            choices: [{
+              index: 0,
+              delta: {
+                tool_calls: [{
+                  index: 0,
+                  id: callId,
+                  type: 'function',
+                  function: { name: part.functionCall.name, arguments: JSON.stringify(part.functionCall.args || {}) },
+                }],
+              },
+              finish_reason: null,
+            }],
+          });
+        }
+
+        if (candidate.finishReason) {
+          const reason = mapFinishReason(candidate.finishReason);
+          output += encodeOpenAIEvent({
+            id: '',
+            object: 'chat.completion.chunk',
+            choices: [{ index: 0, delta: {}, finish_reason: reason }],
+          });
+          output += encodeOpenAIDone();
+        }
+      }
+
+      return output || null;
+    },
+    flush() { return ''; },
+  };
+}
+
+module.exports = { convertRequest, convertResponse, createSSEConverter };

package/lib/converters/openai-to-anthropic.js

@@ -188,6 +188,7 @@ function createSSEConverter(targetModel) {
     blockIndex: 0,
     toolUseId: null,
     toolName: null,
+    toolCallIndex: -1,
     sentRole: false,
     sentToolInit: false,
     buffer: '',
@@ -243,6 +244,7 @@ function processLine(line, state, targetModel) {
       if (state.blockType === 'tool_use') {
         state.toolUseId = event.content_block.id;
         state.toolName = event.content_block.name;
+        state.toolCallIndex = (state.toolCallIndex || 0) + 1;
       }
       return '';
     }
@@ -267,7 +269,7 @@ function processLine(line, state, targetModel) {
           state.sentToolInit = true;
           const toolCallChunk = {
             tool_calls: [{
-              index: 0,
+              index: state.toolCallIndex,
               id: state.toolUseId,
               type: 'function',
               function: { name: state.toolName, arguments: delta.partial_json },
@@ -276,7 +278,7 @@ function processLine(line, state, targetModel) {
           return prefix + encodeOpenAIChunk(state.messageId, targetModel, toolCallChunk);
         }
         return prefix + encodeOpenAIChunk(state.messageId, targetModel, {
-          tool_calls: [{ index: 0, function: { arguments: delta.partial_json } }],
+          tool_calls: [{ index: state.toolCallIndex, function: { arguments: delta.partial_json } }],
         });
       }
 

package/lib/converters/openai-to-gemini.js

@@ -0,0 +1,286 @@
+/**
+ * OpenAI → Gemini 协议转换
+ */
+
+const { encodeOpenAIEvent, encodeOpenAIDone } = require('./sse-helpers');
+
+// ==================== 请求转换 ====================
+
+function generateCallId() {
+  return 'call_' + Math.random().toString(36).slice(2, 14);
+}
+
+function convertRequest(body, targetModel) {
+  const contents = [];
+  let systemInstruction = null;
+
+  for (const msg of (body.messages || [])) {
+    if (msg.role === 'system') {
+      // 多段 system 合并为一个
+      const text = typeof msg.content === 'string' ? msg.content : '';
+      if (!systemInstruction) {
+        systemInstruction = { parts: [{ text }] };
+      } else {
+        systemInstruction.parts[0].text += '\n' + text;
+      }
+      continue;
+    }
+
+    // tool role → functionResponse
+    if (msg.role === 'tool') {
+      contents.push({
+        role: 'user',
+        parts: [{
+          functionResponse: {
+            name: msg.tool_call_id || 'unknown',
+            response: typeof msg.content === 'string' ? { result: msg.content } : msg.content || {},
+          },
+        }],
+      });
+      continue;
+    }
+
+    // assistant with tool_calls → functionCall
+    if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+      const parts = [];
+      if (msg.content) parts.push({ text: typeof msg.content === 'string' ? msg.content : '' });
+      for (const tc of msg.tool_calls) {
+        let args = {};
+        try {
+          args = tc.function?.arguments ? JSON.parse(tc.function.arguments) : {};
+        } catch { args = {}; }
+        parts.push({
+          functionCall: {
+            name: tc.function?.name || '',
+            args,
+          },
+        });
+      }
+      contents.push({ role: 'model', parts });
+      continue;
+    }
+
+    const role = msg.role === 'assistant' ? 'model' : 'user';
+    const text = typeof msg.content === 'string' ? msg.content : '';
+
+    // assistant with array content (Anthropic-originated)
+    if (Array.isArray(msg.content)) {
+      const parts = [];
+      for (const block of msg.content) {
+        if (block.type === 'text' && block.text) parts.push({ text: block.text });
+        if (block.type === 'tool_use') {
+          parts.push({
+            functionCall: { name: block.name, args: block.input || {} },
+          });
+        }
+        if (block.type === 'tool_result') {
+          parts.push({
+            functionResponse: {
+              name: block.tool_use_id || 'unknown',
+              response: typeof block.content === 'string' ? { result: block.content } : block.content || {},
+            },
+          });
+        }
+      }
+      if (parts.length > 0) {
+        contents.push({ role, parts });
+      }
+      continue;
+    }
+
+    if (text) contents.push({ role, parts: [{ text }] });
+  }
+
+  const result = { contents };
+
+  if (systemInstruction) {
+    result.systemInstruction = systemInstruction;
+  }
+
+  // 转换 tools → functionDeclarations
+  if (body.tools && Array.isArray(body.tools)) {
+    const functionDeclarations = [];
+    for (const tool of body.tools) {
+      if (tool.type === 'function' && tool.function) {
+        functionDeclarations.push({
+          name: tool.function.name,
+          description: tool.function.description || '',
+          parameters: tool.function.parameters || { type: 'object', properties: {} },
+        });
+      }
+    }
+    if (functionDeclarations.length > 0) {
+      result.tools = [{ functionDeclarations }];
+    }
+  }
+
+  // generationConfig
+  const gc = {};
+  if (body.max_tokens !== undefined) gc.maxOutputTokens = body.max_tokens;
+  if (body.temperature !== undefined) gc.temperature = body.temperature;
+  if (body.top_p !== undefined) gc.topP = body.top_p;
+  if (body.stop) gc.stopSequences = Array.isArray(body.stop) ? body.stop : [body.stop];
+  if (Object.keys(gc).length > 0) result.generationConfig = gc;
+
+  return result;
+}
+
+// ==================== 响应转换 ====================
+
+function convertResponse(geminiBody) {
+  const candidate = geminiBody.candidates?.[0];
+  if (!candidate) {
+    return { id: '', object: 'chat.completion', choices: [], usage: {} };
+  }
+
+  const parts = candidate.content?.parts || [];
+  const textParts = [];
+  const toolCalls = [];
+
+  for (const part of parts) {
+    if (part.text) {
+      textParts.push(part.text);
+    }
+    if (part.functionCall) {
+      toolCalls.push({
+        id: generateCallId(),
+        type: 'function',
+        function: {
+          name: part.functionCall.name,
+          arguments: JSON.stringify(part.functionCall.args || {}),
+        },
+      });
+    }
+  }
+
+  const message = { role: 'assistant', content: textParts.join('') || null };
+  if (toolCalls.length > 0) message.tool_calls = toolCalls;
+
+  return {
+    id: '',
+    object: 'chat.completion',
+    choices: [{
+      index: 0,
+      message,
+      finish_reason: toolCalls.length > 0 ? 'tool_calls' : mapFinishReason(candidate.finishReason),
+    }],
+    usage: {
+      prompt_tokens: geminiBody.usageMetadata?.promptTokenCount || 0,
+      completion_tokens: geminiBody.usageMetadata?.candidatesTokenCount || 0,
+      total_tokens: geminiBody.usageMetadata?.totalTokenCount || 0,
+    },
+  };
+}
+
+function mapFinishReason(reason) {
+  if (!reason) return null;
+  if (reason === 'STOP') return 'stop';
+  if (reason === 'MAX_TOKENS') return 'length';
+  if (reason === 'SAFETY') return 'content_filter';
+  return 'stop';
+}
+
+// ==================== SSE 流式转换 ====================
+
+function createSSEConverter() {
+  const state = { started: false, sentFunctionCall: new Map(), buffer: '' };
+
+  return {
+    convertChunk(chunkText) {
+      let output = '';
+      state.buffer += chunkText;
+      const lines = state.buffer.split('\n');
+      state.buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('data: ')) continue;
+        const dataStr = trimmed.slice(6);
+        if (!dataStr) continue;
+
+        let chunk;
+        try { chunk = JSON.parse(dataStr); } catch { continue; }
+
+        const candidate = chunk.candidates?.[0];
+        if (!candidate) continue;
+
+        const parts = candidate.content?.parts || [];
+
+        // 首个 chunk 发送 role
+        if (!state.started && (parts.length > 0)) {
+          state.started = true;
+          output += encodeOpenAIEvent({
+            id: '',
+            object: 'chat.completion.chunk',
+            choices: [{
+              index: 0,
+              delta: { role: 'assistant', content: null },
+              finish_reason: null,
+            }],
+          });
+        }
+
+        // 文本增量
+        const text = parts.filter(p => p.text).map(p => p.text).join('') || '';
+        if (text) {
+          output += encodeOpenAIEvent({
+            id: '',
+            object: 'chat.completion.chunk',
+            choices: [{
+              index: 0,
+              delta: { content: text },
+              finish_reason: null,
+            }],
+          });
+        }
+
+        // functionCall 增量（去重，首次生成 ID 后缓存）
+        for (const part of parts) {
+          if (!part.functionCall) continue;
+          const key = part.functionCall.name + (typeof part.functionCall.args === 'string' ? part.functionCall.args : JSON.stringify(part.functionCall.args || {}));
+          if (state.sentFunctionCall.has(key)) continue;
+          const callId = generateCallId();
+          state.sentFunctionCall.set(key, callId);
+
+          output += encodeOpenAIEvent({
+            id: '',
+            object: 'chat.completion.chunk',
+            choices: [{
+              index: 0,
+              delta: {
+                tool_calls: [{
+                  index: 0,
+                  id: callId,
+                  type: 'function',
+                  function: {
+                    name: part.functionCall.name,
+                    arguments: JSON.stringify(part.functionCall.args || {}),
+                  },
+                }],
+              },
+              finish_reason: null,
+            }],
+          });
+        }
+
+        // finish
+        if (candidate.finishReason) {
+          const reason = mapFinishReason(candidate.finishReason);
+          output += encodeOpenAIEvent({
+            id: '',
+            object: 'chat.completion.chunk',
+            choices: [{ index: 0, delta: {}, finish_reason: reason }],
+          });
+          output += encodeOpenAIDone();
+        }
+      }
+
+      return output || null;
+    },
+    flush() {
+      return '';
+    },
+  };
+}
+
+module.exports = { convertRequest, convertResponse, createSSEConverter };

package/lib/detector.js

@@ -17,6 +17,10 @@ function detectInboundProtocol(req, body) {
 
   // 根据 body 结构推断
   if (body && typeof body === 'object') {
+    // Gemini: contents 数组且每个元素有 parts
+    if (Array.isArray(body.contents) && body.contents[0]?.parts) {
+      return 'gemini';
+    }
     // Anthropic: 有 system 顶级字段，messages 中角色没有 system
     if (body.system !== undefined && Array.isArray(body.messages)) {
       return 'anthropic';

package/lib/proxy-server.js

@@ -2,6 +2,10 @@ const express = require('express');
 const { detectInboundProtocol } = require('./detector');
 const o2a = require('./converters/openai-to-anthropic');
 const a2o = require('./converters/anthropic-to-openai');
+const o2g = require('./converters/openai-to-gemini');
+const g2o = require('./converters/gemini-to-openai');
+const a2g = require('./converters/anthropic-to-gemini');
+const g2a = require('./converters/gemini-to-anthropic');
 const { recordUsage } = require('./stats-store');
 
 function createProxyApp(proxyConfigOrGetter) {
@@ -137,7 +141,7 @@ function createProxyApp(proxyConfigOrGetter) {
       console.log(`[${requestId}] ⬅️  ${(inboundProtocol || 'unknown').toUpperCase()} → ${targetProtocol.toUpperCase()} | path=${req.path}`);
 
       // 决定转换方向
-      let convertReq, convertRes, createSSEConv;
+      let convertReq, convertRes, createSSEConv, nameToId = null;
       if (inboundProtocol === 'openai' && targetProtocol === 'anthropic') {
         convertReq = o2a.convertRequest;
         convertRes = o2a.convertResponse;
@@ -146,6 +150,28 @@ function createProxyApp(proxyConfigOrGetter) {
         convertReq = a2o.convertRequest;
         convertRes = a2o.convertResponse;
         createSSEConv = a2o.createSSEConverter;
+      } else if (inboundProtocol === 'openai' && targetProtocol === 'gemini') {
+        convertReq = o2g.convertRequest;
+        convertRes = o2g.convertResponse;
+        createSSEConv = o2g.createSSEConverter;
+      } else if (inboundProtocol === 'gemini' && targetProtocol === 'openai') {
+        convertReq = g2o.convertRequest;
+        convertRes = g2o.convertResponse;
+        createSSEConv = g2o.createSSEConverter;
+      } else if (inboundProtocol === 'anthropic' && targetProtocol === 'gemini') {
+        convertReq = a2g.convertRequest;
+        convertRes = a2g.convertResponse;
+        createSSEConv = a2g.createSSEConverter;
+      } else if (inboundProtocol === 'gemini' && targetProtocol === 'anthropic') {
+        // g2a.convertRequest 返回 { ...body, nameToId }，需要提取映射
+        convertReq = (body, model) => {
+          const result = g2a.convertRequest(body, model);
+          nameToId = result.nameToId;
+          const { nameToId: _, ...bodyOnly } = result;
+          return bodyOnly;
+        };
+        convertRes = g2a.convertResponse;
+        createSSEConv = (model) => g2a.createSSEConverter(nameToId);
       } else {
         convertReq = (body, model) => ({ ...body, model: body.model || model });
         convertRes = (body) => body;
@@ -161,7 +187,7 @@ function createProxyApp(proxyConfigOrGetter) {
 
       const targetBody = convertReq(req.body, effectiveModel);
 
-      const isAzure = !!target.azureDeployment;
+      const isAzure = !!target.azureDeployment && /azure/i.test(target.providerUrl);
 
       // 流式请求时注入 stream_options 以获取 usage 统计（Azure 不支持）
       if (isStream && targetProtocol === 'openai' && !isAzure) {
@@ -172,7 +198,7 @@ function createProxyApp(proxyConfigOrGetter) {
       injectReasoningToMessages(targetBody.messages);
 
       // 构建目标 URL
-      const targetUrl = buildTargetUrl(target, req.path);
+      const targetUrl = buildTargetUrl(target, req.path, isStream, effectiveModel);
       console.log(`[${requestId}] 🔗 ${targetUrl} | model=${effectiveModel}`);
 
       // 构建请求头
@@ -187,6 +213,8 @@ function createProxyApp(proxyConfigOrGetter) {
         } else {
           headers['Authorization'] = `Bearer ${target.apiKey}`;
         }
+      } else if (targetProtocol === 'gemini') {
+        headers['x-goog-api-key'] = target.apiKey;
       } else if (targetProtocol === 'anthropic') {
         headers['X-Api-Key'] = target.apiKey;
         headers['Anthropic-Version'] = '2023-06-01';
@@ -197,7 +225,7 @@ function createProxyApp(proxyConfigOrGetter) {
         method: 'POST',
         headers,
         body: JSON.stringify(targetBody),
-        signal: AbortSignal.timeout(120000),
+        signal: AbortSignal.timeout(300000),
       });
 
       if (!fetchRes.ok) {
@@ -272,6 +300,11 @@ function createProxyApp(proxyConfigOrGetter) {
           }
         } catch (err) {
           console.error(`[${requestId}] Stream error:`, err.message);
+          if (!res.writableEnded) {
+            try {
+              res.write(`data: ${JSON.stringify({ error: { message: err.message, type: 'proxy_error' } })}\n\n`);
+            } catch { /* ignore */ }
+          }
         } finally {
           res.end();
         }
@@ -293,7 +326,7 @@ function createProxyApp(proxyConfigOrGetter) {
   return app;
 }
 
-function buildTargetUrl(target, originalPath) {
+function buildTargetUrl(target, originalPath, isStream, effectiveModel) {
   const base = target.providerUrl.replace(/\/$/, '');
   const hasV1Suffix = base.endsWith('/v1');
 
@@ -312,6 +345,12 @@ function buildTargetUrl(target, originalPath) {
     return `${base}/v1/messages`;
   }
 
+  if (target.protocol === 'gemini') {
+    const model = effectiveModel || 'gemini-pro';
+    const action = isStream ? 'streamGenerateContent?alt=sse' : 'generateContent';
+    return `${base}/v1beta/models/${model}:${action}`;
+  }
+
   return base + originalPath;
 }