mcp-use 0.1.6 → 0.1.8

package/dist/tests/ai_sdk_compatibility.test.js

@@ -0,0 +1,214 @@
+/**
+ * Tests for AI SDK compatibility with MCPAgent streamEvents()
+ *
+ * These tests verify that streamEvents() can be used with the AI SDK's
+ * LangChainAdapter for creating data stream responses compatible with
+ * Vercel AI SDK hooks like useCompletion and useChat.
+ */
+import { LangChainAdapter } from 'ai';
+import { describe, expect, it } from 'vitest';
+// Mock an async generator that simulates our streamEvents output
+async function* mockStreamEvents() {
+    // Simulate typical events from streamEvents
+    yield {
+        event: 'on_chain_start',
+        name: 'AgentExecutor',
+        data: { input: { input: 'test query' } },
+    };
+    yield {
+        event: 'on_chat_model_stream',
+        name: 'ChatAnthropic',
+        data: { chunk: { content: 'Hello' } },
+    };
+    yield {
+        event: 'on_chat_model_stream',
+        name: 'ChatAnthropic',
+        data: { chunk: { content: ' world' } },
+    };
+    yield {
+        event: 'on_chat_model_stream',
+        name: 'ChatAnthropic',
+        data: { chunk: { content: '!' } },
+    };
+    yield {
+        event: 'on_tool_start',
+        name: 'test_tool',
+        data: { input: { query: 'test' } },
+    };
+    yield {
+        event: 'on_tool_end',
+        name: 'test_tool',
+        data: { output: 'Tool executed successfully' },
+    };
+    yield {
+        event: 'on_chain_end',
+        name: 'AgentExecutor',
+        data: { output: 'Hello world!' },
+    };
+}
+// Function to convert streamEvents to a format compatible with AI SDK
+async function* streamEventsToAISDK(streamEvents) {
+    for await (const event of streamEvents) {
+        // Only yield the actual content tokens from chat model streams
+        if (event.event === 'on_chat_model_stream' && event.data?.chunk?.content) {
+            yield event.data.chunk.content;
+        }
+    }
+}
+// Alternative adapter that yields complete content at the end
+async function* streamEventsToCompleteContent(streamEvents) {
+    let fullContent = '';
+    for await (const event of streamEvents) {
+        if (event.event === 'on_chat_model_stream' && event.data?.chunk?.content) {
+            fullContent += event.data.chunk.content;
+        }
+        // For tool events, we could add additional formatting
+        else if (event.event === 'on_tool_start') {
+            // Could add tool start indicators if needed
+        }
+        else if (event.event === 'on_tool_end') {
+            // Could add tool completion indicators if needed
+        }
+    }
+    // Yield the complete content at the end
+    if (fullContent) {
+        yield fullContent;
+    }
+}
+describe('aI SDK Compatibility', () => {
+    it('should convert streamEvents to AI SDK compatible stream', async () => {
+        const mockEvents = mockStreamEvents();
+        const aiSDKStream = streamEventsToAISDK(mockEvents);
+        const tokens = [];
+        for await (const token of aiSDKStream) {
+            tokens.push(token);
+        }
+        expect(tokens).toEqual(['Hello', ' world', '!']);
+    });
+    it('should work with LangChainAdapter.toDataStreamResponse', async () => {
+        const mockEvents = mockStreamEvents();
+        const aiSDKStream = streamEventsToAISDK(mockEvents);
+        // Convert async generator to ReadableStream for AI SDK compatibility
+        const readableStream = new ReadableStream({
+            async start(controller) {
+                try {
+                    for await (const token of aiSDKStream) {
+                        controller.enqueue(token);
+                    }
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+        // Test that we can create a data stream response
+        const response = LangChainAdapter.toDataStreamResponse(readableStream);
+        expect(response).toBeInstanceOf(Response);
+        expect(response.headers.get('Content-Type')).toBe('text/plain; charset=utf-8');
+    });
+    it('should convert streamEvents to complete content stream', async () => {
+        const mockEvents = mockStreamEvents();
+        const contentStream = streamEventsToCompleteContent(mockEvents);
+        const content = [];
+        for await (const chunk of contentStream) {
+            content.push(chunk);
+        }
+        expect(content).toEqual(['Hello world!']);
+    });
+    it('should handle empty streams gracefully', async () => {
+        async function* emptyStreamEvents() {
+            // Empty generator
+        }
+        const emptyEvents = emptyStreamEvents();
+        const aiSDKStream = streamEventsToAISDK(emptyEvents);
+        const tokens = [];
+        for await (const token of aiSDKStream) {
+            tokens.push(token);
+        }
+        expect(tokens).toEqual([]);
+    });
+    it('should filter non-content events correctly', async () => {
+        async function* mixedEvents() {
+            yield {
+                event: 'on_chain_start',
+                name: 'Test',
+                data: { input: 'test' },
+            };
+            yield {
+                event: 'on_chat_model_stream',
+                name: 'ChatModel',
+                data: { chunk: { content: 'Content' } },
+            };
+            yield {
+                event: 'on_tool_start',
+                name: 'Tool',
+                data: { input: 'test' },
+            };
+            yield {
+                event: 'on_chat_model_stream',
+                name: 'ChatModel',
+                data: { chunk: { content: ' token' } },
+            };
+            yield {
+                event: 'on_chain_end',
+                name: 'Test',
+                data: { output: 'result' },
+            };
+        }
+        const events = mixedEvents();
+        const aiSDKStream = streamEventsToAISDK(events);
+        const tokens = [];
+        for await (const token of aiSDKStream) {
+            tokens.push(token);
+        }
+        expect(tokens).toEqual(['Content', ' token']);
+    });
+    it('should create readable stream from streamEvents', async () => {
+        const mockEvents = mockStreamEvents();
+        // Create a ReadableStream from our async generator
+        const readableStream = new ReadableStream({
+            async start(controller) {
+                try {
+                    for await (const event of streamEventsToAISDK(mockEvents)) {
+                        controller.enqueue(new TextEncoder().encode(event));
+                    }
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+            },
+        });
+        expect(readableStream).toBeInstanceOf(ReadableStream);
+        // Test that we can read from the stream
+        const reader = readableStream.getReader();
+        const decoder = new TextDecoder();
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(decoder.decode(value));
+        }
+        expect(chunks).toEqual(['Hello', ' world', '!']);
+    });
+});
+// Convert async generator to ReadableStream for AI SDK compatibility
+function createReadableStreamFromGenerator(generator) {
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                for await (const chunk of generator) {
+                    controller.enqueue(chunk);
+                }
+                controller.close();
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+    });
+}
+// Export the adapter functions for use in examples
+export { createReadableStreamFromGenerator, streamEventsToAISDK, streamEventsToCompleteContent };

package/dist/tests/stream_events.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stream_events.test.d.ts.map

package/dist/tests/stream_events.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream_events.test.d.ts","sourceRoot":"","sources":["../../tests/stream_events.test.ts"],"names":[],"mappings":""}

package/dist/tests/stream_events.test.js

@@ -0,0 +1,306 @@
+/* eslint-disable no-unreachable-loop, unused-imports/no-unused-vars */
+import { HumanMessage } from '@langchain/core/messages';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { MCPAgent, MCPClient } from '../index.js';
+// Mock the MCP client for testing
+vi.mock('../src/client.js', () => ({
+    MCPClient: vi.fn().mockImplementation(() => ({
+        getAllActiveSessions: vi.fn().mockResolvedValue({}),
+        createAllSessions: vi.fn().mockResolvedValue({}),
+        closeAllSessions: vi.fn().mockResolvedValue(undefined),
+    })),
+}));
+// Mock the LangChain adapter
+vi.mock('../src/adapters/langchain_adapter.js', () => ({
+    LangChainAdapter: vi.fn().mockImplementation(() => ({
+        createToolsFromConnectors: vi.fn().mockResolvedValue([
+            {
+                name: 'test_tool',
+                description: 'A test tool',
+                schema: {},
+                func: vi.fn().mockResolvedValue('Test tool result'),
+            },
+        ]),
+    })),
+}));
+describe('mCPAgent streamEvents()', () => {
+    let agent;
+    let mockClient;
+    let mockLLM;
+    beforeEach(() => {
+        // Create mock LLM that supports streamEvents
+        mockLLM = {
+            invoke: vi.fn().mockResolvedValue({ content: 'Test response' }),
+            _modelType: 'chat_anthropic',
+            _llmType: 'anthropic',
+        };
+        // Create mock client
+        mockClient = new MCPClient({});
+        // Create agent with mocked dependencies
+        agent = new MCPAgent({
+            llm: mockLLM,
+            client: mockClient,
+            maxSteps: 3,
+            memoryEnabled: true,
+            verbose: false,
+        });
+        // Mock the agent executor's streamEvents method
+        const mockStreamEvents = vi.fn().mockImplementation(async function* () {
+            // Simulate typical event sequence
+            yield {
+                event: 'on_chain_start',
+                name: 'AgentExecutor',
+                data: { input: { input: 'test query' } },
+            };
+            yield {
+                event: 'on_chat_model_stream',
+                name: 'ChatAnthropic',
+                data: { chunk: { content: 'Hello' } },
+            };
+            yield {
+                event: 'on_chat_model_stream',
+                name: 'ChatAnthropic',
+                data: { chunk: { content: ' world' } },
+            };
+            yield {
+                event: 'on_tool_start',
+                name: 'test_tool',
+                data: { input: { query: 'test' } },
+            };
+            yield {
+                event: 'on_tool_end',
+                name: 'test_tool',
+                data: { output: 'Tool result' },
+            };
+            yield {
+                event: 'on_chain_end',
+                name: 'AgentExecutor',
+                data: { output: 'Hello world' },
+            };
+        });
+        // Mock initialize method
+        vi.spyOn(agent, 'initialize').mockResolvedValue(undefined);
+        // Mock agentExecutor after initialization
+        Object.defineProperty(agent, 'agentExecutor', {
+            get: () => ({
+                streamEvents: mockStreamEvents,
+                maxIterations: 3,
+            }),
+            configurable: true,
+        });
+        // Mock tools
+        Object.defineProperty(agent, 'tools', {
+            get: () => [{ name: 'test_tool' }],
+            configurable: true,
+        });
+        // Mock telemetry using bracket notation to access private property
+        vi.spyOn(agent.telemetry, 'trackAgentExecution').mockResolvedValue(undefined);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should yield StreamEvent objects', async () => {
+        const events = [];
+        for await (const event of agent.streamEvents('test query')) {
+            events.push(event);
+        }
+        expect(events).toHaveLength(6);
+        // Check event structure
+        events.forEach((event) => {
+            expect(event).toHaveProperty('event');
+            expect(event).toHaveProperty('name');
+            expect(event).toHaveProperty('data');
+        });
+    });
+    it('should handle token streaming correctly', async () => {
+        const tokens = [];
+        for await (const event of agent.streamEvents('test query')) {
+            if (event.event === 'on_chat_model_stream' && event.data?.chunk?.content) {
+                tokens.push(event.data.chunk.content);
+            }
+        }
+        expect(tokens).toEqual(['Hello', ' world']);
+    });
+    it('should track tool execution events', async () => {
+        const toolEvents = [];
+        for await (const event of agent.streamEvents('test query')) {
+            if (event.event.includes('tool')) {
+                toolEvents.push(event);
+            }
+        }
+        expect(toolEvents).toHaveLength(2);
+        expect(toolEvents[0].event).toBe('on_tool_start');
+        expect(toolEvents[0].name).toBe('test_tool');
+        expect(toolEvents[1].event).toBe('on_tool_end');
+        expect(toolEvents[1].name).toBe('test_tool');
+    });
+    it('should initialize agent if not already initialized', async () => {
+        const initializeSpy = vi.spyOn(agent, 'initialize');
+        // Set initialized to false
+        Object.defineProperty(agent, 'initialized', {
+            get: () => false,
+            configurable: true,
+        });
+        const events = [];
+        for await (const event of agent.streamEvents('test query')) {
+            events.push(event);
+            break; // Just get first event
+        }
+        expect(initializeSpy).toHaveBeenCalled();
+    });
+    it('should handle memory correctly when enabled', async () => {
+        const addToHistorySpy = vi.spyOn(agent, 'addToHistory');
+        // Consume all events
+        const events = [];
+        for await (const event of agent.streamEvents('test query')) {
+            events.push(event);
+        }
+        // Should add user message and AI response to history
+        expect(addToHistorySpy).toHaveBeenCalledTimes(2);
+    });
+    it('should track telemetry', async () => {
+        const telemetrySpy = vi.spyOn(agent.telemetry, 'trackAgentExecution');
+        // Consume all events
+        for await (const event of agent.streamEvents('test query')) {
+            // Just consume events
+        }
+        expect(telemetrySpy).toHaveBeenCalledWith(expect.objectContaining({
+            executionMethod: 'streamEvents',
+            query: 'test query',
+            success: true,
+        }));
+    });
+    it('should handle errors gracefully', async () => {
+        // Mock agent executor to throw error
+        Object.defineProperty(agent, 'agentExecutor', {
+            get: () => ({
+                streamEvents: vi.fn().mockImplementation(async function* () {
+                    throw new Error('Test error');
+                }),
+                maxIterations: 3,
+            }),
+            configurable: true,
+        });
+        await expect(async () => {
+            for await (const event of agent.streamEvents('test query')) {
+                // Should not reach here
+            }
+        }).rejects.toThrow('Test error');
+    });
+    it('should respect maxSteps parameter', async () => {
+        const mockAgentExecutor = {
+            streamEvents: vi.fn().mockImplementation(async function* () {
+                yield { event: 'test', name: 'test', data: {} };
+            }),
+            maxIterations: 3,
+        };
+        Object.defineProperty(agent, 'agentExecutor', {
+            get: () => mockAgentExecutor,
+            configurable: true,
+        });
+        for await (const event of agent.streamEvents('test query', 5)) {
+            break;
+        }
+        expect(mockAgentExecutor.maxIterations).toBe(5);
+    });
+    it('should handle external history', async () => {
+        const externalHistory = [
+            new HumanMessage('Previous message'),
+        ];
+        // Mock the agent executor to capture inputs
+        let capturedInputs;
+        const mockStreamEvents = vi.fn().mockImplementation(async function* (inputs) {
+            capturedInputs = inputs;
+            yield { event: 'test', name: 'test', data: {} };
+        });
+        Object.defineProperty(agent, 'agentExecutor', {
+            get: () => ({
+                streamEvents: mockStreamEvents,
+                maxIterations: 3,
+            }),
+            configurable: true,
+        });
+        // Mock initialize method
+        vi.spyOn(agent, 'initialize').mockResolvedValue(undefined);
+        for await (const event of agent.streamEvents('test query', undefined, true, externalHistory)) {
+            break;
+        }
+        expect(capturedInputs.chat_history).toEqual(externalHistory);
+    });
+    it('should clean up resources on completion', async () => {
+        const closeSpy = vi.spyOn(agent, 'close').mockResolvedValue(undefined);
+        // Test with manageConnector=true and no client
+        Object.defineProperty(agent, 'client', {
+            get: () => undefined,
+            configurable: true,
+        });
+        // Consume all events
+        for await (const event of agent.streamEvents('test query', undefined, true)) {
+            // Just consume events
+        }
+        // Note: cleanup only happens if initialized in this call and no client
+        // This is hard to test with our current mocking setup, but the logic is there
+    });
+});
+describe('mCPAgent streamEvents() edge cases', () => {
+    it('should handle empty event stream', async () => {
+        const mockLLM = {
+            invoke: vi.fn().mockResolvedValue({ content: 'Test response' }),
+            _modelType: 'chat_anthropic',
+        };
+        const mockClient = new MCPClient({});
+        const agent = new MCPAgent({
+            llm: mockLLM,
+            client: mockClient,
+            maxSteps: 3,
+        });
+        // Mock empty event stream
+        Object.defineProperty(agent, 'agentExecutor', {
+            get: () => ({
+                streamEvents: vi.fn().mockImplementation(async function* () {
+                    // Empty generator
+                }),
+                maxIterations: 3,
+            }),
+            configurable: true,
+        });
+        vi.spyOn(agent, 'initialize').mockResolvedValue(undefined);
+        vi.spyOn(agent.telemetry, 'trackAgentExecution').mockResolvedValue(undefined);
+        const events = [];
+        for await (const event of agent.streamEvents('test query')) {
+            events.push(event);
+        }
+        expect(events).toHaveLength(0);
+    });
+    it('should handle malformed events gracefully', async () => {
+        const mockLLM = {
+            invoke: vi.fn().mockResolvedValue({ content: 'Test response' }),
+            _modelType: 'chat_anthropic',
+        };
+        const mockClient = new MCPClient({});
+        const agent = new MCPAgent({
+            llm: mockLLM,
+            client: mockClient,
+            maxSteps: 3,
+        });
+        // Mock malformed event stream
+        Object.defineProperty(agent, 'agentExecutor', {
+            get: () => ({
+                streamEvents: vi.fn().mockImplementation(async function* () {
+                    yield { event: 'malformed' }; // Missing required fields
+                    yield null; // Invalid event
+                    yield { event: 'on_chat_model_stream', data: { chunk: { content: 'test' } } };
+                }),
+                maxIterations: 3,
+            }),
+            configurable: true,
+        });
+        vi.spyOn(agent, 'initialize').mockResolvedValue(undefined);
+        vi.spyOn(agent.telemetry, 'trackAgentExecution').mockResolvedValue(undefined);
+        const events = [];
+        for await (const event of agent.streamEvents('test query')) {
+            events.push(event);
+        }
+        expect(events).toHaveLength(3); // Should still yield all events, even malformed ones
+    });
+});

package/dist/tests/stream_events_simple.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Simple tests for MCPAgent streamEvents() method
+ *
+ * These tests verify the basic functionality of streamEvents() using minimal mocking
+ */
+export {};
+//# sourceMappingURL=stream_events_simple.test.d.ts.map

package/dist/tests/stream_events_simple.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream_events_simple.test.d.ts","sourceRoot":"","sources":["../../tests/stream_events_simple.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}