mcp-use 0.2.0 → 1.0.0

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');
-    });
-});

package/dist/vitest.config.js

@@ -1,21 +0,0 @@
-import { defineConfig } from 'vitest/config';
-export default defineConfig({
-    test: {
-        globals: true,
-        environment: 'node',
-        include: ['tests/**/*.test.ts'],
-        exclude: ['node_modules/**', 'dist/**'],
-        coverage: {
-            provider: 'v8',
-            include: ['src/**/*.ts'],
-            exclude: ['src/**/*.d.ts', 'src/**/index.ts'],
-        },
-        testTimeout: 30000,
-        hookTimeout: 30000,
-    },
-    resolve: {
-        alias: {
-            '@': './src',
-        },
-    },
-});