agent-gear 1.1.6 → 1.1.7

package/src/acp/bridge.test.ts

@@ -1,19 +1,27 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-vi.mock('@agentclientprotocol/sdk', () => ({
-  ndJsonStream: vi.fn(() => ({})),
-  ClientSideConnection: vi.fn(function () {
+const { mockNewSession, mockResumeSession, mockInitialize, mockClientSideConnection } = vi.hoisted(() => {
+  const mockNewSession = vi.fn().mockResolvedValue({ sessionId: 'acp-sess-abc' });
+  const mockResumeSession = vi.fn().mockResolvedValue({});
+  const mockInitialize = vi.fn().mockResolvedValue({ protocolVersion: 1 });
+  const mockClientSideConnection = vi.fn(function () {
     return {
-      initialize: vi.fn().mockResolvedValue({ protocolVersion: 1 }),
-      newSession: vi.fn().mockResolvedValue({ sessionId: 'acp-sess-abc' }),
-      resumeSession: vi.fn().mockResolvedValue({}),
+      initialize: mockInitialize,
+      newSession: mockNewSession,
+      resumeSession: mockResumeSession,
       prompt: vi.fn().mockResolvedValue({ stopReason: 'end_turn' }),
       cancel: vi.fn().mockResolvedValue(undefined),
       closeSession: vi.fn().mockResolvedValue({}),
       setSessionMode: vi.fn().mockResolvedValue({}),
       setSessionConfigOption: vi.fn().mockResolvedValue({}),
     };
-  }),
+  });
+  return { mockNewSession, mockResumeSession, mockInitialize, mockClientSideConnection };
+});
+
+vi.mock('@agentclientprotocol/sdk', () => ({
+  ndJsonStream: vi.fn(() => ({})),
+  ClientSideConnection: mockClientSideConnection,
 }));
 
 import { AcpSessionBridge } from './bridge.js';
@@ -194,3 +202,147 @@ describe('AcpSessionBridge - requestPermission', () => {
     warnSpy.mockRestore();
   });
 });
+
+describe('AcpSessionBridge - mcpEndpoint injection', () => {
+  let mockSocket: ReturnType<typeof createMockSocket>;
+  let mockSpawner: MockAcpSpawner;
+
+  function createBridge(mcpEndpoint?: { url: string; token: string; serverNames: string[] }) {
+    return new AcpSessionBridge(
+      mockSocket as never,
+      { sessionId: 'sess-1', cwd: '/home/user', mcpEndpoint },
+      mockSpawner as never,
+    );
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    mockSocket = createMockSocket();
+    mockSpawner = new MockAcpSpawner();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it('should pass http mcpServers to newSession when mcpEndpoint provided', async () => {
+    const bridge = createBridge({
+      url: 'http://gateway/mcp/sess-1',
+      token: 'tok-1',
+      serverNames: ['github-mcp', 'fs-mcp'],
+    });
+
+    await bridge.start();
+
+    expect(mockNewSession).toHaveBeenCalledWith(expect.objectContaining({
+      mcpServers: [
+        { type: 'http', name: 'github-mcp', url: 'http://gateway/mcp/sess-1/github-mcp', headers: [{ name: 'Authorization', value: 'Bearer tok-1' }] },
+        { type: 'http', name: 'fs-mcp', url: 'http://gateway/mcp/sess-1/fs-mcp', headers: [{ name: 'Authorization', value: 'Bearer tok-1' }] },
+      ],
+    }));
+  });
+
+  it('should not set mcpServers when mcpEndpoint absent', async () => {
+    const bridge = createBridge();
+    await bridge.start();
+
+    expect(mockNewSession).toHaveBeenCalledWith(expect.objectContaining({
+      mcpServers: [],
+    }));
+  });
+
+  it('should pass http mcpServers to resumeSession when mcpEndpoint provided', async () => {
+    const bridge = createBridge({
+      url: 'http://gateway/mcp/sess-1',
+      token: 'tok-1',
+      serverNames: ['github-mcp'],
+    });
+
+    await bridge.resume('ext-123');
+
+    expect(mockResumeSession).toHaveBeenCalledWith(expect.objectContaining({
+      mcpServers: [
+        { type: 'http', name: 'github-mcp', url: 'http://gateway/mcp/sess-1/github-mcp', headers: [{ name: 'Authorization', value: 'Bearer tok-1' }] },
+      ],
+    }));
+  });
+
+  it('should fail with a diagnosable error when mcpEndpoint.serverNames is missing', async () => {
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const bridge = createBridge({
+      url: 'http://gateway/mcp/sess-1',
+      token: 'tok-1',
+      // simulate an upstream payload that drifts from the contract
+      serverNames: undefined as never,
+    });
+
+    await bridge.start();
+
+    expect(mockNewSession).not.toHaveBeenCalled();
+    expect(mockSocket.emit).toHaveBeenCalledWith('acp:stopped', expect.objectContaining({
+      sessionId: 'sess-1',
+      reason: 'error',
+      error: expect.stringContaining('serverNames'),
+    }));
+    // the failure must be visible in local logs, not only via socket events
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('serverNames'));
+    expect(mockSpawner.stop).toHaveBeenCalled();
+  });
+
+  it('should fail with a diagnosable error when mcpEndpoint.serverNames is empty', async () => {
+    const bridge = createBridge({
+      url: 'http://gateway/mcp/sess-1',
+      token: 'tok-1',
+      serverNames: [],
+    });
+
+    await bridge.start();
+
+    expect(mockNewSession).not.toHaveBeenCalled();
+    expect(mockSocket.emit).toHaveBeenCalledWith('acp:stopped', expect.objectContaining({
+      sessionId: 'sess-1',
+      reason: 'error',
+      error: expect.stringContaining('serverNames'),
+    }));
+  });
+
+  it('should log the MCP servers passed to session/new without leaking the token', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const bridge = createBridge({
+      url: 'http://gateway/mcp/sess-1',
+      token: 'secret-token',
+      serverNames: ['fluentui-mcp'],
+    });
+
+    await bridge.start();
+
+    const logLines = logSpy.mock.calls.map((c) => String(c[0]));
+    const mcpLog = logLines.find((l) => l.includes('passing MCP servers via session/new'));
+    expect(mcpLog).toBeDefined();
+    expect(mcpLog).toContain('fluentui-mcp(type=http, url=http://gateway/mcp/sess-1/fluentui-mcp');
+    expect(mcpLog).not.toContain('secret-token');
+  });
+
+  it('should warn when passing http MCP servers to an agent without http MCP capability', async () => {
+    mockInitialize.mockResolvedValueOnce({
+      protocolVersion: 1,
+      agentCapabilities: { mcpCapabilities: { http: false, sse: true } },
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const bridge = createBridge({
+      url: 'http://gateway/mcp/sess-1',
+      token: 'tok-1',
+      serverNames: ['fluentui-mcp'],
+    });
+
+    await bridge.start();
+
+    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('mcpCapabilities.http'));
+    // still passes the servers through — the agent decides
+    expect(mockNewSession).toHaveBeenCalledWith(expect.objectContaining({
+      mcpServers: [expect.objectContaining({ type: 'http', name: 'fluentui-mcp' })],
+    }));
+  });
+});

package/src/acp/bridge.ts

@@ -10,6 +10,7 @@ export interface AcpBridgeOptions {
   cwd: string;
   additionalDirectories?: string[];
   mcpServers?: Array<{ name: string; command: string; args?: string[]; env?: Array<{ name: string; value: string }> }>;
+  mcpEndpoint?: { url: string; token: string; serverNames: string[] };
 }
 
 interface QueuedInput {
@@ -59,6 +60,39 @@ function toMcpServers(servers: AcpBridgeOptions['mcpServers']): acp.McpServer[]
   }));
 }
 
