mcp-use 0.1.20 → 0.3.0

package/dist/src/agents/prompts/system_prompt_builder.js

@@ -1,40 +0,0 @@
-import { SystemMessage } from '@langchain/core/messages';
-export function generateToolDescriptions(tools, disallowedTools) {
-    const disallowedSet = new Set(disallowedTools ?? []);
-    const descriptions = [];
-    for (const tool of tools) {
-        if (disallowedSet.has(tool.name))
-            continue;
-        const escaped = tool.description
-            .replace(/\{/g, '{{')
-            .replace(/\}/g, '}}');
-        descriptions.push(`- ${tool.name}: ${escaped}`);
-    }
-    return descriptions;
-}
-export function buildSystemPromptContent(template, toolDescriptionLines, additionalInstructions) {
-    const block = toolDescriptionLines.join('\n');
-    let content;
-    if (template.includes('{tool_descriptions}')) {
-        content = template.replace('{tool_descriptions}', block);
-    }
-    else {
-        console.warn('`{tool_descriptions}` placeholder not found; appending at end.');
-        content = `${template}\n\nAvailable tools:\n${block}`;
-    }
-    if (additionalInstructions) {
-        content += `\n\n${additionalInstructions}`;
-    }
-    return content;
-}
-export function createSystemMessage(tools, systemPromptTemplate, serverManagerTemplate, useServerManager, disallowedTools, userProvidedPrompt, additionalInstructions) {
-    if (userProvidedPrompt) {
-        return new SystemMessage({ content: userProvidedPrompt });
-    }
-    const template = useServerManager
-        ? serverManagerTemplate
-        : systemPromptTemplate;
-    const toolLines = generateToolDescriptions(tools, disallowedTools);
-    const finalContent = buildSystemPromptContent(template, toolLines, additionalInstructions);
-    return new SystemMessage({ content: finalContent });
-}

package/dist/src/agents/prompts/templates.js

@@ -1,39 +0,0 @@
-export const DEFAULT_SYSTEM_PROMPT_TEMPLATE = `You are a helpful AI assistant.
-You have access to the following tools:
-
-{tool_descriptions}
-
-Use the following format:
-
-Question: the input question you must answer
-Thought: you should always think about what to do
-Action: the action to take, should be one of the available tools
-Action Input: the input to the action
-Observation: the result of the action
-... (this Thought/Action/Action Input/Observation can repeat N times)
-Thought: I now know the final answer
-Final Answer: the final answer to the original input question`;
-export const SERVER_MANAGER_SYSTEM_PROMPT_TEMPLATE = `You are a helpful assistant designed to interact with MCP
- (Model Context Protocol) servers. You can manage connections to different servers and use the tools
- provided by the currently active server.
-
-Important: The available tools change depending on which server is active.
-If a request requires tools not listed below (e.g., file operations, web browsing,
- image manipulation), you MUST first connect to the appropriate server using
- 'connect_to_mcp_server'.
-Use 'list_mcp_servers' to find the relevant server if you are unsure.
-Only after successfully connecting and seeing the new tools listed in
-the response should you attempt to use those server-specific tools.
-Before attempting a task that requires specific tools, you should
-ensure you are connected to the correct server and aware of its
-available tools. If unsure, use 'list_mcp_servers' to see options
-or 'get_active_mcp_server' to check the current connection.
-
-When you connect to a server using 'connect_to_mcp_server',
- you will be informed about the new tools that become available.
-You can then use these server-specific tools in subsequent steps.
-
-Here are the tools *currently* available to you (this list includes server management tools and will
- change when you connect to a server):
-{tool_descriptions}
-`;

package/dist/src/agents/remote.js

