refactor: 更新 Gemini 客户端和流转换器以支持工具调用和流式响应

Dango233 · aider-chat-bot · Dango233 · commit 5baad04a4209 · 2025-07-02T18:44:11.000+08:00
Co-authored-by: aider (vertex_ai/gemini-2.5-pro) &lt;aider@aider.chat&gt;
diff --git a/packages/mcp-server/src/bridge/stream-transformer.ts b/packages/mcp-server/src/bridge/stream-transformer.ts
@@ -1,7 +1,10 @@
-import { GenerateContentResponse, FinishReason } from '@google/genai';
 import { randomUUID } from 'node:crypto';
+import {
+  GeminiEventType,
+  ServerGeminiStreamEvent,
+} from '@google/gemini-cli-core';
 
-// --- 更新的 OpenAI 响应结构接口 ---
+// --- OpenAI 响应结构接口 ---
 interface OpenAIDelta {
   role?: 'assistant';
   content?: string | null;
@@ -28,21 +31,15 @@ interface OpenAIChunk {
   }[];
 }
 
-type ToolCallState = {
-  id: string;
-  name: string;
-  arguments: string;
-};
-
-// --- 更新的、有状态的转换器 ---
+// --- 新的、有状态的转换器 ---
 export function createOpenAIStreamTransformer(
   model: string,
-): TransformStream<GenerateContentResponse, Uint8Array> {
+): TransformStream<ServerGeminiStreamEvent, Uint8Array> {
   const chatID = `chatcmpl-${randomUUID()}`;
   const creationTime = Math.floor(Date.now() / 1000);
   const encoder = new TextEncoder();
   let isFirstChunk = true;
-  const toolCallStates: ToolCallState[] = [];
+  let toolCallIndex = 0;
 
   const createChunk = (
     delta: OpenAIDelta,
@@ -70,76 +67,78 @@ export function createOpenAIStreamTransformer(
   };
 
   return new TransformStream({
-    transform(geminiChunk, controller) {
-      const parts = geminiChunk.candidates?.[0]?.content?.parts || [];
-      const finishReason = geminiChunk.candidates?.[0]?.finishReason;
-
-      for (const part of parts) {
-        let delta: OpenAIDelta = {};
+    transform(event: ServerGeminiStreamEvent, controller) {
+      let delta: OpenAIDelta = {};
 
-        if (isFirstChunk) {
-          delta.role = 'assistant';
-          isFirstChunk = false;
-        }
+      if (isFirstChunk) {
+        delta.role = 'assistant';
+        isFirstChunk = false;
+      }
 
-        if (part.text) {
-          delta.content = part.text;
-          enqueueChunk(controller, createChunk(delta));
-        }
+      switch (event.type) {
+        case GeminiEventType.Content:
+          if (event.value) {
+            delta.content = event.value;
+            enqueueChunk(controller, createChunk(delta));
+          }
+          break;
 
-        if (part.functionCall && part.functionCall.name) {
-          const callId = `call_${randomUUID()}`;
+        case GeminiEventType.ToolCallRequest: {
+          const { name, args } = event.value;
+          // **重要**: 在 ID 中嵌入函数名，以便在收到工具响应时可以解析它
+          const toolCallId = `call_${name}_${randomUUID()}`;
 
-          // 模拟分块发送 tool_calls
-          // 1. 发送带有 name 的块
+          // OpenAI 流式工具调用需要分块发送
+          // 1. 发送包含函数名的块
           const nameDelta: OpenAIDelta = {
+            ...delta, // 包含 role (如果是第一个块)
             tool_calls: [
               {
-                index: toolCallStates.length,
-                id: callId,
+                index: toolCallIndex,
+                id: toolCallId,
                 type: 'function',
-                function: { name: part.functionCall.name, arguments: '' },
+                function: { name: name, arguments: '' },
               },
             ],
           };
-          if (isFirstChunk) {
-            nameDelta.role = 'assistant';
-            isFirstChunk = false;
-          }
           enqueueChunk(controller, createChunk(nameDelta));
 
-          // 2. 发送带有 arguments 的块
+          // 2. 发送包含参数的块
           const argsDelta: OpenAIDelta = {
             tool_calls: [
               {
-                index: toolCallStates.length,
-                id: callId,
+                index: toolCallIndex,
+                id: toolCallId,
                 type: 'function',
-                function: { arguments: JSON.stringify(part.functionCall.args) },
+                function: { arguments: JSON.stringify(args) },
               },
             ],
           };
           enqueueChunk(controller, createChunk(argsDelta));
 
-          toolCallStates.push({
-            id: callId,
-            name: part.functionCall.name,
-            arguments: JSON.stringify(part.functionCall.args),
-          });
+          toolCallIndex++;
+          break;
         }
-      }
 
-      if (finishReason && finishReason !== 'FINISH_REASON_UNSPECIFIED') {
-        const reason =
-          finishReason === FinishReason.STOP
-            ? toolCallStates.length > 0
-              ? 'tool_calls'
-              : 'stop'
-            : finishReason.toLowerCase();
-        enqueueChunk(controller, createChunk({}, reason));
+        case GeminiEventType.ChatCompressed:
+        case GeminiEventType.Thought:
+          // 这些事件目前在 OpenAI 格式中没有直接对应项，可以选择忽略或以某种方式记录
+          console.log(`[Stream Transformer] Ignoring event: ${event.type}`);
+          break;
+
+        // 错误和取消事件应在更高层处理，但为完整性起见
+        case GeminiEventType.Error:
+        case GeminiEventType.UserCancelled:
+          // 可以在这里发送一个带有错误信息的 data chunk，如果需要的话
+          break;
       }
     },
+
     flush(controller) {
+      // 在流结束时，发送一个带有 `tool_calls` 或 `stop` 的 finish_reason
+      const finish_reason = toolCallIndex > 0 ? 'tool_calls' : 'stop';
+      enqueueChunk(controller, createChunk({}, finish_reason));
+
       const doneString = `data: [DONE]\n\n`;
       controller.enqueue(encoder.encode(doneString));
     },
diff --git a/packages/mcp-server/src/gemini-client.ts b/packages/mcp-server/src/gemini-client.ts
@@ -39,8 +39,8 @@ export class GeminiApiClient {
     }
 
     const functionDeclarations: FunctionDeclaration[] = openAITools
-      .filter((tool) => tool.type === 'function' && tool.function)
-      .map((tool) => ({
+      .filter(tool => tool.type === 'function' && tool.function)
+      .map(tool => ({
         name: tool.function.name,
         description: tool.function.description,
         parameters: tool.function.parameters,
@@ -53,20 +53,40 @@ export class GeminiApiClient {
     return [{ functionDeclarations }];
   }
 
+  /**
+   * 从 tool_call_id 中解析出原始的函数名。
+   * ID 格式为 "call_{functionName}_{uuid}"
+   */
+  private parseFunctionNameFromId(toolCallId: string): string {
+    const parts = toolCallId.split('_');
+    if (parts.length > 2 && parts[0] === 'call') {
+      // 重新组合可能包含下划线的函数名
+      return parts.slice(1, parts.length - 1).join('_');
+    }
+    // 回退机制，虽然不理想，但比发送错误名称要好
+    return 'unknown_tool_from_id';
+  }
+
   /**
    * 将 OpenAI 格式的消息转换为 Gemini 格式的 Content 对象。
    */
   private openAIMessageToGemini(msg: OpenAIMessage): Content {
     const role = msg.role === 'assistant' ? 'model' : 'user';
 
     if (msg.role === 'tool') {
+      const functionName = this.parseFunctionNameFromId(msg.tool_call_id || '');
       return {
         role: 'user', // Gemini 使用 'user' role 来承载 functionResponse
         parts: [
           {
             functionResponse: {
-              name: msg.tool_call_id || 'unknown_tool', // 需要一个工具名
-              response: { content: msg.content },
+              name: functionName,
+              response: {
+                // Gemini 期望 response 是一个对象，我们把工具的输出放在这里
+                // 假设工具输出是一个 JSON 字符串，我们解析它
+                // 如果不是，就直接作为字符串
+                output: msg.content,
+              },
             },
           },
         ],
@@ -90,11 +110,12 @@ export class GeminiApiClient {
               const mimeType = mimePart.split(':')[1].split(';')[0];
               return { inlineData: { mimeType, data: dataPart } };
             }
+            // Gemini API 更喜欢 inlineData，但 fileData 也可以作为备选
             return { fileData: { mimeType: 'image/jpeg', fileUri: imageUrl } };
           }
-          return { text: '' };
+          return null;
         })
-        .filter((p) => p.text !== '' || p.inlineData || p.fileData);
+        .filter((p): p is Part => p !== null);
 
       return { role, parts };
     }
@@ -116,12 +137,13 @@ export class GeminiApiClient {
     tools?: OpenAIChatCompletionRequest['tools'];
     tool_choice?: any;
   }) {
-    const history = messages.map(this.openAIMessageToGemini);
+    const history = messages.map(msg => this.openAIMessageToGemini(msg));
     const lastMessage = history.pop();
     if (!lastMessage) {
       throw new Error('No message to send.');
     }
 
+    // 为每个请求创建一个新的、独立的聊天会话
     const oneShotChat = new GeminiChat(
       this.config,
       this.contentGenerator,