+// Sanitized, token-free summary of the MCP servers about to be sent to the
+// agent, so launch failures are diagnosable from local logs alone.
+function describeMcpServersForLog(servers: acp.McpServer[]): string {
+  if (servers.length === 0) return 'none';
+  return servers.map((s) => {
+    if ('url' in s) {
+      const headerNames = (s.headers ?? []).map((h) => h.name).join('+');
+      return `${s.name}(type=${(s as { type?: string }).type ?? 'http'}, url=${s.url}${headerNames ? `, headers=${headerNames}` : ''})`;
+    }
+    return `${s.name}(type=stdio, cmd=${(s as { command?: string }).command})`;
+  }).join(' ');
+}
+
+function toMcpEndpointServers(mcpEndpoint: NonNullable<AcpBridgeOptions['mcpEndpoint']>): acp.McpServer[] {
+  // Fail loudly with a diagnosable message instead of a raw TypeError when the
+  // upstream payload drifts from the contract (serverNames is required).
+  if (!Array.isArray(mcpEndpoint.serverNames) || mcpEndpoint.serverNames.length === 0) {
+    throw new Error(
+      `Invalid mcpEndpoint payload: "serverNames" must be a non-empty array ` +
+      `(received: ${JSON.stringify(mcpEndpoint.serverNames)}, url: ${mcpEndpoint.url})`,
+    );
+  }
+  const headers: acp.HttpHeader[] = [{ name: 'Authorization', value: `Bearer ${mcpEndpoint.token}` }];
+  // Each assembled server gets its own URL so the entry point can route
+  // standard MCP clients (which never send a serverName param) correctly.
+  return mcpEndpoint.serverNames.map((name) => ({
+    type: 'http' as const,
+    name,
+    url: `${mcpEndpoint.url}/${encodeURIComponent(name)}`,
+    headers,
+  }));
+}
+
 export function extractConfigOptions(
   configOptions: acp.SessionConfigOption[] | null | undefined,
 ): SessionConfigOptionData[] {
@@ -151,6 +185,7 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
   private cwd: string;
   private additionalDirectories: string[];
   private mcpServers: AcpBridgeOptions['mcpServers'];
+  private mcpEndpoint: AcpBridgeOptions['mcpEndpoint'];
   private connection: acp.ClientSideConnection | null = null;
   private acpSessionId: string | null = null;
   private activePrompt: Promise<acp.PromptResponse> | null = null;
@@ -164,6 +199,10 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
     resolve: (response: acp.RequestPermissionResponse) => void;
     timeout: NodeJS.Timeout;
   }>();