@@ -1,264 +0,0 @@
-/**
- * Remote agent implementation for executing agents via API.
- */
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { logger } from '../logging.js';
-// API endpoint constants
-const API_CHATS_ENDPOINT = '/api/v1/chats';
-const API_CHAT_EXECUTE_ENDPOINT = '/api/v1/chats/{chat_id}/execute';
-export class RemoteAgent {
-    agentId;
-    apiKey;
-    baseUrl;
-    chatId = null;
-    constructor(options) {
-        this.agentId = options.agentId;
-        this.baseUrl = options.baseUrl ?? 'https://cloud.mcp-use.com';
-        // Handle API key validation
-        const apiKey = options.apiKey ?? process.env.MCP_USE_API_KEY;
-        if (!apiKey) {
-            throw new Error('API key is required for remote execution. '
-                + 'Please provide it as a parameter or set the MCP_USE_API_KEY environment variable. '
-                + 'You can get an API key from https://cloud.mcp-use.com');
-        }
-        this.apiKey = apiKey;
-    }
-    pydanticToJsonSchema(schema) {
-        /**
-         * Convert a Zod schema to JSON schema for API transmission.
-         */
-        return zodToJsonSchema(schema);
-    }
-    parseStructuredResponse(responseData, outputSchema) {
-        /**
-         * Parse the API response into the structured output format.
-         */
-        let resultData;
-        // Handle different response formats
-        if (typeof responseData === 'object' && responseData !== null) {
-            if ('result' in responseData) {
-                const outerResult = responseData.result;
-                // Check if this is a nested result structure (agent execution response)
-                if (typeof outerResult === 'object' && outerResult !== null && 'result' in outerResult) {
-                    // Extract the actual structured output from the nested result
-                    resultData = outerResult.result;
-                }
-                else {
-                    // Use the outer result directly
-                    resultData = outerResult;
-                }
-            }
-            else {
-                resultData = responseData;
-            }
-        }
-        else if (typeof responseData === 'string') {
-            try {
-                resultData = JSON.parse(responseData);
-            }
-            catch {
-                // If it's not valid JSON, try to create the model from the string content
-                resultData = { content: responseData };
-            }
-        }
-        else {
-            resultData = responseData;
-        }
-        // Parse into the Zod schema
-        try {
-            return outputSchema.parse(resultData);
-        }
-        catch (e) {
-            logger.warn(`Failed to parse structured output: ${e}`);
-            // Fallback: try to parse it as raw content if the schema has a content field
-            const schemaShape = outputSchema._def?.shape();
-            if (schemaShape && 'content' in schemaShape) {
-                return outputSchema.parse({ content: String(resultData) });
-            }
-            throw e;
-        }
-    }
-    async createChatSession() {
-        /**
-         * Create a persistent chat session for the agent.
-         */
-        const chatPayload = {
-            title: `Remote Agent Session - ${this.agentId}`,
-            agent_id: this.agentId,
-            type: 'agent_execution',
-        };
-        const headers = {
-            'Content-Type': 'application/json',
-            'x-api-key': this.apiKey,
-        };
-        const chatUrl = `${this.baseUrl}${API_CHATS_ENDPOINT}`;
-        logger.info(`📝 Creating chat session for agent ${this.agentId}`);
-        try {
-            const response = await fetch(chatUrl, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(chatPayload),
-            });
-            if (!response.ok) {
-                const responseText = await response.text();
-                const statusCode = response.status;
-                if (statusCode === 404) {
-                    throw new Error(`Agent not found: Agent '${this.agentId}' does not exist or you don't have access to it. `
-                        + 'Please verify the agent ID and ensure it exists in your account.');
-                }
-                throw new Error(`Failed to create chat session: ${statusCode} - ${responseText}`);
-            }
-            const chatData = await response.json();
-            const chatId = chatData.id;
-            logger.info(`✅ Chat session created: ${chatId}`);
-            return chatId;
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                throw new TypeError(`Failed to create chat session: ${e.message}`);
-            }
-            throw new Error(`Failed to create chat session: ${String(e)}`);
-        }
-    }
-    async run(query, maxSteps, manageConnector, externalHistory, outputSchema) {
-        /**
-         * Run a query on the remote agent.
-         */
-        if (externalHistory !== undefined) {
-            logger.warn('External history is not yet supported for remote execution');
-        }
-        try {
-            logger.info(`🌐 Executing query on remote agent ${this.agentId}`);
-            // Step 1: Create a chat session for this agent (only if we don't have one)
-            if (this.chatId === null) {
-                this.chatId = await this.createChatSession();
-            }
-            const chatId = this.chatId;
-            // Step 2: Execute the agent within the chat context
-            const executionPayload = {
-                query,
-                max_steps: maxSteps ?? 10,
-            };
-            // Add structured output schema if provided
-            if (outputSchema) {
-                executionPayload.output_schema = this.pydanticToJsonSchema(outputSchema);
-                logger.info(`🔧 Using structured output with schema`);
-            }
-            const headers = {
-                'Content-Type': 'application/json',
-                'x-api-key': this.apiKey,
-            };
-            const executionUrl = `${this.baseUrl}${API_CHAT_EXECUTE_ENDPOINT.replace('{chat_id}', chatId)}`;
-            logger.info(`🚀 Executing agent in chat ${chatId}`);
-            const response = await fetch(executionUrl, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(executionPayload),
-                signal: AbortSignal.timeout(300000), // 5 minute timeout
-            });
-            if (!response.ok) {
-                const responseText = await response.text();
-                const statusCode = response.status;
-                // Provide specific error messages based on status code
-                if (statusCode === 401) {
-                    logger.error(`❌ Authentication failed: ${responseText}`);
-                    throw new Error('Authentication failed: Invalid or missing API key. '
-                        + 'Please check your API key and ensure the MCP_USE_API_KEY environment variable is set correctly.');
-                }
-                else if (statusCode === 403) {
-                    logger.error(`❌ Access forbidden: ${responseText}`);
-                    throw new Error(`Access denied: You don't have permission to execute agent '${this.agentId}'. `
-                        + 'Check if the agent exists and you have the necessary permissions.');
-                }
-                else if (statusCode === 404) {
-                    logger.error(`❌ Agent not found: ${responseText}`);
-                    throw new Error(`Agent not found: Agent '${this.agentId}' does not exist or you don't have access to it. `
-                        + 'Please verify the agent ID and ensure it exists in your account.');
-                }
-                else if (statusCode === 422) {
-                    logger.error(`❌ Validation error: ${responseText}`);
-                    throw new Error(`Request validation failed: ${responseText}. `
-                        + 'Please check your query parameters and output schema format.');
-                }
-                else if (statusCode === 500) {
-                    logger.error(`❌ Server error: ${responseText}`);
-                    throw new Error('Internal server error occurred during agent execution. '
-                        + 'Please try again later or contact support if the issue persists.');
-                }
-                else {
-                    logger.error(`❌ Remote execution failed with status ${statusCode}: ${responseText}`);
-                    throw new Error(`Remote agent execution failed: ${statusCode} - ${responseText}`);
-                }
-            }
-            const result = await response.json();
-            logger.info(`🔧 Response: ${JSON.stringify(result)}`);
-            logger.info('✅ Remote execution completed successfully');
-            // Check for error responses (even with 200 status)
-            if (typeof result === 'object' && result !== null) {
-                // Check for actual error conditions (not just presence of error field)
-                if (result.status === 'error' || result.error !== null) {
-                    const errorMsg = result.error ?? String(result);
-                    logger.error(`❌ Remote agent execution failed: ${errorMsg}`);
-                    throw new Error(`Remote agent execution failed: ${errorMsg}`);
-                }
-                // Check if the response indicates agent initialization failure
-                if (String(result).includes('failed to initialize')) {
-                    logger.error(`❌ Agent initialization failed: ${result}`);
-                    throw new Error('Agent initialization failed on remote server. '
-                        + 'This usually indicates:\n'
-                        + '• Invalid agent configuration (LLM model, system prompt)\n'
-                        + '• Missing or invalid MCP server configurations\n'
-                        + '• Network connectivity issues with MCP servers\n'
-                        + '• Missing environment variables or credentials\n'
-                        + `Raw error: ${result}`);
-                }
-            }
-            // Handle structured output
-            if (outputSchema) {
-                return this.parseStructuredResponse(result, outputSchema);
-            }
-            // Regular string output
-            if (typeof result === 'object' && result !== null && 'result' in result) {
-                return result.result;
-            }
-            else if (typeof result === 'string') {
-                return result;
-            }
-            else {
-                return String(result);
-            }
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                // Check for specific error types
-                if (e.name === 'AbortError') {
-                    logger.error(`❌ Remote execution timed out: ${e}`);
-                    throw new Error('Remote agent execution timed out. The server may be overloaded or the query is taking too long to '
-                        + 'process. Try again or use a simpler query.');
-                }
-                logger.error(`❌ Remote execution error: ${e}`);
-                throw new Error(`Remote agent execution failed: ${e.message}`);
-            }
-            logger.error(`❌ Remote execution error: ${e}`);
-            throw new Error(`Remote agent execution failed: ${String(e)}`);
-        }
-    }
-    async *stream(query, maxSteps, manageConnector, externalHistory, outputSchema) {
-        /**
-         * Stream implementation for remote agent - currently just wraps run.
-         * In the future, this could be enhanced to support actual streaming from the API.
-         */
-        const result = await this.run(query, maxSteps, manageConnector, externalHistory, outputSchema);
-        return result;
-    }
-    async close() {
-        /**
-         * Close the remote agent connection.
-         */
-        logger.info('🔌 Remote agent client closed');
-        // In the future, we might want to delete the chat session here
-        // if (this.chatId) {
-        //   await this.deleteChatSession(this.chatId)
-        // }
-    }
-}

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

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

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

