refactor: 为每个会话管理独立的 transport 实例

Co-authored-by: aider (vertex_ai/gemini-2.5-pro) <aider@aider.chat>

Author: Dango233

packages/mcp-server/src/bridge/bridge.ts

@@ -8,9 +8,9 @@ import {
   type ToolResult,
   GeminiChat,
 } from '@google/gemini-cli-core';
-// isInitializeRequest 在这种模式下不再需要
 import {
   type CallToolResult,
+  isInitializeRequest,
 } from '@modelcontextprotocol/sdk/types.js';
 import {
   type PartUnion,
@@ -34,8 +34,8 @@ export class GcliMcpBridge {
   private readonly cliVersion: string;
   private readonly mcpServer: McpServer;
   private readonly debugMode: boolean;
-  // 将 transport 提升为类的成员
-  private transport: StreamableHTTPServerTransport | undefined;
+  // **修改 1: 创建一个 Map 来存储每个会话的 transport 实例**
+  private readonly transports: Record<string, StreamableHTTPServerTransport> = {};
 
   constructor(config: Config, cliVersion: string, debugMode = false) {
     this.config = config;
@@ -56,29 +56,75 @@ export class GcliMcpBridge {
     if (this.debugMode) {
       app.use(requestLogger(this.debugMode));
     }
-    
-    // 1. 在 start 方法中只创建一次 transport
-    this.transport = new StreamableHTTPServerTransport({
-      // sessionIdGenerator 仍然是需要的，SDK 会用它来处理会话
-      sessionIdGenerator: () => randomUUID(),
-    });
-
-    // 2. 在 start 方法中只连接一次
-    await this.mcpServer.connect(this.transport);
-    
-    console.log(`${LOG_PREFIX} McpServer connected to the transport.`);
 
-    // 3. 修改路由处理器，始终使用同一个 transport 实例
+    // **修改 2: 更新路由处理器以管理多个 transport**
     app.all('/mcp', async (req: Request, res: Response) => {
-      if (!this.transport) {
-        console.error(`${LOG_PREFIX} Transport is not initialized.`);
-        res.status(500).json({ error: 'Server transport not available' });
-        return;
+      const sessionId = req.headers['mcp-session-id'] as string | undefined;
+      let transport: StreamableHTTPServerTransport | undefined = sessionId ? this.transports[sessionId] : undefined;
+
+      if (!transport) {
+        // 如果没有找到 transport，并且这是一个新的 initialize 请求，则创建一个新的
+        if (isInitializeRequest(req.body)) {
+          if (this.debugMode) {
+            console.log(
+              `${LOG_PREFIX} Creating new transport for initialize request`,
+            );
+          }
+          
+          transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: newSessionId => {
+              if (this.debugMode) {
+                console.log(
+                  `${LOG_PREFIX} Session initialized: ${newSessionId}`,
+                );
+              }
+              // 将新的 transport 实例存储在 Map 中
+              if (transport) {
+                  this.transports[newSessionId] = transport;
+              }
+            },
+          });
+
+          // 当连接关闭时，从 Map 中移除 transport
+          transport.onclose = () => {
+            const sid = transport!.sessionId;
+            if (sid && this.transports[sid]) {
+              if (this.debugMode) {
+                console.log(
+                  `${LOG_PREFIX} Session ${sid} closed, removing transport.`,
+                );
+              }
+              delete this.transports[sid];
+            }
+          };
+
+          // 将新的 transport 连接到我们唯一的 McpServer 实例
+          await this.mcpServer.connect(transport);
+        } else {
+          // 如果请求没有 session ID 但又不是 initialize 请求，则为错误请求
+          console.error(
+            `${LOG_PREFIX} Bad Request: Missing session ID for non-initialize request.`,
+          );
+          res.status(400).json({
+            jsonrpc: '2.0',
+            error: {
+              code: -32000,
+              message: 'Bad Request: Mcp-Session-Id header is required',
+            },
+            id: null,
+          });
+          return;
+        }
+      } else if (this.debugMode) {
+        console.log(
+          `${LOG_PREFIX} Reusing transport for session: ${sessionId}`,
+        );
       }
-      
+
+      // 使用找到的或新创建的 transport 处理请求
       try {
-        // handleRequest 方法能够处理并发请求
-        await this.transport.handleRequest(req, res, req.body);
+        await transport.handleRequest(req, res, req.body);
       } catch (e) {
         console.error(`${LOG_PREFIX} Error handling request:`, e);
         if (!res.headersSent) {