+  private pendingElicitations = new Map<string, {
+    resolve: (response: acp.CreateElicitationResponse) => void;
+    timeout: NodeJS.Timeout;
+  }>();
 
   // Capability snapshot from initialize / session/new / resume
   private configOptions: SessionConfigOptionData[] = [];
@@ -172,6 +211,7 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
   private authMethods: AcpAuthMethodData[] = [];
   private supportsAdditionalDirectories = false;
   private agentProtocolVersion: number | null = null;
+  private agentMcpCapabilities: { http?: boolean | null; sse?: boolean | null } | null = null;
 
   constructor(socket: Socket, options: AcpBridgeOptions, spawner?: AcpSpawner) {
     super();
@@ -180,9 +220,31 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
     this.cwd = options.cwd;
     this.additionalDirectories = options.additionalDirectories ?? [];
     this.mcpServers = options.mcpServers;
+    this.mcpEndpoint = options.mcpEndpoint;
     this.spawner = spawner ?? new AcpSpawner({ sessionId: options.sessionId, cwd: options.cwd });
   }
 
+  private resolveMcpServers(): acp.McpServer[] {
+    if (this.mcpEndpoint) {
+      return toMcpEndpointServers(this.mcpEndpoint);
+    }
+    return toMcpServers(this.mcpServers);
+  }
+
+  // Log the MCP configuration that is about to be handed to the agent via
+  // session/new (or session/resume), and warn when the agent did not
+  // advertise the required MCP transport capability in initialize.
+  private logMcpServersForSession(method: 'session/new' | 'session/resume', servers: acp.McpServer[]): void {
+    console.log(`[ACP bridge] session ${this.sessionId}: passing MCP servers via ${method}: ${describeMcpServersForLog(servers)}`);
+    const httpServers = servers.filter((s) => 'url' in s && (s as { type?: string }).type === 'http');
+    if (httpServers.length > 0 && this.agentMcpCapabilities && this.agentMcpCapabilities.http === false) {
+      console.warn(
+        `[ACP bridge] session ${this.sessionId}: agent did not advertise mcpCapabilities.http ` +
+        `but ${httpServers.length} http MCP server(s) are being passed: ${httpServers.map((s) => s.name).join(', ')}`,
+      );
+    }
+  }
+
   async start(): Promise<void> {
     if (this.initializing) return;
     this.initializing = true;
@@ -190,9 +252,11 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
     this.spawner.start();
     try {
       await this.initConnection();
+      const mcpServers = this.resolveMcpServers();
+      this.logMcpServersForSession('session/new', mcpServers);
       const result = await this.connection!.newSession({
         cwd: this.cwd,
-        mcpServers: toMcpServers(this.mcpServers),
+        mcpServers,
         additionalDirectories: this.additionalDirectories.length > 0 ? this.additionalDirectories : undefined,
       });
       this.acpSessionId = result.sessionId;
@@ -213,9 +277,12 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
     this.spawner.start();
     try {
       await this.initConnection();
+      const mcpServers = this.resolveMcpServers();
+      this.logMcpServersForSession('session/resume', mcpServers);
       const result = await this.connection!.resumeSession({
         sessionId: externalSessionId,
         cwd: this.cwd,
+        mcpServers,
         additionalDirectories: this.additionalDirectories.length > 0 ? this.additionalDirectories : undefined,
       });
       this.acpSessionId = externalSessionId;
@@ -228,7 +295,7 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
       try {
         const result = await this.connection!.newSession({
           cwd: this.cwd,
-          mcpServers: toMcpServers(this.mcpServers),
+          mcpServers: this.resolveMcpServers(),
           additionalDirectories: this.additionalDirectories.length > 0 ? this.additionalDirectories : undefined,
         });
         this.acpSessionId = result.sessionId;
@@ -399,6 +466,7 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
         session: {
           configOptions: { boolean: {} },
         },
+        elicitation: { form: {}, url: {} },
       },
       clientInfo: {
         name: 'agent-gear',
@@ -427,6 +495,12 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
       ? { name: result.agentInfo.name, version: result.agentInfo.version ?? null }
       : null;
     this.authMethods = toAuthMethods(result.authMethods);
+    this.agentMcpCapabilities = result.agentCapabilities?.mcpCapabilities ?? null;
+    console.log(
+      `[ACP bridge] session ${this.sessionId}: agent capabilities: ` +
+      `protocolVersion=${result.protocolVersion ?? 'n/a'} mcp=${JSON.stringify(this.agentMcpCapabilities)} ` +
+      `agent=${this.agentInfo ? `${this.agentInfo.name}@${this.agentInfo.version ?? 'n/a'}` : 'n/a'}`,
+    );
     this.supportsAdditionalDirectories =
       result.agentCapabilities?.sessionCapabilities?.additionalDirectories !== undefined &&
       result.agentCapabilities?.sessionCapabilities?.additionalDirectories !== null;
@@ -580,6 +654,78 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
     pending.resolve({ outcome });
   }
 
+  async unstable_createElicitation(
+    params: acp.CreateElicitationRequest,
+  ): Promise<acp.CreateElicitationResponse> {
+    // custom/未知模式不支持：立即取消，避免挂起 Agent
+    if (!acp.CreateElicitationRequest.isForm(params) && !acp.CreateElicitationRequest.isUrl(params)) {
+      return { action: 'cancel' };
+    }
+
+    const requestId = `elic_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    const toolCallId = 'toolCallId' in params ? params.toolCallId : undefined;
+
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.pendingElicitations.delete(requestId);
+        resolve({ action: 'cancel' });
+      }, 65_000);
+
+      this.pendingElicitations.set(requestId, { resolve, timeout });
+
+      if (acp.CreateElicitationRequest.isForm(params)) {
+        this.socket.emit('acp:elicitation', {
+          requestId,
+          sessionId: this.sessionId,
+          mode: 'form',
+          message: params.message,
+          ...(toolCallId != null ? { toolCallId } : {}),
+          requestedSchema: params.requestedSchema,
+        });
+      } else {
+        this.socket.emit('acp:elicitation', {
+          requestId,
+          sessionId: this.sessionId,
+          mode: 'url',
+          message: params.message,
+          ...(toolCallId != null ? { toolCallId } : {}),
+          elicitationId: params.elicitationId,
+          url: params.url,
+        });
+      }
+
+      this.emit('elicitation:sent', requestId);
+    });
+  }
+
+  handleElicitationResponse(
+    requestId: string,
+    action: 'accept' | 'decline' | 'cancel',
+    content?: Record<string, unknown>,
+  ): void {
+    const pending = this.pendingElicitations.get(requestId);
+    if (!pending) {
+      console.warn(`Elicitation request ${requestId} not found`);
+      return;
+    }
+
+    clearTimeout(pending.timeout);
+    this.pendingElicitations.delete(requestId);
+    pending.resolve({
+      action,
+      ...(action === 'accept' && content
+        ? { content: content as Record<string, acp.ElicitationContentValue> }
+        : {}),
+    });
+  }
+
+  async unstable_completeElicitation(params: acp.CompleteElicitationNotification): Promise<void> {
+    this.socket.emit('acp:elicitation:complete', {
+      sessionId: this.sessionId,
+      elicitationId: params.elicitationId,
+    });
+  }
+
   // ── text buffering ──
 
   private scheduleTextFlush(): void {
@@ -613,14 +759,17 @@ export class AcpSessionBridge extends EventEmitter implements acp.Client {
   }
 
   private emitStopped(reason: string, exitCode?: number): void {
+    console.log(`[ACP bridge] session ${this.sessionId} stopped: reason=${reason} exitCode=${exitCode ?? 'n/a'}`);
     this.stopped = true;
     this.socket.emit('acp:stopped', { sessionId: this.sessionId, reason, exitCode });
     this.emit('acp:stopped', { sessionId: this.sessionId, reason, exitCode });
   }
 
   private handleError(error: unknown): void {
-    this.stopped = true;
     const msg = error instanceof Error ? error.message : String(error);
+    const stack = error instanceof Error ? error.stack : undefined;
+    console.error(`[ACP bridge] session ${this.sessionId} failed: ${msg}${stack ? `\n${stack}` : ''}`);
+    this.stopped = true;
     this.socket.emit('acp:stopped', {
       sessionId: this.sessionId,
       reason: 'error',

package/src/acp/spawner.ts

@@ -29,7 +29,7 @@ export class AcpSpawner {
 
   start(): void {
     const cmd = this.resolveCommand();
-    console.log(`Starting ACP server ${cmd}`)
+    console.log(`Starting ACP server: session=${this.sessionId} cmd=${cmd} args=${JSON.stringify(this.args)} cwd=${this.cwd}`);
     mkdirSync(this.cwd, { recursive: true });
 
     const spawnOptions: SpawnOptions = {
@@ -43,17 +43,17 @@ export class AcpSpawner {
     this.process = spawn(cmd, this.args, spawnOptions);
 
     this.process.stderr?.on('data', (data: Buffer) => {
-      console.error(`ACP stderr: ${data.toString()}`);
+      console.error(`ACP stderr (session=${this.sessionId}): ${data.toString()}`);
     });
 
     this.process.on('exit', (code, signal) => {
-      console.log(`ACP process exited with code ${code} and signal ${signal}`);
+      console.log(`ACP process exited: session=${this.sessionId} code=${code} signal=${signal} cmd=${cmd} args=${JSON.stringify(this.args)}`);
       this.process = null;
       this.resolveClosed?.();
     });
 
     this.process.on('error', (error) => {
-      console.error('ACP process error:', error);
+      console.error(`ACP process error (session=${this.sessionId}, cmd=${cmd}):`, error);
     });
   }
 

package/src/acp/sync-bridge.ts

@@ -124,4 +124,12 @@ export class AcpSyncBridge implements acp.Client {
   async requestPermission(): Promise<acp.RequestPermissionResponse> {
     return { outcome: { outcome: 'cancelled' } };
   }
+
+  async unstable_createElicitation(): Promise<acp.CreateElicitationResponse> {
+    return { action: 'cancel' };
+  }
+
+  async unstable_completeElicitation(): Promise<void> {
+    // no-op
+  }
 }

package/src/commands/mcp-proxy.ts

@@ -7,6 +7,92 @@ interface McpProxyOptions {
   command: string;
 }
 
+interface JsonRpcRequest {
+  jsonrpc?: string;
+  id?: unknown;
+  method?: string;
+  [key: string]: unknown;
+}
+
+const FORWARD_TIMEOUT_MS = 30_000;
+
+// JSON-RPC notifications have no id and MUST NOT be waited on: per the MCP
+// spec the server never responds to them. Waiting would stall every hop of
+// the forward chain for the full timeout.
+function isNotification(request: JsonRpcRequest): boolean {
+  return request.id === undefined || request.id === null;
+}
+
+// Persistent line-buffered JSON-RPC dispatcher over a child process' stdio.
+// Responses are matched to requests by id, so chunked responses (a single
+// 'data' event is NOT guaranteed to contain exactly one complete JSON
+// message) and concurrent in-flight requests are handled correctly.
+export function createStdioDispatcher(child: ChildProcess) {
+  let buffer = '';
+  const pending = new Map<unknown, { resolve: (value: unknown) => void; reject: (reason: Error) => void; timeout: NodeJS.Timeout; method: string }>();
+
+  child.stdout?.on('data', (data: Buffer) => {
+    buffer += data.toString();
+    let idx;
+    while ((idx = buffer.indexOf('\n')) >= 0) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (!line) continue;
+      let msg: { id?: unknown; error?: { message?: string } };
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        console.error(`[MCP proxy] ignoring non-JSON line from child: ${line.slice(0, 200)}`);
+        continue;
+      }
+      const entry = pending.get(msg.id);
+      if (!entry) {
+        console.error(`[MCP proxy] ignoring response with unknown id: ${JSON.stringify(msg.id)}`);
+        continue;
+      }
+      clearTimeout(entry.timeout);
+      pending.delete(msg.id);
+      console.log(`[MCP proxy] response: method=${entry.method} id=${JSON.stringify(msg.id)}${msg.error ? ` error=${msg.error.message}` : ''}`);
+      entry.resolve(msg);
+    }
+  });
+
+  const rejectAll = (reason: Error) => {
+    for (const [, entry] of pending) {
+      clearTimeout(entry.timeout);
+      entry.reject(reason);
+    }
+    pending.clear();
+  };
+
+  child.on('exit', (code) => {
+    console.log(`[MCP proxy] MCP command exited with code ${code}, rejecting ${pending.size} pending request(s)`);
+    rejectAll(new Error(`MCP command exited with code ${code}`));
+  });
+
+  return {
+    forward(request: JsonRpcRequest): Promise<unknown> {
+      const method = request.method ?? '(unknown)';
+      if (isNotification(request)) {
+        // Fire-and-forget: deliver the notification (e.g. notifications/initialized
+        // completes the MCP handshake) but do not wait for a response.
+        console.log(`[MCP proxy] forwarding notification: method=${method}`);
+        child.stdin?.write(JSON.stringify(request) + '\n');
+        return Promise.resolve(null);
+      }
+      console.log(`[MCP proxy] forwarding request: method=${method} id=${JSON.stringify(request.id)}`);
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pending.delete(request.id);
+          reject(new Error(`Request timeout waiting for ${method}`));
+        }, FORWARD_TIMEOUT_MS);
+        pending.set(request.id, { resolve, reject, timeout, method });
+        child.stdin?.write(JSON.stringify(request) + '\n');
+      });
+    },
+  };
+}
+
 export async function startMcpRegistration(options: McpProxyOptions): Promise<void> {
   const { server, key, command } = options;
 
@@ -45,10 +131,6 @@ export async function startMcpRegistration(options: McpProxyOptions): Promise<vo
     console.error('Failed to start MCP command:', err.message);
   });
 
-  child.on('exit', (code) => {
-    console.log(`MCP command exited with code ${code}`);
-  });
-
   // 3. Establish WebSocket connection
   const socket = ioClient(`${server}/mcp-proxy`, {
     transports: ['websocket'],
@@ -69,16 +151,18 @@ export async function startMcpRegistration(options: McpProxyOptions): Promise<vo
   });
 
   // 4. Bridge requests
-  socket.on('proxy:request', async (data: { requestId: string; request: any }) => {
+  const dispatcher = createStdioDispatcher(child);
+  socket.on('proxy:request', async (data: { requestId: string; request: JsonRpcRequest }) => {
     try {
-      const response = await forwardToChild(child, data.request);
+      const response = await dispatcher.forward(data.request);
       socket.emit('proxy:response', { requestId: data.requestId, response });
     } catch (err: any) {
+      console.error(`[MCP proxy] forward failed: method=${data.request?.method} id=${JSON.stringify(data.request?.id)} error=${err.message}`);
       socket.emit('proxy:response', {
         requestId: data.requestId,
         response: {
           jsonrpc: '2.0',
-          id: data.request.id,
+          id: data.request.id ?? null,
           error: { code: -32603, message: err.message },
         },
       });
@@ -105,24 +189,3 @@ export async function startMcpRegistration(options: McpProxyOptions): Promise<vo
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 }
-
-function forwardToChild(child: ChildProcess, request: any): Promise<any> {
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(new Error('Request timeout'));
-    }, 30000);
-
-    const onData = (data: Buffer) => {
-      clearTimeout(timeout);
-      child.stdout?.removeListener('data', onData);
-      try {
-        resolve(JSON.parse(data.toString()));
-      } catch {
-        reject(new Error('Invalid JSON response from MCP command'));
-      }
-    };
-
-    child.stdout?.on('data', onData);
-    child.stdin?.write(JSON.stringify(request) + '\n');
-  });
-}