package/dist/src/client.js

@@ -1,133 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { createConnectorFromConfig, loadConfigFile } from './config.js';
-import { logger } from './logging.js';
-import { MCPSession } from './session.js';
-export class MCPClient {
-    config = {};
-    sessions = {};
-    activeSessions = [];
-    constructor(config) {
-        if (config) {
-            if (typeof config === 'string') {
-                this.config = loadConfigFile(config);
-            }
-            else {
-                this.config = config;
-            }
-        }
-    }
-    static fromDict(cfg) {
-        return new MCPClient(cfg);
-    }
-    static fromConfigFile(path) {
-        return new MCPClient(loadConfigFile(path));
-    }
-    addServer(name, serverConfig) {
-        this.config.mcpServers = this.config.mcpServers || {};
-        this.config.mcpServers[name] = serverConfig;
-    }
-    removeServer(name) {
-        if (this.config.mcpServers?.[name]) {
-            delete this.config.mcpServers[name];
-            this.activeSessions = this.activeSessions.filter(n => n !== name);
-        }
-    }
-    getServerNames() {
-        return Object.keys(this.config.mcpServers ?? {});
-    }
-    getServerConfig(name) {
-        return this.config.mcpServers?.[name];
-    }
-    getConfig() {
-        return this.config ?? {};
-    }
-    saveConfig(filepath) {
-        const dir = path.dirname(filepath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        fs.writeFileSync(filepath, JSON.stringify(this.config, null, 2), 'utf-8');
-    }
-    async createSession(serverName, autoInitialize = true) {
-        const servers = this.config.mcpServers ?? {};
-        if (Object.keys(servers).length === 0) {
-            logger.warn('No MCP servers defined in config');
-        }
-        if (!servers[serverName]) {
-            throw new Error(`Server '${serverName}' not found in config`);
-        }
-        const connector = createConnectorFromConfig(servers[serverName]);
-        const session = new MCPSession(connector);
-        if (autoInitialize) {
-            await session.initialize();
-        }
-        this.sessions[serverName] = session;
-        if (!this.activeSessions.includes(serverName)) {
-            this.activeSessions.push(serverName);
-        }
-        return session;
-    }
-    async createAllSessions(autoInitialize = true) {
-        const servers = this.config.mcpServers ?? {};
-        if (Object.keys(servers).length === 0) {
-            logger.warn('No MCP servers defined in config');
-        }
-        for (const name of Object.keys(servers)) {
-            await this.createSession(name, autoInitialize);
-        }
-        return this.sessions;
-    }
-    getSession(serverName) {
-        const session = this.sessions[serverName];
-        // if (!session) {
-        //   throw new Error(`No session exists for server '${serverName}'`)
-        // }
-        if (!session) {
-            return null;
-        }
-        return session;
-    }
-    getAllActiveSessions() {
-        return Object.fromEntries(this.activeSessions.map(n => [n, this.sessions[n]]));
-    }
-    async closeSession(serverName) {
-        const session = this.sessions[serverName];
-        if (!session) {
-            logger.warn(`No session exists for server ${serverName}, nothing to close`);
-            return;
-        }
-        try {
-            logger.debug(`Closing session for server ${serverName}`);
-            await session.disconnect();
-        }
-        catch (e) {
-            logger.error(`Error closing session for server '${serverName}': ${e}`);
-        }
-        finally {
-            delete this.sessions[serverName];
-            this.activeSessions = this.activeSessions.filter(n => n !== serverName);
-        }
-    }
-    async closeAllSessions() {
-        const serverNames = Object.keys(this.sessions);
-        const errors = [];
-        for (const serverName of serverNames) {
-            try {
-                logger.debug(`Closing session for server ${serverName}`);
-                await this.closeSession(serverName);
-            }
-            catch (e) {
-                const errorMsg = `Failed to close session for server '${serverName}': ${e}`;
-                logger.error(errorMsg);
-                errors.push(errorMsg);
-            }
-        }
-        if (errors.length) {
-            logger.error(`Encountered ${errors.length} errors while closing sessions`);
-        }
-        else {
-            logger.debug('All sessions closed successfully');
-        }
-    }
-}

package/dist/src/config.js

@@ -1,34 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { HttpConnector } from './connectors/http.js';
-import { StdioConnector } from './connectors/stdio.js';
-import { WebSocketConnector } from './connectors/websocket.js';
-export function loadConfigFile(filepath) {
-    const raw = readFileSync(filepath, 'utf-8');
-    return JSON.parse(raw);
-}
-export function createConnectorFromConfig(serverConfig) {
-    if ('command' in serverConfig && 'args' in serverConfig) {
-        return new StdioConnector({
-            command: serverConfig.command,
-            args: serverConfig.args,
-            env: serverConfig.env,
-        });
-    }
-    if ('url' in serverConfig) {
-        // HttpConnector automatically handles streamable HTTP with SSE fallback
-        const transport = serverConfig.transport || 'http';
-        return new HttpConnector(serverConfig.url, {
-            headers: serverConfig.headers,
-            authToken: serverConfig.auth_token || serverConfig.authToken,
-            // Only force SSE if explicitly requested
-            preferSse: serverConfig.preferSse || transport === 'sse',
-        });
-    }
-    if ('ws_url' in serverConfig) {
-        return new WebSocketConnector(serverConfig.ws_url, {
-            headers: serverConfig.headers,
-            authToken: serverConfig.auth_token,
-        });
-    }
-    throw new Error('Cannot determine connector type from config');
-}