@strands-agents/sdk 1.0.0 → 1.2.0

package/dist/src/__tests__/mcp.test.js

@@ -1,11 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { McpError, ErrorCode, ElicitRequestSchema, UrlElicitationRequiredError, } from '@modelcontextprotocol/sdk/types.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { ClientCredentialsProvider } from '@modelcontextprotocol/sdk/client/auth-extensions.js';
 import { McpClient } from '../mcp.js';
 import { McpTool } from '../tools/mcp-tool.js';
 import { JsonBlock } from '../types/messages.js';
 import { ImageBlock } from '../types/media.js';
 import { context, propagation, trace, TraceFlags } from '@opentelemetry/api';
+import { logger } from '../logging/index.js';
 /**
  * Helper to create a mock async generator that yields a result message.
  * This simulates the behavior of callToolStream returning a stream that ends with a result.
@@ -15,6 +18,16 @@ function createMockCallToolStream(result) {
         yield { type: 'result', result };
     };
 }
+vi.mock('@modelcontextprotocol/sdk/client/streamableHttp.js', () => ({
+    StreamableHTTPClientTransport: vi.fn(function () {
+        return { start: vi.fn(), send: vi.fn(), close: vi.fn() };
+    }),
+}));
+vi.mock('@modelcontextprotocol/sdk/client/auth-extensions.js', () => ({
+    ClientCredentialsProvider: vi.fn(function () {
+        return { redirectUrl: undefined, clientMetadata: { client_id: 'test' } };
+    }),
+}));
 vi.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
     Client: vi.fn(function () {
         return {
@@ -23,6 +36,10 @@ vi.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
             listTools: vi.fn(),
             callTool: vi.fn(),
             setRequestHandler: vi.fn(),
+            setNotificationHandler: vi.fn(),
+            getServerCapabilities: vi.fn(),
+            getServerVersion: vi.fn(),
+            getInstructions: vi.fn(),
             experimental: {
                 tasks: {
                     callToolStream: vi.fn(),
@@ -110,7 +127,11 @@ describe('MCP Integration', () => {
             sdkClientMock = vi.mocked(Client).mock.results[0].value;
         });
         it('initializes SDK client with correct configuration', () => {
-            expect(Client).toHaveBeenCalledWith({ name: 'TestApp', version: '0.0.1' }, undefined);
+            expect(Client).toHaveBeenCalledWith({ name: 'TestApp', version: '0.0.1' }, expect.objectContaining({
+                listChanged: expect.objectContaining({
+                    tools: expect.objectContaining({ autoRefresh: false, debounceMs: 300 }),
+                }),
+            }));
         });
         it('injects trace context into tool arguments when active span exists', async () => {
             mockActiveSpan();
@@ -198,17 +219,72 @@ describe('MCP Integration', () => {
             expect(tools[0]).toBeInstanceOf(McpTool);
             expect(tools[0].name).toBe('weather');
         });
+        it('paginates through all pages of tools', async () => {
+            sdkClientMock.listTools
+                .mockResolvedValueOnce({
+                tools: [{ name: 'tool_a', description: 'A', inputSchema: {} }],
+                nextCursor: 'page2',
+            })
+                .mockResolvedValueOnce({
+                tools: [{ name: 'tool_b', description: 'B', inputSchema: {} }],
+                nextCursor: 'page3',
+            })
+                .mockResolvedValueOnce({
+                tools: [{ name: 'tool_c', description: 'C', inputSchema: {} }],
+            });
+            const tools = await client.listTools();
+            expect(tools).toHaveLength(3);
+            expect(tools.map((t) => t.name)).toEqual(['tool_a', 'tool_b', 'tool_c']);
+            expect(sdkClientMock.listTools).toHaveBeenCalledTimes(3);
+            expect(sdkClientMock.listTools).toHaveBeenNthCalledWith(1, undefined);
+            expect(sdkClientMock.listTools).toHaveBeenNthCalledWith(2, { cursor: 'page2' });
+            expect(sdkClientMock.listTools).toHaveBeenNthCalledWith(3, { cursor: 'page3' });
+        });
+        it('generates description fallback when description is missing', async () => {
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [{ name: 'my_tool', inputSchema: {} }],
+            });
+            const tools = await client.listTools();
+            expect(tools[0].description).toBe('Tool which performs my_tool');
+        });
+        it('generates description fallback when description is empty string', async () => {
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [{ name: 'my_tool', description: '', inputSchema: {} }],
+            });
+            const tools = await client.listTools();
+            expect(tools[0].description).toBe('Tool which performs my_tool');
+        });
         it('uses callTool when tasksConfig is undefined (default)', async () => {
             const tool = new McpTool({ name: 'calc', description: '', inputSchema: {}, client });
             sdkClientMock.callTool.mockResolvedValue({ content: [] });
             await client.callTool(tool, { op: 'add' });
             expect(sdkClientMock.connect).toHaveBeenCalled();
-            expect(sdkClientMock.callTool).toHaveBeenCalledWith({
-                name: 'calc',
-                arguments: { op: 'add' },
-            });
+            expect(sdkClientMock.callTool).toHaveBeenCalledWith({ name: 'calc', arguments: { op: 'add' } }, undefined, undefined);
             expect(sdkClientMock.experimental.tasks.callToolStream).not.toHaveBeenCalled();
         });
+        it('forwards abort signal to SDK callTool', async () => {
+            const tool = new McpTool({ name: 'calc', description: '', inputSchema: {}, client });
+            sdkClientMock.callTool.mockResolvedValue({ content: [] });
+            const controller = new AbortController();
+            await client.callTool(tool, { op: 'add' }, { signal: controller.signal });
+            expect(sdkClientMock.callTool).toHaveBeenCalledWith({ name: 'calc', arguments: { op: 'add' } }, undefined, {
+                signal: controller.signal,
+            });
+        });
+        it('forwards abort signal to callToolStream when tasksConfig is provided', async () => {
+            const resultsLengthBefore = vi.mocked(Client).mock.results.length;
+            const taskClient = new McpClient({
+                applicationName: 'TestApp',
+                transport: mockTransport,
+                tasksConfig: {},
+            });
+            const taskSdkClientMock = vi.mocked(Client).mock.results[resultsLengthBefore].value;
+            const tool = new McpTool({ name: 'calc', description: '', inputSchema: {}, client: taskClient });
+            taskSdkClientMock.experimental.tasks.callToolStream.mockReturnValue(createMockCallToolStream({ content: [] })());
+            const controller = new AbortController();
+            await taskClient.callTool(tool, { op: 'add' }, { signal: controller.signal });
+            expect(taskSdkClientMock.experimental.tasks.callToolStream).toHaveBeenCalledWith({ name: 'calc', arguments: { op: 'add' } }, undefined, { timeout: 60000, maxTotalTimeout: 300000, resetTimeoutOnProgress: true, signal: controller.signal });
+        });
         it('uses callToolStream when tasksConfig is provided (empty object)', async () => {
             const resultsLengthBefore = vi.mocked(Client).mock.results.length;
             const taskClient = new McpClient({
@@ -246,6 +322,11 @@ describe('MCP Integration', () => {
             expect(sdkClientMock.close).toHaveBeenCalled();
             expect(mockTransport.close).toHaveBeenCalled();
         });
+        it('supports Symbol.asyncDispose for await using pattern', async () => {
+            await client[Symbol.asyncDispose]();
+            expect(sdkClientMock.close).toHaveBeenCalled();
+            expect(mockTransport.close).toHaveBeenCalled();
+        });
         it('registers elicitation handler before connecting when callback is provided', async () => {
             const resultsLengthBefore = vi.mocked(Client).mock.results.length;
             const callback = vi.fn();
@@ -273,7 +354,7 @@ describe('MCP Integration', () => {
                 elicitationCallback: callback,
             });
             const lastCall = vi.mocked(Client).mock.calls.at(-1);
-            expect(lastCall[1]).toEqual({ capabilities: { elicitation: { form: {}, url: {} } } });
+            expect(lastCall[1]).toEqual(expect.objectContaining({ capabilities: { elicitation: { form: {}, url: {} } } }));
         });
         it('elicitation handler returns accepted result with content', async () => {
             const callbackResult = { action: 'accept', content: { username: 'alice' } };
@@ -329,6 +410,98 @@ describe('MCP Integration', () => {
             await expect(handler(request, extra)).rejects.toThrow('User cancelled');
         });
     });
+    describe('tools list changed', () => {
+        let client;
+        let sdkClientMock;
+        beforeEach(() => {
+            client = new McpClient({ applicationName: 'TestApp', transport: mockTransport });
+            sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+            sdkClientMock.connect.mockResolvedValue(undefined);
+        });
+        function triggerToolsChanged() {
+            const ctorCall = vi.mocked(Client).mock.calls.at(-1);
+            ctorCall[1].listChanged.tools.onChanged(null, null);
+        }
+        it('calls onToolsChanged with old names and new tools when list changes', async () => {
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [{ name: 'tool_a', description: 'A', inputSchema: {} }],
+            });
+            await client.listTools();
+            const onToolsChanged = vi.fn();
+            client.onToolsChanged = onToolsChanged;
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [
+                    { name: 'tool_a', description: 'A', inputSchema: {} },
+                    { name: 'tool_b', description: 'B', inputSchema: {} },
+                ],
+            });
+            triggerToolsChanged();
+            await vi.waitFor(() => expect(onToolsChanged).toHaveBeenCalled());
+            expect(onToolsChanged).toHaveBeenCalledWith(['tool_a'], expect.any(Array));
+            const newTools = onToolsChanged.mock.calls[0][1];
+            expect(newTools.map((t) => t.name)).toEqual(['tool_a', 'tool_b']);
+        });
+        it('updates registered tool names after each listTools call', async () => {
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [
+                    { name: 'x', description: 'X', inputSchema: {} },
+                    { name: 'y', description: 'Y', inputSchema: {} },
+                ],
+            });
+            await client.listTools();
+            const onToolsChanged = vi.fn();
+            client.onToolsChanged = onToolsChanged;
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [{ name: 'z', description: 'Z', inputSchema: {} }],
+            });
+            triggerToolsChanged();
+            await vi.waitFor(() => expect(onToolsChanged).toHaveBeenCalled());
+            expect(onToolsChanged).toHaveBeenCalledWith(['x', 'y'], expect.any(Array));
+            const newTools = onToolsChanged.mock.calls[0][1];
+            expect(newTools.map((t) => t.name)).toEqual(['z']);
+        });
+        it('does not throw when onToolsChanged is not set', async () => {
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [{ name: 'tool_a', description: 'A', inputSchema: {} }],
+            });
+            await client.listTools();
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [{ name: 'tool_b', description: 'B', inputSchema: {} }],
+            });
+            triggerToolsChanged();
+            await new Promise((r) => setTimeout(r, 0));
+        });
+        it('logs warning and preserves registry when listTools fails during refresh', async () => {
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [{ name: 'tool_a', description: 'A', inputSchema: {} }],
+            });
+            await client.listTools();
+            const onToolsChanged = vi.fn();
+            client.onToolsChanged = onToolsChanged;
+            sdkClientMock.listTools.mockRejectedValue(new Error('server disconnected'));
+            const warnSpy = vi.spyOn(logger, 'warn');
+            triggerToolsChanged();
+            await vi.waitFor(() => expect(warnSpy).toHaveBeenCalled());
+            expect(onToolsChanged).not.toHaveBeenCalled();
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('failed to refresh tools'));
+        });
+        it('coalesces notifications received during an in-flight refresh into one extra refresh', async () => {
+            sdkClientMock.listTools.mockResolvedValue({
+                tools: [{ name: 'tool_a', description: 'A', inputSchema: {} }],
+            });
+            await client.listTools();
+            const onToolsChanged = vi.fn();
+            client.onToolsChanged = onToolsChanged;
+            let resolveListTools;
+            sdkClientMock.listTools.mockReturnValue(new Promise((r) => (resolveListTools = r)));
+            triggerToolsChanged();
+            triggerToolsChanged();
+            triggerToolsChanged();
+            resolveListTools({ tools: [{ name: 'tool_b', description: 'B', inputSchema: {} }] });
+            await vi.waitFor(() => expect(onToolsChanged).toHaveBeenCalledTimes(2));
+            expect(sdkClientMock.listTools).toHaveBeenCalledTimes(3);
+        });
+    });
     describe('McpTool', () => {
         const mockClientWrapper = { callTool: vi.fn() };
         const tool = new McpTool({
@@ -339,9 +512,21 @@ describe('MCP Integration', () => {
         });
         const toolContext = {
             toolUse: { toolUseId: 'id-123', name: 'weather', input: { city: 'NYC' } },
-            agent: {},
+            agent: { cancelSignal: new AbortController().signal },
             invocationState: {},
+            interrupt: () => {
+                throw new Error('interrupt not available in mock context');
+            },
         };
+        it('forwards agent cancelSignal to callTool', async () => {
+            vi.mocked(mockClientWrapper.callTool).mockResolvedValue({
+                content: [{ type: 'text', text: 'ok' }],
+            });
+            await runTool(tool.stream(toolContext));
+            expect(mockClientWrapper.callTool).toHaveBeenCalledWith(tool, { city: 'NYC' }, {
+                signal: toolContext.agent.cancelSignal,
+            });
+        });
         it('returns text results on success', async () => {
             vi.mocked(mockClientWrapper.callTool).mockResolvedValue({
                 content: [{ type: 'text', text: 'Sunny' }],
@@ -560,4 +745,259 @@ describe('MCP Integration', () => {
         });
     });
 });
+describe('server metadata getters', () => {
+    let client;
+    let sdkClientMock;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        client = new McpClient({ applicationName: 'TestApp', transport: mockTransport });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('returns undefined for all getters before connect', () => {
+        sdkClientMock.getServerCapabilities.mockReturnValue(undefined);
+        sdkClientMock.getServerVersion.mockReturnValue(undefined);
+        sdkClientMock.getInstructions.mockReturnValue(undefined);
+        expect(client.serverCapabilities).toBeUndefined();
+        expect(client.serverVersion).toBeUndefined();
+        expect(client.serverInstructions).toBeUndefined();
+    });
+    it('returns serverCapabilities after connect', async () => {
+        const caps = { tools: {} };
+        sdkClientMock.getServerCapabilities.mockReturnValue(caps);
+        await client.connect();
+        expect(client.serverCapabilities).toBe(caps);
+    });
+    it('returns serverVersion after connect', async () => {
+        const version = { name: 'my-server', version: '1.2.3' };
+        sdkClientMock.getServerVersion.mockReturnValue(version);
+        await client.connect();
+        expect(client.serverVersion).toBe(version);
+    });
+    it('returns serverInstructions after connect', async () => {
+        sdkClientMock.getInstructions.mockReturnValue('Use this server for X.');
+        await client.connect();
+        expect(client.serverInstructions).toBe('Use this server for X.');
+    });
+    it('connectionState is disconnected before connect', () => {
+        expect(client.connectionState).toBe('disconnected');
+    });
+    it('connectionState is connected after successful connect', async () => {
+        await client.connect();
+        expect(client.connectionState).toBe('connected');
+    });
+});
+describe('failOpen', () => {
+    let sdkClientMock;
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('throws on connection failure by default', async () => {
+        const client = new McpClient({ applicationName: 'TestApp', transport: mockTransport });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+        sdkClientMock.connect.mockRejectedValue(new Error('connection refused'));
+        await expect(client.connect()).rejects.toThrow('connection refused');
+    });
+    it('swallows connection failure when failOpen is true', async () => {
+        const client = new McpClient({ applicationName: 'TestApp', transport: mockTransport, failOpen: true });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+        sdkClientMock.connect.mockRejectedValue(new Error('connection refused'));
+        await expect(client.connect()).resolves.toBeUndefined();
+    });
+    it('logs a warning when failOpen swallows a connection failure', async () => {
+        const warnSpy = vi.spyOn(logger, 'warn').mockImplementation(() => { });
+        const client = new McpClient({ applicationName: 'TestApp', transport: mockTransport, failOpen: true });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+        sdkClientMock.connect.mockRejectedValue(new Error('connection refused'));
+        await client.connect();
+        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('MCP server failed to connect'));
+    });
+    it('listTools returns empty array when failOpen and connection failed', async () => {
+        const client = new McpClient({ applicationName: 'TestApp', transport: mockTransport, failOpen: true });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+        sdkClientMock.connect.mockRejectedValue(new Error('connection refused'));
+        const tools = await client.listTools();
+        expect(tools).toEqual([]);
+    });
+    it('callTool throws when failOpen and connection failed', async () => {
+        const client = new McpClient({ applicationName: 'TestApp', transport: mockTransport, failOpen: true });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+        sdkClientMock.connect.mockRejectedValue(new Error('connection refused'));
+        const tool = new McpTool({ name: 'my_tool', description: '', inputSchema: {}, client });
+        await expect(client.callTool(tool, {})).rejects.toThrow('MCP server failed to connect. Call connect(true) to retry.');
+    });
+    it('does not retry connection on subsequent calls after failOpen failure', async () => {
+        const client = new McpClient({ applicationName: 'TestApp', transport: mockTransport, failOpen: true });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+        sdkClientMock.connect.mockRejectedValue(new Error('connection refused'));
+        await client.listTools();
+        await client.listTools();
+        expect(sdkClientMock.connect).toHaveBeenCalledTimes(1);
+    });
+    it('recovers after explicit connect(true) when server comes back', async () => {
+        const client = new McpClient({ applicationName: 'TestApp', transport: mockTransport, failOpen: true });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+        sdkClientMock.connect.mockRejectedValueOnce(new Error('connection refused'));
+        sdkClientMock.listTools.mockResolvedValue({ tools: [] });
+        const firstTools = await client.listTools();
+        expect(firstTools).toEqual([]);
+        expect(client.connectionState).toBe('failed');
+        await client.connect(true);
+        const secondTools = await client.listTools();
+        expect(secondTools).toEqual([]);
+        expect(client.connectionState).toBe('connected');
+        expect(sdkClientMock.connect).toHaveBeenCalledTimes(2);
+    });
+});
+describe('log routing', () => {
+    let notificationHandler;
+    let sdkClientMock;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        new McpClient({ applicationName: 'TestApp', transport: mockTransport });
+        sdkClientMock = vi.mocked(Client).mock.results.at(-1).value;
+        // Handler is registered in the constructor — read it from the first setNotificationHandler call
+        notificationHandler = sdkClientMock.setNotificationHandler.mock.calls[0][1];
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('routes debug level to logger.debug', () => {
+        const spy = vi.spyOn(logger, 'debug').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'debug', data: 'hello' } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('hello'));
+    });
+    it('routes info level to logger.info', () => {
+        const spy = vi.spyOn(logger, 'info').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'info', data: 'hello' } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('hello'));
+    });
+    it('routes notice level to logger.info', () => {
+        const spy = vi.spyOn(logger, 'info').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'notice', data: 'hello' } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('hello'));
+    });
+    it('routes warning level to logger.warn', () => {
+        const spy = vi.spyOn(logger, 'warn').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'warning', data: 'hello' } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('hello'));
+    });
+    it('routes error level to logger.error', () => {
+        const spy = vi.spyOn(logger, 'error').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'error', data: 'hello' } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('hello'));
+    });
+    it('routes critical level to logger.error', () => {
+        const spy = vi.spyOn(logger, 'error').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'critical', data: 'hello' } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('hello'));
+    });
+    it('routes alert level to logger.error', () => {
+        const spy = vi.spyOn(logger, 'error').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'alert', data: 'hello' } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('hello'));
+    });
+    it('routes emergency level to logger.error', () => {
+        const spy = vi.spyOn(logger, 'error').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'emergency', data: 'hello' } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('hello'));
+    });
+    it('includes logger name and data in the message', () => {
+        const spy = vi.spyOn(logger, 'info').mockImplementation(() => { });
+        notificationHandler({ params: { level: 'info', logger: 'my-server', data: { key: 'val' } } });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('my-server'));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('key'));
+    });
+    it('calls custom logHandler when provided', () => {
+        const customHandler = vi.fn();
+        new McpClient({ applicationName: 'TestApp', transport: mockTransport, logHandler: customHandler });
+        const customSdkMock = vi.mocked(Client).mock.results.at(-1).value;
+        const capturedHandler = customSdkMock.setNotificationHandler.mock.calls[0][1];
+        const params = { level: 'info', data: 'test' };
+        capturedHandler({ params });
+        expect(customHandler).toHaveBeenCalledWith(params);
+    });
+});
+describe('McpClient transport resolution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('constructs StreamableHTTPClientTransport when url is provided', () => {
+        new McpClient({ url: 'https://mcp.example.com' });
+        expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(new URL('https://mcp.example.com'), undefined);
+    });
+    it('constructs ClientCredentialsProvider when auth is provided', () => {
+        new McpClient({ url: 'https://mcp.example.com', auth: { clientId: 'id', clientSecret: 'secret' } });
+        expect(ClientCredentialsProvider).toHaveBeenCalledWith({ clientId: 'id', clientSecret: 'secret' });
+        expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(new URL('https://mcp.example.com'), {
+            authProvider: expect.anything(),
+        });
+    });
+    it('passes scopes as space-separated string', () => {
+        new McpClient({
+            url: 'https://mcp.example.com',
+            auth: { clientId: 'id', clientSecret: 'secret', scopes: ['read', 'write'] },
+        });
+        expect(ClientCredentialsProvider).toHaveBeenCalledWith({
+            clientId: 'id',
+            clientSecret: 'secret',
+            scope: 'read write',
+        });
+    });
+    it('passes custom authProvider to transport', () => {
+        const customProvider = { redirectUrl: undefined, clientMetadata: {} };
+        new McpClient({ url: 'https://mcp.example.com', authProvider: customProvider });
+        expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(new URL('https://mcp.example.com'), {
+            authProvider: customProvider,
+        });
+    });
+    it('throws when both transport and url are provided', () => {
+        expect(() => new McpClient({ transport: mockTransport, url: 'https://mcp.example.com' })).toThrow('provide either "transport" or "url", not both');
+    });
+    it('throws when neither transport nor url is provided', () => {
+        expect(() => new McpClient({})).toThrow('either "transport" or "url" must be provided');
+    });
+    it('throws when auth is provided with transport', () => {
+        expect(() => new McpClient({ transport: mockTransport, auth: { clientId: 'x', clientSecret: 'y' } })).toThrow('"auth", "authProvider", and "headers" require "url"');
+    });
+    it('throws when both auth and authProvider are provided', () => {
+        const customProvider = {};
+        expect(() => new McpClient({
+            url: 'https://mcp.example.com',
+            auth: { clientId: 'x', clientSecret: 'y' },
+            authProvider: customProvider,
+        })).toThrow('provide either "auth" or "authProvider", not both');
+    });
+    it('accepts URL instance for url field', () => {
+        const url = new URL('https://mcp.example.com/path');
+        new McpClient({ url });
+        expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(url, undefined);
+    });
+    it('passes headers as requestInit to transport', () => {
+        new McpClient({ url: 'https://mcp.example.com', headers: { 'X-Api-Key': 'abc' } });
+        expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(new URL('https://mcp.example.com'), {
+            requestInit: { headers: { 'X-Api-Key': 'abc' } },
+        });
+    });
+    it('passes both auth and headers to transport', () => {
+        new McpClient({
+            url: 'https://mcp.example.com',
+            auth: { clientId: 'id', clientSecret: 'secret' },
+            headers: { 'X-Trace': '123' },
+        });
+        expect(ClientCredentialsProvider).toHaveBeenCalledWith({ clientId: 'id', clientSecret: 'secret' });
+        expect(StreamableHTTPClientTransport).toHaveBeenCalledWith(new URL('https://mcp.example.com'), {
+            authProvider: expect.anything(),
+            requestInit: { headers: { 'X-Trace': '123' } },
+        });
+    });
+    it('throws when headers is provided with transport', () => {
+        expect(() => new McpClient({ transport: mockTransport, headers: { 'X-Foo': 'bar' } })).toThrow('"auth", "authProvider", and "headers" require "url"');
+    });
+});
 //# sourceMappingURL=mcp.test.js.map