@google/gemini-cli-core 0.31.0-preview.2 → 0.32.0-preview.0

package/dist/src/tools/mcp-client.test.js

@@ -25,6 +25,13 @@ const EMPTY_CONFIG = {
     allowedEnvironmentVariables: [],
     blockedEnvironmentVariables: [],
 };
+const MOCK_CONTEXT_DEFAULT = {
+    sanitizationConfig: EMPTY_CONFIG,
+    emitMcpDiagnostic: vi.fn(),
+    setUserInteractedWithMcp: vi.fn(),
+    isTrustedFolder: vi.fn().mockReturnValue(true),
+};
+let MOCK_CONTEXT = MOCK_CONTEXT_DEFAULT;
 vi.mock('@modelcontextprotocol/sdk/client/stdio.js');
 vi.mock('@modelcontextprotocol/sdk/client/index.js');
 vi.mock('@google/genai');
@@ -43,6 +50,12 @@ describe('mcp-client', () => {
     let workspaceContext;
     let testWorkspace;
     beforeEach(() => {
+        MOCK_CONTEXT = {
+            sanitizationConfig: EMPTY_CONFIG,
+            emitMcpDiagnostic: vi.fn(),
+            setUserInteractedWithMcp: vi.fn(),
+            isTrustedFolder: vi.fn().mockReturnValue(true),
+        };
         // create a tmp dir for this test
         // Create a unique temporary directory for the workspace to avoid conflicts
         testWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), 'gemini-agent-test-'));
@@ -95,9 +108,9 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await client.discover({});
+            await client.discover(MOCK_CONTEXT);
             expect(mockedClient.listTools).toHaveBeenCalledWith({}, expect.objectContaining({ timeout: 600000, progressReporter: client }));
         });
         it('should not skip tools even if a parameter is missing a type', async () => {
@@ -157,9 +170,9 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await client.discover({});
+            await client.discover(MOCK_CONTEXT);
             expect(mockedToolRegistry.registerTool).toHaveBeenCalledTimes(2);
             expect(consoleWarnSpy).not.toHaveBeenCalled();
             consoleWarnSpy.mockRestore();
@@ -194,10 +207,10 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await expect(client.discover({})).rejects.toThrow('Test error');
-            expect(coreEvents.emitFeedback).toHaveBeenCalledWith('error', `Error discovering prompts from test-server: Test error`, expect.any(Error));
+            await expect(client.discover(MOCK_CONTEXT)).rejects.toThrow('Test error');
+            expect(MOCK_CONTEXT.emitMcpDiagnostic).toHaveBeenCalledWith('error', `Error discovering prompts from test-server: Test error`, expect.any(Error), 'test-server');
         });
         it('should not discover tools if server does not support them', async () => {
             const mockedClient = {
@@ -229,9 +242,9 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await expect(client.discover({})).rejects.toThrow('No prompts, tools, or resources found on the server.');
+            await expect(client.discover(MOCK_CONTEXT)).rejects.toThrow('No prompts, tools, or resources found on the server.');
         });
         it('should discover tools if server supports them', async () => {
             const mockedClient = {
@@ -272,9 +285,9 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await client.discover({});
+            await client.discover(MOCK_CONTEXT);
             expect(mockedToolRegistry.registerTool).toHaveBeenCalledOnce();
         });
         it('should register tool with readOnlyHint and preserve annotations', async () => {
@@ -322,7 +335,7 @@ describe('mcp-client', () => {
                 setResourcesForServer: vi.fn(),
                 removeResourcesByServer: vi.fn(),
             };
-            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
             await client.discover(mockConfig);
             // Verify tool registration
@@ -379,7 +392,7 @@ describe('mcp-client', () => {
                 setResourcesForServer: vi.fn(),
                 removeResourcesByServer: vi.fn(),
             };
-            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
             await client.discover(mockConfig);
             expect(mockedToolRegistry.registerTool).toHaveBeenCalledOnce();
@@ -434,7 +447,7 @@ describe('mcp-client', () => {
                 setResourcesForServer: vi.fn(),
                 removeResourcesByServer: vi.fn(),
             };
-            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
             await client.discover(mockConfig);
             expect(mockedToolRegistry.registerTool).toHaveBeenCalledOnce();
@@ -500,9 +513,9 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await client.discover({});
+            await client.discover(MOCK_CONTEXT);
             expect(mockedToolRegistry.registerTool).toHaveBeenCalledOnce();
             const registeredTool = vi.mocked(mockedToolRegistry.registerTool).mock
                 .calls[0][0];
@@ -564,9 +577,9 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await client.discover({});
+            await client.discover(MOCK_CONTEXT);
             expect(resourceRegistry.setResourcesForServer).toHaveBeenCalledWith('test-server', [
                 expect.objectContaining({
                     uri: 'file:///tmp/resource.txt',
@@ -632,16 +645,16 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await client.discover({});
+            await client.discover(MOCK_CONTEXT);
             expect(mockedClient.setNotificationHandler).toHaveBeenCalledTimes(2);
             expect(resourceListHandler).toBeDefined();
             await resourceListHandler?.({
                 method: 'notifications/resources/list_changed',
             });
             expect(resourceRegistry.setResourcesForServer).toHaveBeenLastCalledWith('test-server', [expect.objectContaining({ uri: 'file:///tmp/two.txt' })]);
-            expect(coreEvents.emitFeedback).toHaveBeenCalledWith('info', 'Resources updated for server: test-server');
+            expect(MOCK_CONTEXT.emitMcpDiagnostic).toHaveBeenCalledWith('info', 'Resources updated for server: test-server', undefined, 'test-server');
         });
         it('refreshes prompts when prompt list change notification is received', async () => {
             let listCallCount = 0;
@@ -691,9 +704,9 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, promptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await client.discover({ sanitizationConfig: EMPTY_CONFIG });
+            await client.discover(MOCK_CONTEXT);
             expect(mockedClient.setNotificationHandler).toHaveBeenCalledTimes(2);
             expect(promptListHandler).toBeDefined();
             await promptListHandler?.({
@@ -701,7 +714,7 @@ describe('mcp-client', () => {
             });
             expect(promptRegistry.removePromptsByServer).toHaveBeenCalledWith('test-server');
             expect(promptRegistry.registerPrompt).toHaveBeenLastCalledWith(expect.objectContaining({ name: 'two' }));
-            expect(coreEvents.emitFeedback).toHaveBeenCalledWith('info', 'Prompts updated for server: test-server');
+            expect(MOCK_CONTEXT.emitMcpDiagnostic).toHaveBeenCalledWith('info', 'Prompts updated for server: test-server', undefined, 'test-server');
         });
         it('should remove tools and prompts on disconnect', async () => {
             const mockedClient = {
@@ -748,9 +761,9 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', {
                 command: 'test-command',
-            }, mockedToolRegistry, mockedPromptRegistry, resourceRegistry, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            }, mockedToolRegistry, mockedPromptRegistry, resourceRegistry, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
-            await client.discover({});
+            await client.discover(MOCK_CONTEXT);
             expect(mockedToolRegistry.registerTool).toHaveBeenCalledOnce();
             expect(mockedPromptRegistry.registerPrompt).toHaveBeenCalledOnce();
             await client.disconnect();
@@ -778,7 +791,7 @@ describe('mcp-client', () => {
             };
             vi.mocked(ClientLib.Client).mockReturnValue(mockedClient);
             vi.spyOn(SdkClientStdioLib, 'StdioClientTransport').mockReturnValue({});
-            const client = new McpClient('test-server', { command: 'test-command' }, {}, {}, {}, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            const client = new McpClient('test-server', { command: 'test-command' }, {}, {}, {}, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
             expect(mockedClient.setNotificationHandler).toHaveBeenCalledWith(ToolListChangedNotificationSchema, expect.any(Function));
         });
@@ -793,7 +806,7 @@ describe('mcp-client', () => {
             };
             vi.mocked(ClientLib.Client).mockReturnValue(mockedClient);
             vi.spyOn(SdkClientStdioLib, 'StdioClientTransport').mockReturnValue({});
-            const client = new McpClient('test-server', { command: 'test-command' }, {}, {}, {}, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            const client = new McpClient('test-server', { command: 'test-command' }, {}, {}, {}, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
             expect(mockedClient.setNotificationHandler).toHaveBeenCalledOnce();
         });
@@ -828,7 +841,7 @@ describe('mcp-client', () => {
             };
             const onToolsUpdatedSpy = vi.fn().mockResolvedValue(undefined);
             // Initialize client with onToolsUpdated callback
-            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, {}, {}, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1', onToolsUpdatedSpy);
+            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, {}, {}, workspaceContext, MOCK_CONTEXT, false, '0.0.1', onToolsUpdatedSpy);
             // 1. Connect (sets up listener)
             await client.connect();
             // 2. Extract the callback passed to setNotificationHandler
@@ -845,7 +858,7 @@ describe('mcp-client', () => {
             // It should notify the manager
             expect(onToolsUpdatedSpy).toHaveBeenCalled();
             // It should emit feedback event
-            expect(coreEvents.emitFeedback).toHaveBeenCalledWith('info', 'Tools updated for server: test-server');
+            expect(MOCK_CONTEXT.emitMcpDiagnostic).toHaveBeenCalledWith('info', 'Tools updated for server: test-server', undefined, 'test-server');
         });
         it('should handle errors during tool refresh gracefully', async () => {
             const mockedClient = {
@@ -866,7 +879,7 @@ describe('mcp-client', () => {
                 removeMcpToolsByServer: vi.fn(),
                 getMessageBus: vi.fn().mockReturnValue(undefined),
             };
-            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, {}, {}, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, {}, {}, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
             const notificationCallback = mockedClient.setNotificationHandler.mock.calls[0][1];
             // Trigger notification - should fail internally but catch the error
@@ -909,8 +922,8 @@ describe('mcp-client', () => {
                 getMessageBus: vi.fn().mockReturnValue(undefined),
             };
             const onToolsUpdatedSpy = vi.fn().mockResolvedValue(undefined);
-            const clientA = new McpClient('server-A', { command: 'cmd-a' }, mockedToolRegistry, {}, {}, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1', onToolsUpdatedSpy);
-            const clientB = new McpClient('server-B', { command: 'cmd-b' }, mockedToolRegistry, {}, {}, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1', onToolsUpdatedSpy);
+            const clientA = new McpClient('server-A', { command: 'cmd-a' }, mockedToolRegistry, {}, {}, workspaceContext, MOCK_CONTEXT, false, '0.0.1', onToolsUpdatedSpy);
+            const clientB = new McpClient('server-B', { command: 'cmd-b' }, mockedToolRegistry, {}, {}, workspaceContext, MOCK_CONTEXT, false, '0.0.1', onToolsUpdatedSpy);
             await clientA.connect();
             await clientB.connect();
             const handlerA = mockClientA.setNotificationHandler.mock.calls[0][1];
@@ -959,7 +972,7 @@ describe('mcp-client', () => {
             };
             const client = new McpClient('test-server', 
             // Set a short timeout
-            { command: 'test-command', timeout: 100 }, mockedToolRegistry, {}, {}, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1');
+            { command: 'test-command', timeout: 100 }, mockedToolRegistry, {}, {}, workspaceContext, MOCK_CONTEXT, false, '0.0.1');
             await client.connect();
             const notificationCallback = mockedClient.setNotificationHandler.mock.calls[0][1];
             const refreshPromise = notificationCallback();
@@ -993,7 +1006,7 @@ describe('mcp-client', () => {
                 getMessageBus: vi.fn().mockReturnValue(undefined),
             };
             const onToolsUpdatedSpy = vi.fn().mockResolvedValue(undefined);
-            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, {}, {}, workspaceContext, { sanitizationConfig: EMPTY_CONFIG }, false, '0.0.1', onToolsUpdatedSpy);
+            const client = new McpClient('test-server', { command: 'test-command' }, mockedToolRegistry, {}, {}, workspaceContext, MOCK_CONTEXT, false, '0.0.1', onToolsUpdatedSpy);
             await client.connect();
             const notificationCallback = mockedClient.setNotificationHandler.mock.calls[0][1];
             await notificationCallback();
@@ -1027,7 +1040,7 @@ describe('mcp-client', () => {
             it('without headers', async () => {
                 const transport = await createTransport('test-server', {
                     httpUrl: 'http://test-server',
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1038,7 +1051,7 @@ describe('mcp-client', () => {
                 const transport = await createTransport('test-server', {
                     httpUrl: 'http://test-server',
                     headers: { Authorization: 'derp' },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1052,7 +1065,7 @@ describe('mcp-client', () => {
             it('without headers', async () => {
                 const transport = await createTransport('test-server', {
                     url: 'http://test-server',
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1063,7 +1076,7 @@ describe('mcp-client', () => {
                 const transport = await createTransport('test-server', {
                     url: 'http://test-server',
                     headers: { Authorization: 'derp' },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1076,7 +1089,7 @@ describe('mcp-client', () => {
                 const transport = await createTransport('test-server', {
                     url: 'http://test-server',
                     type: 'http',
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1087,7 +1100,7 @@ describe('mcp-client', () => {
                 const transport = await createTransport('test-server', {
                     url: 'http://test-server',
                     type: 'sse',
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(SSEClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1097,7 +1110,7 @@ describe('mcp-client', () => {
             it('without type defaults to StreamableHTTPClientTransport', async () => {
                 const transport = await createTransport('test-server', {
                     url: 'http://test-server',
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1109,7 +1122,7 @@ describe('mcp-client', () => {
                     url: 'http://test-server',
                     type: 'http',
                     headers: { Authorization: 'Bearer token' },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1123,7 +1136,7 @@ describe('mcp-client', () => {
                     url: 'http://test-server',
                     type: 'sse',
                     headers: { 'X-API-Key': 'key123' },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(SSEClientTransport);
                 expect(transport).toMatchObject({
                     _url: new URL('http://test-server'),
@@ -1136,7 +1149,7 @@ describe('mcp-client', () => {
                 const transport = await createTransport('test-server', {
                     httpUrl: 'http://test-server-http',
                     url: 'http://test-server-url',
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 // httpUrl should take priority and create HTTP transport
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(transport).toMatchObject({
@@ -1154,7 +1167,7 @@ describe('mcp-client', () => {
                 args: ['--foo', 'bar'],
                 env: { FOO: 'bar' },
                 cwd: 'test/cwd',
-            }, false, EMPTY_CONFIG);
+            }, false, MOCK_CONTEXT);
             expect(mockedTransport).toHaveBeenCalledWith({
                 command: 'test-command',
                 args: ['--foo', 'bar'],
@@ -1172,7 +1185,7 @@ describe('mcp-client', () => {
                 args: ['--foo', 'bar'],
                 env: {},
                 cwd: 'test/cwd',
-            }, false, EMPTY_CONFIG);
+            }, false, MOCK_CONTEXT);
             const callArgs = mockedTransport.mock.calls[0][0];
             expect(callArgs.env).toBeDefined();
             expect(callArgs.env['GEMINI_CLI']).toBe('1');
@@ -1199,7 +1212,7 @@ describe('mcp-client', () => {
                     contextFiles: [],
                     id: '',
                 },
-            }, false, EMPTY_CONFIG);
+            }, false, MOCK_CONTEXT);
             const callArgs = mockedTransport.mock.calls[0][0];
             expect(callArgs.env).toBeDefined();
             expect(callArgs.env['GEMINI_CLI_EXT_VAR']).toBeUndefined();
@@ -1226,7 +1239,7 @@ describe('mcp-client', () => {
                     contextFiles: [],
                     id: '',
                 },
-            }, false, EMPTY_CONFIG);
+            }, false, MOCK_CONTEXT);
             const callArgs = mockedTransport.mock.calls[0][0];
             expect(callArgs.env).toBeDefined();
             expect(callArgs.env['GEMINI_CLI_EXT_VAR']).toBe('defined-value');
@@ -1256,7 +1269,7 @@ describe('mcp-client', () => {
                     contextFiles: [],
                     id: '',
                 },
-            }, false, EMPTY_CONFIG);
+            }, false, MOCK_CONTEXT);
             const callArgs = mockedTransport.mock.calls[0][0];
             expect(callArgs.env).toBeDefined();
             expect(callArgs.env['GEMINI_CLI_EXT_VAR']).toBe('ext-value');
@@ -1278,7 +1291,7 @@ describe('mcp-client', () => {
                         TEST_EXPANDED: 'Value is $GEMINI_TEST_VAR',
                         SECRET_KEY: 'intentional-secret-123',
                     },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 const callArgs = mockedTransport.mock.calls[0][0];
                 expect(callArgs.env).toBeDefined();
                 expect(callArgs.env['TEST_EXPANDED']).toBe('Value is expanded-value');
@@ -1307,13 +1320,12 @@ describe('mcp-client', () => {
                     headers: {
                         'X-Goog-User-Project': 'myproject',
                     },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const authProvider = transport._authProvider;
+                const testableTransport = transport;
+                const authProvider = testableTransport._authProvider;
                 expect(authProvider).toBeInstanceOf(GoogleCredentialProvider);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const googUserProject = transport._requestInit?.headers?.['X-Goog-User-Project'];
+                const googUserProject = testableTransport._requestInit?.headers?.['X-Goog-User-Project'];
                 expect(googUserProject).toBe('myproject');
             });
             it('should use headers from GoogleCredentialProvider', async () => {
@@ -1327,12 +1339,12 @@ describe('mcp-client', () => {
                     oauth: {
                         scopes: ['scope1'],
                     },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
                 expect(mockGetRequestHeaders).toHaveBeenCalled();
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const headers = transport._requestInit?.headers;
-                expect(headers['X-Goog-User-Project']).toBe('provider-project');
+                const testableTransport = transport;
+                const headers = testableTransport._requestInit?.headers;
+                expect(headers?.['X-Goog-User-Project']).toBe('provider-project');
             });
             it('should prioritize provider headers over config headers', async () => {
                 const mockGetRequestHeaders = vi.fn().mockResolvedValue({
@@ -1348,11 +1360,11 @@ describe('mcp-client', () => {
                     headers: {
                         'X-Goog-User-Project': 'config-project',
                     },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const headers = transport._requestInit?.headers;
-                expect(headers['X-Goog-User-Project']).toBe('provider-project');
+                const testableTransport = transport;
+                const headers = testableTransport._requestInit?.headers;
+                expect(headers?.['X-Goog-User-Project']).toBe('provider-project');
             });
             it('should use GoogleCredentialProvider with SSE transport', async () => {
                 const transport = await createTransport('test-server', {
@@ -1362,10 +1374,10 @@ describe('mcp-client', () => {
                     oauth: {
                         scopes: ['scope1'],
                     },
-                }, false, EMPTY_CONFIG);
+                }, false, MOCK_CONTEXT);
                 expect(transport).toBeInstanceOf(SSEClientTransport);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const authProvider = transport._authProvider;
+                const testableTransport = transport;
+                const authProvider = testableTransport._authProvider;
                 expect(authProvider).toBeInstanceOf(GoogleCredentialProvider);
             });
             it('should throw an error if no URL is provided with GoogleCredentialProvider', async () => {
@@ -1374,7 +1386,7 @@ describe('mcp-client', () => {
                     oauth: {
                         scopes: ['scope1'],
                     },
-                }, false, EMPTY_CONFIG)).rejects.toThrow('URL must be provided in the config for Google Credentials provider');
+                }, false, MOCK_CONTEXT)).rejects.toThrow('URL must be provided in the config for Google Credentials provider');
             });
         });
     });
@@ -1486,18 +1498,18 @@ describe('connectToMcpServer with OAuth', () => {
             tokenUrl,
             scopes: ['test-scope'],
         });
-        // We need this to be an any type because we dig into its private state.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // We need this to be typed to dig into its private state.
         let capturedTransport;
         vi.mocked(mockedClient.connect).mockImplementationOnce(async (transport) => {
             capturedTransport = transport;
             return Promise.resolve();
         });
-        const client = await connectToMcpServer('0.0.1', 'test-server', { httpUrl: serverUrl, oauth: { enabled: true } }, false, workspaceContext, EMPTY_CONFIG);
+        const client = await connectToMcpServer('0.0.1', 'test-server', { httpUrl: serverUrl, oauth: { enabled: true } }, false, workspaceContext, MOCK_CONTEXT);
         expect(client).toBe(mockedClient);
         expect(mockedClient.connect).toHaveBeenCalledTimes(2);
         expect(mockAuthProvider.authenticate).toHaveBeenCalledOnce();
-        const authHeader = capturedTransport._requestInit?.headers?.['Authorization'];
+        const authHeader = capturedTransport._requestInit
+            ?.headers?.['Authorization'];
         expect(authHeader).toBe('Bearer test-access-token');
     });
     it('should discover oauth config if not in www-authenticate header', async () => {
@@ -1511,19 +1523,19 @@ describe('connectToMcpServer with OAuth', () => {
             scopes: ['test-scope'],
         });
         vi.mocked(mockAuthProvider.getValidToken).mockResolvedValue('test-access-token-from-discovery');
-        // We need this to be an any type because we dig into its private state.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // We need this to be typed to dig into its private state.
         let capturedTransport;
         vi.mocked(mockedClient.connect).mockImplementationOnce(async (transport) => {
             capturedTransport = transport;
             return Promise.resolve();
         });
-        const client = await connectToMcpServer('0.0.1', 'test-server', { httpUrl: serverUrl, oauth: { enabled: true } }, false, workspaceContext, EMPTY_CONFIG);
+        const client = await connectToMcpServer('0.0.1', 'test-server', { httpUrl: serverUrl, oauth: { enabled: true } }, false, workspaceContext, MOCK_CONTEXT);
         expect(client).toBe(mockedClient);
         expect(mockedClient.connect).toHaveBeenCalledTimes(2);
         expect(mockAuthProvider.authenticate).toHaveBeenCalledOnce();
         expect(OAuthUtils.discoverOAuthConfig).toHaveBeenCalledWith(serverUrl);
-        const authHeader = capturedTransport._requestInit?.headers?.['Authorization'];
+        const authHeader = capturedTransport._requestInit
+            ?.headers?.['Authorization'];
         expect(authHeader).toBe('Bearer test-access-token-from-discovery');
     });
     it('should use discoverOAuthFromWWWAuthenticate when it succeeds and skip discoverOAuthConfig', async () => {
@@ -1538,7 +1550,7 @@ describe('connectToMcpServer with OAuth', () => {
             scopes: ['read'],
         });
         vi.mocked(mockedClient.connect).mockResolvedValueOnce(undefined);
-        const client = await connectToMcpServer('0.0.1', 'test-server', { httpUrl: serverUrl, oauth: { enabled: true } }, false, workspaceContext, EMPTY_CONFIG);
+        const client = await connectToMcpServer('0.0.1', 'test-server', { httpUrl: serverUrl, oauth: { enabled: true } }, false, workspaceContext, MOCK_CONTEXT);
         expect(client).toBe(mockedClient);
         expect(OAuthUtils.discoverOAuthFromWWWAuthenticate).toHaveBeenCalledWith(wwwAuthHeader, serverUrl);
         expect(OAuthUtils.discoverOAuthConfig).not.toHaveBeenCalled();
@@ -1559,7 +1571,7 @@ describe('connectToMcpServer with OAuth', () => {
             scopes: ['read'],
         });
         vi.mocked(mockedClient.connect).mockResolvedValueOnce(undefined);
-        const client = await connectToMcpServer('0.0.1', 'test-server', { httpUrl: serverUrl, oauth: { enabled: true } }, false, workspaceContext, EMPTY_CONFIG);
+        const client = await connectToMcpServer('0.0.1', 'test-server', { httpUrl: serverUrl, oauth: { enabled: true } }, false, workspaceContext, MOCK_CONTEXT);
         expect(client).toBe(mockedClient);
         expect(OAuthUtils.discoverOAuthFromWWWAuthenticate).toHaveBeenCalledWith(wwwAuthHeader, serverUrl);
         expect(OAuthUtils.extractBaseUrl).toHaveBeenCalledWith(serverUrl);
@@ -1592,13 +1604,13 @@ describe('connectToMcpServer - HTTP→SSE fallback', () => {
     });
     it('should NOT trigger fallback when type="http" is explicit', async () => {
         vi.mocked(mockedClient.connect).mockRejectedValueOnce(new Error('Connection failed'));
-        await expect(connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server', type: 'http' }, false, workspaceContext, EMPTY_CONFIG)).rejects.toThrow('Connection failed');
+        await expect(connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server', type: 'http' }, false, workspaceContext, MOCK_CONTEXT)).rejects.toThrow('Connection failed');
         // Should only try once (no fallback)
         expect(mockedClient.connect).toHaveBeenCalledTimes(1);
     });
     it('should NOT trigger fallback when type="sse" is explicit', async () => {
         vi.mocked(mockedClient.connect).mockRejectedValueOnce(new Error('Connection failed'));
-        await expect(connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server', type: 'sse' }, false, workspaceContext, EMPTY_CONFIG)).rejects.toThrow('Connection failed');
+        await expect(connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server', type: 'sse' }, false, workspaceContext, MOCK_CONTEXT)).rejects.toThrow('Connection failed');
         // Should only try once (no fallback)
         expect(mockedClient.connect).toHaveBeenCalledTimes(1);
     });
@@ -1606,7 +1618,7 @@ describe('connectToMcpServer - HTTP→SSE fallback', () => {
         vi.mocked(mockedClient.connect)
             .mockRejectedValueOnce(new StreamableHTTPError(500, 'Server error'))
             .mockResolvedValueOnce(undefined);
-        const client = await connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server' }, false, workspaceContext, EMPTY_CONFIG);
+        const client = await connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server' }, false, workspaceContext, MOCK_CONTEXT);
         expect(client).toBe(mockedClient);
         // First HTTP attempt fails, second SSE attempt succeeds
         expect(mockedClient.connect).toHaveBeenCalledTimes(2);
@@ -1617,14 +1629,14 @@ describe('connectToMcpServer - HTTP→SSE fallback', () => {
         vi.mocked(mockedClient.connect)
             .mockRejectedValueOnce(httpError)
             .mockRejectedValueOnce(sseError);
-        await expect(connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server' }, false, workspaceContext, EMPTY_CONFIG)).rejects.toThrow('Server error');
+        await expect(connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server' }, false, workspaceContext, MOCK_CONTEXT)).rejects.toThrow('Server error');
         expect(mockedClient.connect).toHaveBeenCalledTimes(2);
     });
     it('should handle HTTP 404 followed by SSE success', async () => {
         vi.mocked(mockedClient.connect)
             .mockRejectedValueOnce(new StreamableHTTPError(404, 'Not Found'))
             .mockResolvedValueOnce(undefined);
-        const client = await connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server' }, false, workspaceContext, EMPTY_CONFIG);
+        const client = await connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server' }, false, workspaceContext, MOCK_CONTEXT);
         expect(client).toBe(mockedClient);
         expect(mockedClient.connect).toHaveBeenCalledTimes(2);
     });
@@ -1685,7 +1697,7 @@ describe('connectToMcpServer - OAuth with transport fallback', () => {
             .mockRejectedValueOnce(new StreamableHTTPError(404, 'Not Found'))
             .mockRejectedValueOnce(new StreamableHTTPError(401, 'Unauthorized'))
             .mockResolvedValueOnce(undefined);
-        const client = await connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server', oauth: { enabled: true } }, false, workspaceContext, EMPTY_CONFIG);
+        const client = await connectToMcpServer('0.0.1', 'test-server', { url: 'http://test-server', oauth: { enabled: true } }, false, workspaceContext, MOCK_CONTEXT);
         expect(client).toBe(mockedClient);
         expect(mockedClient.connect).toHaveBeenCalledTimes(3);
         expect(mockAuthProvider.authenticate).toHaveBeenCalledOnce();