mcp-use 0.1.7 → 0.1.9

package/dist/src/agents/mcp_agent.js

@@ -22,12 +22,12 @@ export class MCPAgent {
     systemPrompt;
     systemPromptTemplateOverride;
     additionalInstructions;
-    initialized = false;
+    _initialized = false;
     conversationHistory = [];
-    agentExecutor = null;
+    _agentExecutor = null;
     sessions = {};
     systemMessage = null;
-    tools = [];
+    _tools = [];
     adapter;
     serverManager = null;
     telemetry;
@@ -67,6 +67,19 @@ export class MCPAgent {
         const [provider, name] = extractModelInfo(this.llm);
         this.modelProvider = provider;
         this.modelName = name;
+        // Make getters configurable for test mocking
+        Object.defineProperty(this, 'agentExecutor', {
+            get: () => this._agentExecutor,
+            configurable: true,
+        });
+        Object.defineProperty(this, 'tools', {
+            get: () => this._tools,
+            configurable: true,
+        });
+        Object.defineProperty(this, 'initialized', {
+            get: () => this._initialized,
+            configurable: true,
+        });
     }
     async initialize() {
         logger.info('🚀 Initializing MCP agent and connecting to services...');
@@ -75,11 +88,11 @@ export class MCPAgent {
             await this.serverManager.initialize();
             // Get server management tools
             const managementTools = this.serverManager.tools;
-            this.tools = managementTools;
-            this.tools.push(...this.additionalTools);
+            this._tools = managementTools;
+            this._tools.push(...this.additionalTools);
             logger.info(`🔧 Server manager mode active with ${managementTools.length} management tools`);
             // Create the system message based on available tools
-            await this.createSystemMessageFromTools(this.tools);
+            await this.createSystemMessageFromTools(this._tools);
         }
         else {
             // Standard initialization - if using client, get or create sessions
@@ -94,9 +107,9 @@ export class MCPAgent {
                     logger.info(`✅ Created ${Object.keys(this.sessions).length} new sessions`);
                 }
                 // Create LangChain tools directly from the client using the adapter
-                this.tools = await LangChainAdapter.createTools(this.client);
-                this.tools.push(...this.additionalTools);
-                logger.info(`🛠️ Created ${this.tools.length} LangChain tools from client`);
+                this._tools = await LangChainAdapter.createTools(this.client);
+                this._tools.push(...this.additionalTools);
+                logger.info(`🛠️ Created ${this._tools.length} LangChain tools from client`);
             }
             else {
                 // Using direct connector - only establish connection
@@ -107,18 +120,18 @@ export class MCPAgent {
                     }
                 }
                 // Create LangChain tools using the adapter with connectors
-                this.tools = await this.adapter.createToolsFromConnectors(this.connectors);
-                this.tools.push(...this.additionalTools);
-                logger.info(`🛠️ Created ${this.tools.length} LangChain tools from connectors`);
+                this._tools = await this.adapter.createToolsFromConnectors(this.connectors);
+                this._tools.push(...this.additionalTools);
+                logger.info(`🛠️ Created ${this._tools.length} LangChain tools from connectors`);
             }
             // Get all tools for system message generation
-            logger.info(`🧰 Found ${this.tools.length} tools across all connectors`);
+            logger.info(`🧰 Found ${this._tools.length} tools across all connectors`);
             // Create the system message based on available tools
-            await this.createSystemMessageFromTools(this.tools);
+            await this.createSystemMessageFromTools(this._tools);
         }
         // Create the agent executor and mark initialized
