mcp-use 0.1.6 → 0.1.8

package/dist/tests/stream_events_simple.test.js

@@ -0,0 +1,179 @@
+/**
+ * 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.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":";AAEA,wBAmBE"}

package/dist/vitest.config.js

@@ -0,0 +1,21 @@
+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',
+        },
+    },
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-use",
   "type": "module",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "packageManager": "pnpm@10.6.1",
   "description": "A utility library for integrating Model Context Protocol (MCP) with LangChain, Zod, and related tools. Provides helpers for schema conversion, event streaming, and SDK usage.",
   "author": "Zane",
@@ -46,11 +46,15 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:simple": "vitest run tests/stream_events_simple.test.ts",
+    "test:integration": "vitest run tests/stream_events.test.ts",
     "watch": "tsc --watch",
     "start": "node dist/index.js",
     "prepublishOnly": "npm run build",
-    "lint": "eslint",
-    "lint:fix": "eslint --fix",
     "fmt": "eslint --fix",
     "release": "npm version patch --tag-version-prefix=v && git push --follow-tags",
     "release:minor": "npm version minor --tag-version-prefix=v && git push --follow-tags",
@@ -59,6 +63,9 @@
     "example:airbnb": "npm run build && node dist/examples/airbnb_use.js",
     "example:browser": "npm run build && node dist/examples/browser_use.js",
     "example:chat": "npm run build && node dist/examples/chat_example.js",
+    "example:stream": "npm run build && node dist/examples/stream_example.js",
+    "example:stream_events": "npm run build && node dist/examples/stream_events_example.js",
+    "example:ai_sdk": "npm run build && node dist/examples/ai_sdk_example.js",
     "example:filesystem": "npm run build && node dist/examples/filesystem_use.js",
     "example:http": "npm run build && node dist/examples/http_example.js",
     "example:everything": "npm run build && node dist/examples/mcp_everything.js",
@@ -75,6 +82,7 @@
     "@langchain/openai": "^0.5.15",
     "@modelcontextprotocol/sdk": "1.12.1",
     "@scarf/scarf": "^1.4.0",
+    "ai": "^4.3.19",
     "dotenv": "^16.5.0",
     "eventsource": "^3.0.6",
     "fastembed": "^1.14.4",
@@ -90,13 +98,15 @@
   "devDependencies": {
     "@antfu/eslint-config": "^4.13.2",
     "@types/lodash-es": "^4.17.12",
+    "@types/node": "^20.19.8",
     "@types/ws": "^8.18.1",
     "eslint": "^9.28.0",
     "eslint-plugin-format": "^1.0.1",
     "husky": "^9.1.7",
     "lint-staged": "^15.2.11",
     "shx": "^0.4.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^2.1.9"
   },
   "lint-staged": {
     "*.{js,ts}": [