mcp-use 0.1.20 → 0.3.0

package/dist/tests/ai_sdk_compatibility.test.js

@@ -1,214 +0,0 @@
-/**
- * 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.js

@@ -1,307 +0,0 @@
-/* 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: [{ text: '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' } } };
-                    yield { event: 'on_chain_end', data: { output: [{ text: 'test response' }] } };
-                }),
-                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.js

@@ -1,179 +0,0 @@
-/**
- * Simple tests for MCPAgent streamEvents() method
- *
- * These tests verify the basic functionality of streamEvents() using minimal mocking
- */
-import { describe, expect, it } from 'vitest';
-describe('test MCPAgent streamEvents() - Core Functionality', () => {
-    it('should be a generator function that yields StreamEvent objects', async () => {
-        // Mock a simple agent-like object with streamEvents method
-        const mockAgent = {
-            async *streamEvents(query) {
-                // Simulate typical event sequence
-                yield {
-                    event: 'on_chain_start',
-                    name: 'AgentExecutor',
-                    data: { input: { input: 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!' },
-                };
-            },
-        };
-        const events = [];
-        const tokens = [];
-        const toolEvents = [];
-        // Collect all events
-        for await (const event of mockAgent.streamEvents('test query')) {
-            events.push(event);
-            // Collect tokens
-            if (event.event === 'on_chat_model_stream' && event.data?.chunk?.content) {
-                tokens.push(event.data.chunk.content);
-            }
-            // Collect tool events
-            if (event.event.includes('tool')) {
-                toolEvents.push(event);
-            }
-        }
-        // Verify we got the expected number of events
-        expect(events).toHaveLength(6);
-        // Verify event structure
-        events.forEach((event) => {
-            expect(event).toHaveProperty('event');
-            expect(event).toHaveProperty('name');
-            expect(event).toHaveProperty('data');
-        });
-        // Verify token streaming works
-        expect(tokens).toEqual(['Hello', ' world!']);
-        // Verify tool events
-        expect(toolEvents).toHaveLength(2);
-        expect(toolEvents[0].event).toBe('on_tool_start');
-        expect(toolEvents[1].event).toBe('on_tool_end');
-        // Verify event types are correct
-        expect(events[0].event).toBe('on_chain_start');
-        expect(events[1].event).toBe('on_chat_model_stream');
-        expect(events[2].event).toBe('on_chat_model_stream');
-        expect(events[3].event).toBe('on_tool_start');
-        expect(events[4].event).toBe('on_tool_end');
-        expect(events[5].event).toBe('on_chain_end');
-    });
-    it('should handle different event types correctly', async () => {
-        const mockAgent = {
-            async *streamEvents() {
-                // Test different event types
-                const eventTypes = [
-                    'on_chain_start',
-                    'on_llm_start',
-                    'on_llm_stream',
-                    'on_llm_end',
-                    'on_tool_start',
-                    'on_tool_stream',
-                    'on_tool_end',
-                    'on_retriever_start',
-                    'on_retriever_end',
-                    'on_parser_start',
-                    'on_parser_end',
-                    'on_chain_end',
-                ];
-                for (const eventType of eventTypes) {
-                    yield {
-                        event: eventType,
-                        name: 'TestComponent',
-                        data: { test: true },
-                        run_id: 'test-run-id',
-                        metadata: {},
-                    };
-                }
-            },
-        };
-        const events = [];
-        for await (const event of mockAgent.streamEvents()) {
-            events.push(event);
-        }
-        expect(events).toHaveLength(12);
-        // Verify we got all the different event types
-        const receivedEventTypes = events.map(e => e.event);
-        expect(receivedEventTypes).toContain('on_chain_start');
-        expect(receivedEventTypes).toContain('on_llm_stream');
-        expect(receivedEventTypes).toContain('on_tool_start');
-        expect(receivedEventTypes).toContain('on_tool_end');
-        expect(receivedEventTypes).toContain('on_chain_end');
-    });
-    it('should work with empty event streams', async () => {
-        const mockAgent = {
-            async *streamEvents() {
-                // Empty generator
-            },
-        };
-        const events = [];
-        for await (const event of mockAgent.streamEvents()) {
-            events.push(event);
-        }
-        expect(events).toHaveLength(0);
-    });
-    it('should handle streaming token reconstruction', async () => {
-        const mockAgent = {
-            async *streamEvents() {
-                const tokens = ['The', ' quick', ' brown', ' fox', ' jumps', ' over', ' the', ' lazy', ' dog.'];
-                for (const token of tokens) {
-                    yield {
-                        event: 'on_chat_model_stream',
-                        name: 'ChatModel',
-                        data: { chunk: { content: token } },
-                    };
-                }
-            },
-        };
-        let reconstructedText = '';
-        const tokenCount = { count: 0 };
-        for await (const event of mockAgent.streamEvents()) {
-            if (event.event === 'on_chat_model_stream' && event.data?.chunk?.content) {
-                reconstructedText += event.data.chunk.content;
-                tokenCount.count++;
-            }
-        }
-        expect(reconstructedText).toBe('The quick brown fox jumps over the lazy dog.');
-        expect(tokenCount.count).toBe(9);
-    });
-});
-describe('streamEvent type verification', () => {
-    it('should have correct StreamEvent interface', () => {
-        const sampleEvent = {
-            event: 'on_chat_model_stream',
-            name: 'TestModel',
-            data: {
-                chunk: { content: 'test' },
-                input: { query: 'test' },
-                output: 'result',
-            },
-            run_id: 'test-run-id',
-            metadata: {},
-        };
-        expect(sampleEvent.event).toBe('on_chat_model_stream');
-        expect(sampleEvent.name).toBe('TestModel');
-        expect(sampleEvent.data).toBeDefined();
-        expect(sampleEvent.data.chunk?.content).toBe('test');
-    });
-});