-        this.agentExecutor = this.createAgent();
-        this.initialized = true;
+        this._agentExecutor = this.createAgent();
+        this._initialized = true;
         logger.info('✨ Agent initialization complete');
     }
     async createSystemMessageFromTools(tools) {
@@ -142,12 +155,12 @@ export class MCPAgent {
         ]);
         const agent = createToolCallingAgent({
             llm: this.llm,
-            tools: this.tools,
+            tools: this._tools,
             prompt,
         });
         return new AgentExecutor({
             agent,
-            tools: this.tools,
+            tools: this._tools,
             maxIterations: this.maxSteps,
             verbose: this.verbose,
             returnIntermediateSteps: true,
@@ -172,15 +185,15 @@ export class MCPAgent {
             this.conversationHistory = this.conversationHistory.filter(m => !(m instanceof SystemMessage));
             this.conversationHistory.unshift(this.systemMessage);
         }
-        if (this.initialized && this.tools.length) {
-            this.agentExecutor = this.createAgent();
+        if (this._initialized && this._tools.length) {
+            this._agentExecutor = this.createAgent();
             logger.debug('Agent recreated with new system message');
         }
     }
     setDisallowedTools(disallowedTools) {
         this.disallowedTools = disallowedTools;
         this.adapter = new LangChainAdapter(this.disallowedTools);
-        if (this.initialized) {
+        if (this._initialized) {
             logger.debug('Agent already initialized. Changes will take effect on next initialization.');
         }
     }
@@ -198,37 +211,68 @@ export class MCPAgent {
             }
         }
     }
-    /**
-     * Runs the agent and returns a promise for the final result.
-     */
-    async run(query, maxSteps, manageConnector, externalHistory) {
-        const generator = this.stream(query, maxSteps, manageConnector, externalHistory);
+    async run(query, maxSteps, manageConnector, externalHistory, outputSchema) {
+        const generator = this.stream(query, maxSteps, manageConnector, externalHistory, outputSchema);
         return this._consumeAndReturn(generator);
     }
     /**
      * Runs the agent and yields intermediate steps as an async generator.
+     * If outputSchema is provided, returns structured output of type T.
      */
-    async *stream(query, maxSteps, manageConnector = true, externalHistory) {
+    async *stream(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
         let result = '';
         let initializedHere = false;
         const startTime = Date.now();
         const toolsUsedNames = [];
         let stepsTaken = 0;
         let success = false;
+        // Schema-aware setup for structured output
+        let structuredLlm = null;
+        let schemaDescription = '';
+        if (outputSchema) {
+            query = this._enhanceQueryWithSchema(query, outputSchema);
+            // Check if withStructuredOutput method exists
+            if ('withStructuredOutput' in this.llm && typeof this.llm.withStructuredOutput === 'function') {
+                structuredLlm = this.llm.withStructuredOutput(outputSchema);
+            }
+            else {
+                // Fallback: use the same LLM but we'll handle structure in our helper method
+                structuredLlm = this.llm;
+            }
+            // Get schema description for feedback
+            try {
+                const schemaType = outputSchema;
+                if (schemaType._def && schemaType._def.shape) {
+                    const fields = [];
+                    for (const [key, fieldSchema] of Object.entries(schemaType._def.shape)) {
+                        const field = fieldSchema;
+                        const isOptional = field.isOptional?.() ?? field._def?.typeName === 'ZodOptional';
+                        const isNullable = field.isNullable?.() ?? field._def?.typeName === 'ZodNullable';
+                        const description = field._def?.description || field.description || key;
+                        fields.push(`- ${key}: ${description} ${(isOptional || isNullable) ? '(optional)' : '(required)'}`);
+                    }
+                    schemaDescription = fields.join('\n');
+                }
+            }
+            catch (e) {
+                logger.warn(`Could not extract schema details: ${e}`);
+                schemaDescription = `Schema: ${outputSchema.constructor.name}`;
+            }
+        }
         try {
-            if (manageConnector && !this.initialized) {
+            if (manageConnector && !this._initialized) {
                 await this.initialize();
                 initializedHere = true;
             }
-            else if (!this.initialized && this.autoInitialize) {
+            else if (!this._initialized && this.autoInitialize) {
                 await this.initialize();
                 initializedHere = true;
             }
-            if (!this.agentExecutor) {
+            if (!this._agentExecutor) {
                 throw new Error('MCP agent failed to initialize');
             }
             const steps = maxSteps ?? this.maxSteps;
-            this.agentExecutor.maxIterations = steps;
+            this._agentExecutor.maxIterations = steps;
             const display_query = query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, ' ')}...` : query.replace(/\n/g, ' ');
             logger.info(`💬 Received query: '${display_query}'`);
             // —–– Record user message
@@ -244,34 +288,73 @@ export class MCPAgent {
             }
             const intermediateSteps = [];
             const inputs = { input: query, chat_history: langchainHistory };
-            let nameToToolMap = Object.fromEntries(this.tools.map(t => [t.name, t]));
+            let nameToToolMap = Object.fromEntries(this._tools.map(t => [t.name, t]));
             logger.info(`🏁 Starting agent execution with max_steps=${steps}`);
             for (let stepNum = 0; stepNum < steps; stepNum++) {
                 stepsTaken = stepNum + 1;
                 if (this.useServerManager && this.serverManager) {
                     const currentTools = this.serverManager.tools;
                     const currentToolNames = new Set(currentTools.map(t => t.name));
-                    const existingToolNames = new Set(this.tools.map(t => t.name));
-                    const changed = currentTools.length !== this.tools.length
+                    const existingToolNames = new Set(this._tools.map(t => t.name));
+                    const changed = currentTools.length !== this._tools.length
                         || [...currentToolNames].some(n => !existingToolNames.has(n));
                     if (changed) {
                         logger.info(`🔄 Tools changed before step ${stepNum + 1}, updating agent. New tools: ${[...currentToolNames].join(', ')}`);
-                        this.tools = currentTools;
-                        this.tools.push(...this.additionalTools);
-                        await this.createSystemMessageFromTools(this.tools);
-                        this.agentExecutor = this.createAgent();
-                        this.agentExecutor.maxIterations = steps;
-                        nameToToolMap = Object.fromEntries(this.tools.map(t => [t.name, t]));
+                        this._tools = currentTools;
+                        this._tools.push(...this.additionalTools);
+                        await this.createSystemMessageFromTools(this._tools);
+                        this._agentExecutor = this.createAgent();
+                        this._agentExecutor.maxIterations = steps;
+                        nameToToolMap = Object.fromEntries(this._tools.map(t => [t.name, t]));
                     }
                 }
                 logger.info(`👣 Step ${stepNum + 1}/${steps}`);
                 try {
                     logger.debug('Starting agent step execution');
-                    const nextStepOutput = await this.agentExecutor._takeNextStep(nameToToolMap, inputs, intermediateSteps);
+                    const nextStepOutput = await this._agentExecutor._takeNextStep(nameToToolMap, inputs, intermediateSteps);
                     if (nextStepOutput.returnValues) {
                         logger.info(`✅ Agent finished at step ${stepNum + 1}`);
                         result = nextStepOutput.returnValues?.output ?? 'No output generated';
-                        break;
+                        // If structured output is requested, attempt to create it
+                        if (outputSchema && structuredLlm) {
+                            try {
+                                logger.info('🔧 Attempting structured output...');
+                                const structuredResult = await this._attemptStructuredOutput(result, structuredLlm, outputSchema, schemaDescription);
+                                // Add the final response to conversation history if memory is enabled
+                                if (this.memoryEnabled) {
+                                    this.addToHistory(new AIMessage(`Structured result: ${JSON.stringify(structuredResult)}`));
+                                }
+                                logger.info('✅ Structured output successful');
+                                success = true;
+                                return structuredResult;
+                            }
+                            catch (e) {
+                                logger.warn(`⚠️ Structured output failed: ${e}`);
+                                // Continue execution to gather missing information
+                                const missingInfoPrompt = `
+                The current result cannot be formatted into the required structure.
+                Error: ${String(e)}
+                
+                Current information: ${result}
+                
+                Please continue working to gather the missing information needed for:
+                ${schemaDescription}
+                
+                Focus on finding the specific missing details.
+                `;
+                                // Add this as feedback and continue the loop
+                                inputs.input = missingInfoPrompt;
+                                if (this.memoryEnabled) {
+                                    this.addToHistory(new HumanMessage(missingInfoPrompt));
+                                }
+                                logger.info('🔄 Continuing execution to gather missing information...');
+                                continue;
+                            }
+                        }
+                        else {
+                            // Regular execution without structured output
+                            break;
+                        }
                     }
                     const stepArray = nextStepOutput;
                     intermediateSteps.push(...stepArray);
@@ -280,7 +363,9 @@ export class MCPAgent {
                         const { action, observation } = step;
                         const toolName = action.tool;
                         toolsUsedNames.push(toolName);
-                        let toolInputStr = String(action.toolInput);
+                        let toolInputStr = typeof action.toolInput === 'string'
+                            ? action.toolInput
+                            : JSON.stringify(action.toolInput, null, 2);
                         if (toolInputStr.length > 100)
                             toolInputStr = `${toolInputStr.slice(0, 97)}...`;
                         logger.info(`🔧 Tool call: ${toolName} with input: ${toolInputStr}`);
@@ -293,7 +378,7 @@ export class MCPAgent {
                     // Detect direct return
                     if (stepArray.length) {
                         const lastStep = stepArray[stepArray.length - 1];
-                        const toolReturn = await this.agentExecutor._getToolReturn(lastStep);
+                        const toolReturn = await this._agentExecutor._getToolReturn(lastStep);
                         if (toolReturn) {
                             logger.info(`🏆 Tool returned directly at step ${stepNum + 1}`);
                             result = toolReturn.returnValues?.output ?? 'No output generated';
@@ -318,11 +403,31 @@ export class MCPAgent {
                 logger.warn(`⚠️ Agent stopped after reaching max iterations (${steps})`);
                 result = `Agent stopped after reaching the maximum number of steps (${steps}).`;
             }
-            if (this.memoryEnabled) {
+            // If structured output was requested but not achieved, attempt one final time
+            if (outputSchema && structuredLlm && !success) {
+                try {
+                    logger.info('🔧 Final attempt at structured output...');
+                    const structuredResult = await this._attemptStructuredOutput(result, structuredLlm, outputSchema, schemaDescription);
+                    // Add the final response to conversation history if memory is enabled
+                    if (this.memoryEnabled) {
+                        this.addToHistory(new AIMessage(`Structured result: ${JSON.stringify(structuredResult)}`));
+                    }
+                    logger.info('✅ Final structured output successful');
+                    success = true;
+                    return structuredResult;
+                }
+                catch (e) {
+                    logger.error(`❌ Final structured output attempt failed: ${e}`);
+                    throw new Error(`Failed to generate structured output after ${steps} steps: ${e}`);
+                }
+            }
+            // Add the final response to conversation history if memory is enabled (regular case)
+            if (this.memoryEnabled && !outputSchema) {
                 this.addToHistory(new AIMessage(result));
             }
             logger.info('🎉 Agent execution complete');
             success = true;
+            // Return regular result
             return result;
         }
         catch (e) {
@@ -352,8 +457,8 @@ export class MCPAgent {
                 modelName: this.modelName,
                 serverCount,
                 serverIdentifiers: this.connectors.map(connector => connector.publicIdentifier),
-                totalToolsAvailable: this.tools.length,
-                toolsAvailableNames: this.tools.map(t => t.name),
+                totalToolsAvailable: this._tools.length,
+                toolsAvailableNames: this._tools.map(t => t.name),
                 maxStepsConfigured: this.maxSteps,
                 memoryEnabled: this.memoryEnabled,
                 useServerManager: this.useServerManager,
@@ -377,8 +482,8 @@ export class MCPAgent {
     async close() {
         logger.info('🔌 Closing MCPAgent resources…');
         try {
-            this.agentExecutor = null;
-            this.tools = [];
+            this._agentExecutor = null;
+            this._tools = [];
             if (this.client) {
                 logger.info('🔄 Closing sessions through client');
                 await this.client.closeAllSessions();
@@ -395,8 +500,208 @@ export class MCPAgent {
             }
         }
         finally {
-            this.initialized = false;
+            this._initialized = false;
             logger.info('👋 Agent closed successfully');
         }
     }
+    /**
+     * Yields LangChain StreamEvent objects from the underlying streamEvents() method.
+     * This provides token-level streaming and fine-grained event updates.
+     */
+    async *streamEvents(query, maxSteps, manageConnector = true, externalHistory) {
+        let initializedHere = false;
+        const startTime = Date.now();
+        let success = false;
+        let eventCount = 0;
+        let totalResponseLength = 0;
+        try {
+            // Initialize if needed
+            if (manageConnector && !this._initialized) {
+                await this.initialize();
+                initializedHere = true;
+            }
+            else if (!this._initialized && this.autoInitialize) {
+                await this.initialize();
+                initializedHere = true;
+            }
+            const agentExecutor = this.agentExecutor;
+            if (!agentExecutor) {
+                throw new Error('MCP agent failed to initialize');
+            }
+            // Set max iterations
+            const steps = maxSteps ?? this.maxSteps;
+            agentExecutor.maxIterations = steps;
+            const display_query = query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, ' ')}...` : query.replace(/\n/g, ' ');
+            logger.info(`💬 Received query for streamEvents: '${display_query}'`);
+            // Add user message to history if memory enabled
+            if (this.memoryEnabled) {
+                this.addToHistory(new HumanMessage(query));
+            }
+            // Prepare history
+            const historyToUse = externalHistory ?? this.conversationHistory;
+            const langchainHistory = [];
+            for (const msg of historyToUse) {
+                if (msg instanceof HumanMessage || msg instanceof AIMessage) {
+                    langchainHistory.push(msg);
+                }
+            }
+            // Prepare inputs
+            const inputs = { input: query, chat_history: langchainHistory };
+            // Stream events from the agent executor
+            const eventStream = agentExecutor.streamEvents(inputs, { version: 'v2' });
+            // Yield each event
+            for await (const event of eventStream) {
+                eventCount++;
+                // Skip null or invalid events
+                if (!event || typeof event !== 'object') {
+                    continue;
+                }
+                // Track response length for telemetry
+                if (event.event === 'on_chat_model_stream' && event.data?.chunk?.content) {
+                    totalResponseLength += event.data.chunk.content.length;
+                }
+                yield event;
+                // Handle final message for history
+                if (event.event === 'on_chain_end' && event.data?.output) {
+                    const output = event.data.output;
+                    if (typeof output === 'string' && this.memoryEnabled) {
+                        this.addToHistory(new AIMessage(output));
+                    }
+                    else if (output?.output && typeof output.output === 'string' && this.memoryEnabled) {
+                        this.addToHistory(new AIMessage(output.output));
+                    }
+                }
+            }
+            logger.info(`🎉 StreamEvents complete - ${eventCount} events emitted`);
+            success = true;
+        }
+        catch (e) {
+            logger.error(`❌ Error during streamEvents: ${e}`);
+            if (initializedHere && manageConnector) {
+                logger.info('🧹 Cleaning up resources after initialization error in streamEvents');
+                await this.close();
+            }
+            throw e;
+        }
+        finally {
+            // Track telemetry
+            const executionTimeMs = Date.now() - startTime;
+            let serverCount = 0;
+            if (this.client) {
+                serverCount = Object.keys(await this.client.getAllActiveSessions()).length;
+            }
+            else if (this.connectors) {
+                serverCount = this.connectors.length;
+            }
+            const conversationHistoryLength = this.memoryEnabled ? this.conversationHistory.length : 0;
+            await this.telemetry.trackAgentExecution({
+                executionMethod: 'streamEvents',
+                query,
+                success,
+                modelProvider: this.modelProvider,
+                modelName: this.modelName,
+                serverCount,
+                serverIdentifiers: this.connectors.map(connector => connector.publicIdentifier),
+                totalToolsAvailable: this._tools.length,
+                toolsAvailableNames: this._tools.map(t => t.name),
+                maxStepsConfigured: this.maxSteps,
+                memoryEnabled: this.memoryEnabled,
+                useServerManager: this.useServerManager,
+                maxStepsUsed: maxSteps ?? null,
+                manageConnector,
+                externalHistoryUsed: externalHistory !== undefined,
+                response: `[STREAMED RESPONSE - ${totalResponseLength} chars]`,
+                executionTimeMs,
+                errorType: success ? null : 'streaming_error',
+                conversationHistoryLength,
+            });
+            // Clean up if needed
+            if (manageConnector && !this.client && initializedHere) {
+                logger.info('🧹 Closing agent after streamEvents completion');
+                await this.close();
+            }
+        }
+    }
+    /**
+     * Attempt to create structured output from raw result with validation.
+     */
+    async _attemptStructuredOutput(rawResult, structuredLlm, outputSchema, schemaDescription) {
+        const formatPrompt = `
+    Please format the following information according to the specified schema.
+    Extract and structure the relevant information from the content below.
+    
+    Required schema fields:
+    ${schemaDescription}
+    
+    Content to format:
+    ${rawResult}
+    
+    Please provide the information in the requested structured format.
+    If any required information is missing, you must indicate this clearly.
+    `;
+        const structuredResult = await structuredLlm.invoke(formatPrompt);
+        // Validate that the result is complete (basic check)
+        try {
+            // Use Zod to validate the structured result
+            const validatedResult = outputSchema.parse(structuredResult);
+            // Additional validation for required fields
+            const schemaType = outputSchema;
+            if (schemaType._def && schemaType._def.shape) {
+                for (const [fieldName, fieldSchema] of Object.entries(schemaType._def.shape)) {
+                    const field = fieldSchema;
+                    const isOptional = field.isOptional?.() ?? field._def?.typeName === 'ZodOptional';
+                    const isNullable = field.isNullable?.() ?? field._def?.typeName === 'ZodNullable';
+                    if (!isOptional && !isNullable) {
+                        const value = validatedResult[fieldName];
+                        if (value === null || value === undefined
+                            || (typeof value === 'string' && !value.trim())
+                            || (Array.isArray(value) && value.length === 0)) {
+                            throw new Error(`Required field '${fieldName}' is missing or empty`);
+                        }
+                    }
+                }
+            }
+            return validatedResult;
+        }
+        catch (e) {
+            logger.debug(`Validation details: ${e}`);
+            throw e; // Re-raise to trigger retry logic
+        }
+    }
+    /**
+     * Enhance the query with schema information to make the agent aware of required fields.
+     */
+    _enhanceQueryWithSchema(query, outputSchema) {
+        const schemaFields = [];
+        try {
+            // Get field information from the schema
+            const schemaType = outputSchema;
+            if (schemaType._def && schemaType._def.shape) {
+                for (const [fieldName, fieldSchema] of Object.entries(schemaType._def.shape)) {
+                    const field = fieldSchema;
+                    const description = field._def?.description || field.description || fieldName;
+                    const isOptional = field.isOptional?.() ?? field._def?.typeName === 'ZodOptional';
+                    const isNullable = field.isNullable?.() ?? field._def?.typeName === 'ZodNullable';
+                    schemaFields.push(`- ${fieldName}: ${description} ${(isOptional || isNullable) ? '(optional)' : '(required)'}`);
+                }
+            }
+            const schemaDescription = schemaFields.join('\n');
+            // Enhance the query with schema awareness
+            const enhancedQuery = `
+      ${query}
+      
+      IMPORTANT: Your response must include sufficient information to populate the following structured output:
+      
+      ${schemaDescription}
+      
+      Make sure you gather ALL the required information during your task execution.
+      If any required information is missing, continue working to find it.
+      `;
+            return enhancedQuery;
+        }
+        catch (e) {
+            logger.warn(`Could not extract schema details: ${e}`);
+            return query;
+        }
+    }
 }

package/dist/src/agents/utils/ai_sdk.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AI SDK Integration Utilities
+ *
+ * Utility functions for integrating MCPAgent's streamEvents with Vercel AI SDK.
+ * These utilities help convert stream events to AI SDK compatible formats.
+ */
+import type { StreamEvent } from '@langchain/core/tracers/log_stream';
+/**
+ * Converts streamEvents to AI SDK compatible stream (basic version)
+ * Only yields the actual content tokens from chat model streams
+ */
+export declare function streamEventsToAISDK(streamEvents: AsyncGenerator<StreamEvent, void, void>): AsyncGenerator<string, void, void>;
+/**
+ * Converts async generator to ReadableStream for AI SDK compatibility
+ */
+export declare function createReadableStreamFromGenerator(generator: AsyncGenerator<string, void, void>): ReadableStream<string>;
+/**
+ * Enhanced adapter that includes tool information along with chat content
+ * Yields both content tokens and tool usage notifications
+ */
+export declare function streamEventsToAISDKWithTools(streamEvents: AsyncGenerator<StreamEvent, void, void>): AsyncGenerator<string, void, void>;
+//# sourceMappingURL=ai_sdk.d.ts.map

package/dist/src/agents/utils/ai_sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai_sdk.d.ts","sourceRoot":"","sources":["../../../../src/agents/utils/ai_sdk.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AAErE;;;GAGG;AACH,wBAAuB,mBAAmB,CACxC,YAAY,EAAE,cAAc,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,GACpD,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CASpC;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,GAC5C,cAAc,CAAC,MAAM,CAAC,CAcxB;AAED;;;GAGG;AACH,wBAAuB,4BAA4B,CACjD,YAAY,EAAE,cAAc,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,GACpD,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAqBpC"}

package/dist/src/agents/utils/ai_sdk.js

@@ -0,0 +1,62 @@
+/**
+ * AI SDK Integration Utilities
+ *
+ * Utility functions for integrating MCPAgent's streamEvents with Vercel AI SDK.
+ * These utilities help convert stream events to AI SDK compatible formats.
+ */
+/**
+ * Converts streamEvents to AI SDK compatible stream (basic version)
+ * Only yields the actual content tokens from chat model streams
+ */
+export async function* streamEventsToAISDK(streamEvents) {
+    for await (const event of streamEvents) {
+        if (event.event === 'on_chat_model_stream' && event.data?.chunk?.text) {
+            const textContent = event.data.chunk.text;
+            if (typeof textContent === 'string' && textContent.length > 0) {
+                yield textContent;
+            }
+        }
+    }
+}
+/**
+ * Converts async generator to ReadableStream for AI SDK compatibility
+ */
+export 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);
+            }
+        },
+    });
+}
+/**
+ * Enhanced adapter that includes tool information along with chat content
+ * Yields both content tokens and tool usage notifications
+ */
+export async function* streamEventsToAISDKWithTools(streamEvents) {
+    for await (const event of streamEvents) {
+        switch (event.event) {
+            case 'on_chat_model_stream':
+                if (event.data?.chunk?.text) {
+                    const textContent = event.data.chunk.text;
+                    if (typeof textContent === 'string' && textContent.length > 0) {
+                        yield textContent;
+                    }
+                }
+                break;
+            case 'on_tool_start':
+                yield `\n🔧 Using tool: ${event.name}\n`;
+                break;
+            case 'on_tool_end':
+                yield `\n✅ Tool completed: ${event.name}\n`;
+                break;
+        }
+    }
+}

package/dist/src/agents/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { createReadableStreamFromGenerator, streamEventsToAISDK, streamEventsToAISDKWithTools, } from './ai_sdk.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/agents/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/agents/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EACjC,mBAAmB,EACnB,4BAA4B,GAC7B,MAAM,aAAa,CAAA"}

package/dist/src/agents/utils/index.js

@@ -0,0 +1 @@
+export { createReadableStreamFromGenerator, streamEventsToAISDK, streamEventsToAISDKWithTools, } from './ai_sdk.js';