agent-gear 1.1.6 → 1.1.7

package/src/socketio-client.ts

@@ -18,6 +18,7 @@ import { gatewayManager } from './gateway.js';
 const CONTROLLER_VERSION = '1.1.1';
 const acpBridges = new Map<string, AcpSessionBridge>();
 const permissionRequestBridge = new Map<string, AcpSessionBridge>();
+const elicitationRequestBridge = new Map<string, AcpSessionBridge>();
 
 function createSpawner(serverType: string, sessionId: string, cwd: string): AcpSpawner {
   const config = acpDetector.getSpawnerConfig(serverType);
@@ -48,6 +49,7 @@ interface AcpStartPayload {
   serverType: string;
   cwd: string;
   mcpServers?: Array<{ name: string; command: string; args?: string[]; env?: Array<{ name: string; value: string }> }>;
+  mcpEndpoint?: { url: string; token: string; serverNames: string[] };
   additionalDirectories?: string[];
 }
 
@@ -56,6 +58,19 @@ interface AcpMessagePayload {
   message: { type: string; content: string; attachments?: Array<Record<string, unknown>> };
 }
 
+// Summarize the MCP configuration of an acp:start/acp:resume payload for logs,
+// without leaking the endpoint token.
+function describeMcpConfig(data: { mcpServers?: unknown[]; mcpEndpoint?: { url: string; serverNames?: string[] } }): string {
+  const parts: string[] = [];
+  if (data.mcpServers && data.mcpServers.length > 0) {
+    parts.push(`mcpServers=${data.mcpServers.length}`);
+  }
+  if (data.mcpEndpoint) {
+    parts.push(`mcpEndpoint(url=${data.mcpEndpoint.url}, serverNames=${JSON.stringify(data.mcpEndpoint.serverNames ?? null)})`);
+  }
+  return parts.length > 0 ? `mcp=[${parts.join(' ')}]` : 'mcp=[none]';
+}
+
 interface AcpCancelPayload {
   sessionId: string;
 }
@@ -103,6 +118,7 @@ interface AcpResumePayload {
   externalSessionId: string;
   serverType: string;
   cwd: string;
+  mcpEndpoint?: { url: string; token: string; serverNames: string[] };
   additionalDirectories?: string[];
 }
 
@@ -244,7 +260,7 @@ export function connectToServer(
   });
 
   socket.on('acp:start', async (data: AcpStartPayload) => {
-    console.log(`[ACP ctrl] acp:start received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${data.serverType} cwd=${data.cwd}`);
+    console.log(`[ACP ctrl] acp:start received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${data.serverType} cwd=${data.cwd} ${describeMcpConfig(data)}`);
 
     try {
       const spawner = createSpawner(data.serverType, data.sessionId, data.cwd);
@@ -252,6 +268,7 @@ export function connectToServer(
         sessionId: data.sessionId,
         cwd: data.cwd,
         mcpServers: data.mcpServers,
+        mcpEndpoint: data.mcpEndpoint,
         additionalDirectories: data.additionalDirectories,
       }, spawner);
 
@@ -261,6 +278,10 @@ export function connectToServer(
         permissionRequestBridge.set(requestId, bridge);
       });
 
+      bridge.on('elicitation:sent', (requestId: string) => {
+        elicitationRequestBridge.set(requestId, bridge);
+      });
+
       const onInitialized = (payload: Record<string, unknown>) => {
         if (payload.sessionId !== data.sessionId) return;
         bridge.off('acp:initialized', onInitialized);
@@ -292,7 +313,7 @@ export function connectToServer(
         bridge.off('acp:initialized', onInitialized);
         bridge.off('acp:stopped', onStopped);
         acpBridges.delete(data.sessionId);
-        console.log(`[ACP ctrl] emitting acp:start:result: requestId=${data.requestId} sessionId=${data.sessionId} success=false`);
+        console.log(`[ACP ctrl] emitting acp:start:result: requestId=${data.requestId} sessionId=${data.sessionId} success=false reason=${payload.reason} error=${payload.error ?? 'n/a'}`);
         socket.emit('acp:start:result', {
           requestId: data.requestId,
           sessionId: data.sessionId,
@@ -318,13 +339,14 @@ export function connectToServer(
   });
 
   socket.on('acp:resume', async (data: AcpResumePayload) => {
-    console.log(`[ACP ctrl] acp:resume received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${data.serverType} externalSessionId=${data.externalSessionId}`);
+    console.log(`[ACP ctrl] acp:resume received: requestId=${data.requestId} sessionId=${data.sessionId} serverType=${data.serverType} externalSessionId=${data.externalSessionId} ${describeMcpConfig(data)}`);
 
     try {
       const spawner = createSpawner(data.serverType, data.sessionId, data.cwd);
       const bridge = new AcpSessionBridge(socket, {
         sessionId: data.sessionId,
         cwd: data.cwd,
+        mcpEndpoint: data.mcpEndpoint,
         additionalDirectories: data.additionalDirectories,
       }, spawner);
 
@@ -334,6 +356,10 @@ export function connectToServer(
         permissionRequestBridge.set(requestId, bridge);
       });
 
+      bridge.on('elicitation:sent', (requestId: string) => {
+        elicitationRequestBridge.set(requestId, bridge);
+      });
+
       const onInitialized = (payload: Record<string, unknown>) => {
         if (payload.sessionId !== data.sessionId) return;
         bridge.off('acp:initialized', onInitialized);
@@ -360,6 +386,7 @@ export function connectToServer(
         bridge.off('acp:initialized', onInitialized);
         bridge.off('acp:stopped', onStopped);
         acpBridges.delete(data.sessionId);
+        console.log(`[ACP ctrl] emitting acp:resume:result: requestId=${data.requestId} sessionId=${data.sessionId} success=false reason=${payload.reason} error=${payload.error ?? 'n/a'}`);
         socket.emit('acp:resume:result', {
           requestId: data.requestId,
           sessionId: data.sessionId,
@@ -769,11 +796,24 @@ export function connectToServer(
     }
   });
 
+  socket.on('acp:elicitation:response', (data: {
+    requestId: string;
+    action: 'accept' | 'decline' | 'cancel';
+    content?: Record<string, unknown>;
+  }) => {
+    const bridge = elicitationRequestBridge.get(data.requestId);
+    if (bridge) {
+      elicitationRequestBridge.delete(data.requestId);
+      bridge.handleElicitationResponse(data.requestId, data.action, data.content);
+    }
+  });
+
   socket.on('disconnect', (reason) => {
     console.log(`Disconnected: ${reason}`);
     heartbeat.stop();
     gatewayManager.closeAll();
     permissionRequestBridge.clear();
+    elicitationRequestBridge.clear();
   });
 
   socket.on('connect_error', (err) => {

package/tests/acp-bridge.test.ts

@@ -20,6 +20,10 @@ let mockConnInstance = buildMockConn();
 vi.mock('@agentclientprotocol/sdk', () => ({
   ndJsonStream: vi.fn(() => ({})),
   ClientSideConnection: vi.fn(function () { return mockConnInstance; }),
+  CreateElicitationRequest: {
+    isForm: (v: { mode?: string }) => v.mode === 'form',
+    isUrl: (v: { mode?: string }) => v.mode === 'url',
+  },
 }));
 
 import { AcpSessionBridge, extractConfigOptions } from '../../src/acp/bridge.js';
@@ -80,6 +84,7 @@ describe('AcpSessionBridge', () => {
           session: {
             configOptions: { boolean: {} },
           },
+          elicitation: { form: {}, url: {} },
         },
         clientInfo: { name: 'agent-gear', version: '1.1.5' },
       });
@@ -235,6 +240,7 @@ describe('AcpSessionBridge', () => {
       expect(mc().resumeSession).toHaveBeenCalledWith({
         sessionId: 'existing-sess-id',
         cwd: '/home/user',
+        mcpServers: [],
       });
       expect(emitSpy).toHaveBeenCalledWith(expect.objectContaining({
         sessionId: 'sess-1',
@@ -525,6 +531,119 @@ describe('AcpSessionBridge', () => {
     });
   });
 
+  describe('unstable_createElicitation', () => {
+    it('form 模式：emit acp:elicitation 并在响应后 resolve accept + content', async () => {
+      const bridge = createBridge();
+      const requestedSchema = {
+        type: 'object',
+        properties: { name: { type: 'string' } },
+        required: ['name'],
+      };
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'form',
+        message: 'Need your name',
+        sessionId: 'acp-sess-abc',
+        toolCallId: 'tc-1',
+        requestedSchema,
+      } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation', expect.objectContaining({
+        sessionId: 'sess-1',
+        mode: 'form',
+        message: 'Need your name',
+        toolCallId: 'tc-1',
+        requestedSchema,
+      }));
+
+      const emitCall = mockSocket.emit.mock.calls.find((c: unknown[]) => c[0] === 'acp:elicitation');
+      const requestId = (emitCall![1] as { requestId: string }).requestId;
+      expect(requestId).toMatch(/^elic_/);
+
+      bridge.handleElicitationResponse(requestId, 'accept', { name: 'ash' });
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'accept', content: { name: 'ash' } });
+    });
+
+    it('url 模式：透传 elicitationId 与 url', async () => {
+      const bridge = createBridge();
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'url',
+        message: 'Authorize access',
+        sessionId: 'acp-sess-abc',
+        elicitationId: 'elic-agent-1',
+        url: 'https://example.com/auth',
+      } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation', expect.objectContaining({
+        sessionId: 'sess-1',
+        mode: 'url',
+        message: 'Authorize access',
+        elicitationId: 'elic-agent-1',
+        url: 'https://example.com/auth',
+      }));
+
+      const emitCall = mockSocket.emit.mock.calls.find((c: unknown[]) => c[0] === 'acp:elicitation');
+      const requestId = (emitCall![1] as { requestId: string }).requestId;
+      bridge.handleElicitationResponse(requestId, 'decline');
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'decline' });
+    });
+
+    it('custom/未知模式：立即返回 cancel 且不 emit socket 事件', async () => {
+      const bridge = createBridge();
+
+      const result = await bridge.unstable_createElicitation({
+        mode: '_vendor_custom',
+        message: 'custom request',
+        sessionId: 'acp-sess-abc',
+      } as never);
+
+      expect(result).toEqual({ action: 'cancel' });
+      expect(mockSocket.emit).not.toHaveBeenCalledWith('acp:elicitation', expect.anything());
+    });
+
+    it('65s 超时自动 resolve cancel', async () => {
+      const bridge = createBridge();
+
+      const promise = bridge.unstable_createElicitation({
+        mode: 'form',
+        message: 'm',
+        sessionId: 'acp-sess-abc',
+        requestedSchema: { type: 'object' },
+      } as never);
+
+      await vi.advanceTimersByTimeAsync(65_000);
+
+      const result = await promise;
+      expect(result).toEqual({ action: 'cancel' });
+    });
+
+    it('handleElicitationResponse 未知 requestId 打 warn 不抛错', () => {
+      const bridge = createBridge();
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      expect(() => bridge.handleElicitationResponse('elic_unknown', 'cancel')).not.toThrow();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('elic_unknown'));
+    });
+  });
+
+  describe('unstable_completeElicitation', () => {
+    it('emit acp:elicitation:complete', async () => {
+      const bridge = createBridge();
+
+      await bridge.unstable_completeElicitation({ elicitationId: 'elic-agent-1' } as never);
+
+      expect(mockSocket.emit).toHaveBeenCalledWith('acp:elicitation:complete', {
+        sessionId: 'sess-1',
+        elicitationId: 'elic-agent-1',
+      });
+    });
+  });
+
   describe('setMode', () => {
     it('should call connection.setSessionMode', async () => {
       const bridge = createBridge();

package/tests/acp-spawner.test.ts

@@ -68,7 +68,34 @@ describe('AcpSpawner', () => {
       spawner.start();
       const stderr = mockProcess.stderr as Readable;
       stderr.emit('data', Buffer.from('some warning\n'));
-      expect(consoleErrorSpy).toHaveBeenCalledWith('ACP stderr: some warning\n');
+      expect(consoleErrorSpy).toHaveBeenCalledWith('ACP stderr (session=sess-1): some warning\n');
+    });
+
+    it('should log resolved command, args and cwd on start', () => {
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      spawner.start();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'Starting ACP server: session=sess-1 cmd=/usr/bin/opencode args=["acp"] cwd=/tmp/project',
+      );
+    });
+
+    it('should log exit code, signal and spawn params on process exit', () => {
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      spawner.start();
+      mockProcess.emit('exit', 1, null);
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        'ACP process exited: session=sess-1 code=1 signal=null cmd=/usr/bin/opencode args=["acp"]',
+      );
+    });
+
+    it('should log process error with session and command', () => {
+      spawner.start();
+      const error = new Error('spawn opencode ENOENT');
+      mockProcess.emit('error', error);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        'ACP process error (session=sess-1, cmd=/usr/bin/opencode):',
+        error,
+      );
     });
 
     it('should resolve closed on process exit', async () => {

package/tests/acp-wire-elicitation.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { readFileSync, rmSync, mkdtempSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Force the real (unmocked) ACP SDK through the vite pipeline (same rationale
+// as acp-wire-mcp.test.ts): keep actual SDK serialization behavior on the wire.
+vi.mock('@agentclientprotocol/sdk', async (importOriginal) => {
+  return await importOriginal<typeof import('@agentclientprotocol/sdk')>();
+});
+
+import { AcpSessionBridge } from '../../src/acp/bridge.js';
+import { AcpSpawner } from '../../src/acp/spawner.js';
+
+const FAKE_AGENT = join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'fake-acp-agent.mjs');
+
+interface CapturedEntry {
+  method: string;
+  params?: Record<string, unknown>;
+  response?: Record<string, unknown> | null;
+}
+
+// Wire-level test: drives a REAL ACP client connection against a fake agent
+// process that issues `elicitation/create` (the same wire behavior as an
+// eliciting agent such as opencode), and asserts both the Socket.IO payload
+// emitted by the bridge and the exact JSON-RPC response that goes back over
+// stdio — no mocked ClientSideConnection.
+describe('AcpSessionBridge - Elicitation wire format (ACP spec)', () => {
+  let workdir: string;
+  let captureFile: string;
+  let bridge: AcpSessionBridge | null = null;
+
+  afterEach(async () => {
+    delete process.env.CAPTURE_FILE;
+    delete process.env.FAKE_AGENT_ELICITATION;
+    if (bridge) {
+      await bridge.stop().catch(() => {});
+      bridge = null;
+    }
+    if (workdir) rmSync(workdir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function setup(mode: 'form' | 'url') {
+    workdir = mkdtempSync(join(tmpdir(), 'acp-wire-elic-'));
+    captureFile = join(workdir, 'capture.jsonl');
+    process.env.CAPTURE_FILE = captureFile;
+    process.env.FAKE_AGENT_ELICITATION = mode;
+    const spawner = new AcpSpawner({
+      sessionId: 'sess-wire',
+      cwd: workdir,
+      command: process.execPath,
+      args: [FAKE_AGENT],
+    });
+    const socket = { emit: vi.fn(), on: vi.fn(), off: vi.fn() };
+    bridge = new AcpSessionBridge(socket as never, {
+      sessionId: 'sess-wire',
+      cwd: workdir,
+    }, spawner);
+    return socket;
+  }
+
+  function readCapture(): CapturedEntry[] {
+    if (!existsSync(captureFile)) return [];
+    return readFileSync(captureFile, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
+  }
+
+  function emittedCall(socket: { emit: ReturnType<typeof vi.fn> }, event: string) {
+    return socket.emit.mock.calls.find((c) => c[0] === event);
+  }
+
+  it('should advertise elicitation capabilities in initialize on the wire', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    setup('form');
+
+    await bridge!.start();
+
+    const init = readCapture().find((e) => e.method === 'initialize');
+    expect(init).toBeDefined();
+    const capabilities = init!.params!.clientCapabilities as Record<string, unknown>;
+    expect(capabilities.elicitation).toEqual({ form: {}, url: {} });
+  }, 15000);
+
+  it('should forward form elicitation and respond with spec-compliant payload', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const socket = setup('form');
+
+    await bridge!.start();
+    bridge!.sendInput({ type: 'text', content: 'please refactor this' });
+
+    // The agent's elicitation/create must surface as an acp:elicitation socket event
+    await vi.waitFor(() => {
+      expect(emittedCall(socket, 'acp:elicitation')).toBeDefined();
+    }, { timeout: 10000 });
+
+    const [, payload] = emittedCall(socket, 'acp:elicitation')!;
+    expect(payload.sessionId).toBe('sess-wire');
+    expect(payload.mode).toBe('form');
+    expect(payload.message).toBe('How should I approach this refactoring?');
+    expect(payload.requestedSchema.required).toEqual(['strategy']);
+    expect(payload.requestId).toMatch(/^elic_/);
+
+    // Simulate the server returning the user's answer
+    bridge!.handleElicitationResponse(payload.requestId, 'accept', { strategy: 'balanced' });
+
+    // The agent must receive a spec-compliant CreateElicitationResponse on the wire
+    await vi.waitFor(() => {
+      const elicitation = readCapture().find((e) => e.method === 'elicitation/create');
+      expect(elicitation?.response).toBeDefined();
+    }, { timeout: 10000 });
+
+    const elicitation = readCapture().find((e) => e.method === 'elicitation/create');
+    expect(elicitation!.response).toEqual({ action: 'accept', content: { strategy: 'balanced' } });
+
+    // Prompt completes after the elicitation resolves
+    await vi.waitFor(() => {
+      expect(emittedCall(socket, 'acp:prompt:complete')).toBeDefined();
+    }, { timeout: 10000 });
+  }, 20000);
+
+  it('should forward url elicitation and relay the completion notification', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const socket = setup('url');
+
+    await bridge!.start();
+    bridge!.sendInput({ type: 'text', content: 'connect my account' });
+
+    await vi.waitFor(() => {
+      expect(emittedCall(socket, 'acp:elicitation')).toBeDefined();
+    }, { timeout: 10000 });
+
+    const [, payload] = emittedCall(socket, 'acp:elicitation')!;
+    expect(payload.mode).toBe('url');
+    expect(payload.elicitationId).toBe('fake-oauth-001');
+    expect(payload.url).toBe('https://agent.example.com/connect?elicitationId=fake-oauth-001');
+    expect(payload.message).toBe('Please authorize access to your repositories.');
+
+    // User consented to open the URL (accept without content)
+    bridge!.handleElicitationResponse(payload.requestId, 'accept');
+
+    await vi.waitFor(() => {
+      const elicitation = readCapture().find((e) => e.method === 'elicitation/create');
+      expect(elicitation?.response).toBeDefined();
+    }, { timeout: 10000 });
+
+    const elicitation = readCapture().find((e) => e.method === 'elicitation/create');
+    expect(elicitation!.response).toEqual({ action: 'accept' });
+
+    // The agent's elicitation/complete notification must be forwarded
+    await vi.waitFor(() => {
+      expect(emittedCall(socket, 'acp:elicitation:complete')).toBeDefined();
+    }, { timeout: 10000 });
+
+    const [, completePayload] = emittedCall(socket, 'acp:elicitation:complete')!;
+    expect(completePayload).toEqual({ sessionId: 'sess-wire', elicitationId: 'fake-oauth-001' });
+  }, 20000);
+});

package/tests/acp-wire-mcp.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { readFileSync, rmSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Force the real (unmocked) ACP SDK through the vite pipeline: returning the
+// original module keeps actual SDK serialization behavior while avoiding the
+// node-native externalization that breaks .js -> .ts source resolution.
+vi.mock('@agentclientprotocol/sdk', async (importOriginal) => {
+  return await importOriginal<typeof import('@agentclientprotocol/sdk')>();
+});
+
+import { AcpSessionBridge } from '../../src/acp/bridge.js';
+import { AcpSpawner } from '../../src/acp/spawner.js';
+
+const FAKE_AGENT = join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'fake-acp-agent.mjs');
+
+// Wire-level test: drives a REAL ACP client connection (SDK serialization,
+// ndJsonStream) against a fake agent process, and asserts the exact JSON-RPC
+// payload that goes over stdin — no mocked ClientSideConnection.
+describe('AcpSessionBridge - MCP wire format (ACP spec)', () => {
+  let workdir: string;
+  let captureFile: string;
+  let bridge: AcpSessionBridge | null = null;
+
+  afterEach(async () => {
+    delete process.env.CAPTURE_FILE;
+    if (bridge) {
+      await bridge.stop().catch(() => {});
+      bridge = null;
+    }
+    if (workdir) rmSync(workdir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function setup() {
+    workdir = mkdtempSync(join(tmpdir(), 'acp-wire-'));
+    captureFile = join(workdir, 'capture.jsonl');
+    process.env.CAPTURE_FILE = captureFile;
+    const spawner = new AcpSpawner({
+      sessionId: 'sess-wire',
+      cwd: workdir,
+      command: process.execPath,
+      args: [FAKE_AGENT],
+    });
+    const socket = { emit: vi.fn(), on: vi.fn(), off: vi.fn() };
+    bridge = new AcpSessionBridge(socket as never, {
+      sessionId: 'sess-wire',
+      cwd: workdir,
+      mcpEndpoint: {
+        url: 'http://gateway/mcp/sess-wire',
+        token: 'wire-token',
+        serverNames: ['fluentui-mcp', 'fs-mcp'],
+      },
+    }, spawner);
+    return socket;
+  }
+
+  function readCapture(): Array<{ method: string; params: Record<string, unknown> }> {
+    return readFileSync(captureFile, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+  }
+
+  it('should send session/new with spec-compliant mcpServers on the wire', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    setup();
+
+    await bridge!.start();
+
+    const captured = readCapture();
+    expect(captured).toHaveLength(1);
+    expect(captured[0].method).toBe('session/new');
+    // ACP spec (session/new): mcpServers entries for HTTP transport are
+    // { type: "http", name, url, headers: [{ name, value }] }
+    expect(captured[0].params.mcpServers).toEqual([
+      {
+        type: 'http',
+        name: 'fluentui-mcp',
+        url: 'http://gateway/mcp/sess-wire/fluentui-mcp',
+        headers: [{ name: 'Authorization', value: 'Bearer wire-token' }],
+      },
+      {
+        type: 'http',
+        name: 'fs-mcp',
+        url: 'http://gateway/mcp/sess-wire/fs-mcp',
+        headers: [{ name: 'Authorization', value: 'Bearer wire-token' }],
+      },
+    ]);
+    expect(captured[0].params.cwd).toBe(workdir);
+
+    // The MCP handoff must be visible in logs, without leaking the token
+    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-wire/fluentui-mcp, headers=Authorization)');
+    expect(mcpLog).not.toContain('wire-token');
+  }, 15000);
+
+  it('should send session/resume with spec-compliant mcpServers on the wire', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    setup();
+
+    await bridge!.resume('ext-session-1');
+
+    const captured = readCapture();
+    expect(captured).toHaveLength(1);
+    expect(captured[0].method).toBe('session/resume');
+    expect(captured[0].params.sessionId).toBe('ext-session-1');
+    expect(captured[0].params.mcpServers).toEqual([
+      expect.objectContaining({ type: 'http', name: 'fluentui-mcp' }),
+      expect.objectContaining({ type: 'http', name: 'fs-mcp' }),
+    ]);
+  }, 15000);
+});