@mcp-use/cli 1.0.0 → 1.0.1

package/dist/mcp-service.js

@@ -1,6 +1,7 @@
 import { MCPAgent, MCPClient } from 'mcp-use';
 import { config } from 'dotenv';
 import { CommandHandler } from './commands.js';
+import { Logger } from './logger.js';
 // Load environment variables
 config();
 export class MCPService {
@@ -30,163 +31,48 @@ export class MCPService {
             value: null
         });
     }
-    async initialize(config) {
-        if (this.isInitialized)
+    async initialize() {
+        if (this.isInitialized) {
             return;
-        try {
-            // Load servers from persistent storage and session
-            const storedConfig = this.commandHandler.getCurrentStoredConfig();
-            const storedServers = storedConfig.mcpServers || {};
-            const sessionServers = this.commandHandler.getSessionServers();
-            // Default filesystem server
-            const defaultFilesystemServer = {
-                "command": "npx",
-                "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
-                "env": {}
-            };
-            // Merge stored servers, session servers with default (session servers override persistent ones)
-            const servers = {
-                "filesystem": defaultFilesystemServer,
-                ...storedServers,
-                ...sessionServers
-            };
-            const defaultConfig = {
-                "servers": servers
-            };
-            const mcpConfig = config || defaultConfig;
-            // Initialize MCP client with logging
-            console.log('Initializing MCP client with config:', JSON.stringify(mcpConfig, null, 2));
-            this.client = MCPClient.fromDict(mcpConfig);
-            console.log('MCP client created successfully');
-            // Only initialize agent if we have a configured LLM
-            if (this.commandHandler.isAnyProviderAvailable() && this.commandHandler.getCurrentConfig()) {
-                await this.initializeAgent();
-            }
-            this.isInitialized = true;
-        }
-        catch (error) {
-            console.error('Failed to initialize MCP service:', error);
-            throw error;
         }
+        await this.initializeAgent();
+        this.isInitialized = true;
     }
     async initializeAgent() {
-        if (!this.client) {
-            throw new Error('MCP client not initialized');
-        }
-        try {
-            // Create LLM using command handler
-            console.log('Creating LLM for agent...');
-            const llm = this.commandHandler.createLLM();
-            console.log('LLM created successfully');
-            // Create agent
-            console.log('Creating MCPAgent...');
-            this.agent = new MCPAgent({
-                llm,
-                client: this.client,
-                maxSteps: 20,
-            });
-            console.log('MCPAgent created successfully');
-            // Initialize the agent
-            console.log('Initializing MCP agent with servers...');
-            await this.agent.initialize();
-            console.log('MCP agent initialized successfully');
-            // Wait a bit for servers to start up
-            console.log('Waiting for servers to start...');
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            // Log available tools for debugging
-            try {
-                console.log('Checking for available tools...');
-                const toolsResult = await this.getAvailableTools();
-                if (toolsResult.tools.length > 0) {
-                    console.log('✅ Available MCP tools:', toolsResult.tools.map((t) => t.name || 'unnamed').join(', '));
-                }
-                else {
-                    console.log('❌ No MCP tools found:', toolsResult.error || 'Unknown reason');
-                    // Try to get more info about the client state
-                    console.log('Client details:', this.client);
-                    const clientAny = this.client;
-                    if (clientAny.servers) {
-                        console.log('Client servers:', Object.keys(clientAny.servers));
-                        for (const [name, server] of Object.entries(clientAny.servers)) {
-                            console.log(`Server ${name}:`, server);
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                console.log('❌ Error checking MCP tools:', e);
-            }
-        }
-        catch (error) {
-            console.error('❌ Failed to initialize agent:', error);
-            console.error('Error details:', error);
-            // Try to get more specific error info
-            if (error instanceof Error) {
-                console.error('Error stack:', error.stack);
-            }
-            throw error;
-        }
+        const sessionServers = this.commandHandler.getSessionServers();
+        const llm = this.commandHandler.createLLM();
+        const config = {
+            mcpServers: {
+                ...sessionServers,
+            },
+        };
+        Logger.info('Initializing MCP client with config', { config });
+        const client = new MCPClient(config);
+        // Create agent with memory_enabled=true
+        const agent = new MCPAgent({
+            llm,
+            client,
+            maxSteps: 15,
+            memoryEnabled: true, // Enable built-in conversation memory
+        });
+        Logger.info('Initializing MCP agent', { agent });
+        await agent.initialize();
+        Logger.info('MCP agent initialized', { agent });
+        this.agent = agent;
+        this.client = client;
     }
-    async reinitializeWithNewServers() {
-        try {
-            console.log('🔄 Reinitializing agent with new servers...');
-            // Get updated server configuration
-            const storedConfig = this.commandHandler.getCurrentStoredConfig();
-            const storedServers = storedConfig.mcpServers || {};
-            const sessionServers = this.commandHandler.getSessionServers();
-            console.log('Stored servers:', Object.keys(storedServers));
-            console.log('Session servers:', Object.keys(sessionServers));
-            // Default filesystem server
-            const defaultFilesystemServer = {
-                "command": "npx",
-                "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
-                "env": {}
-            };
-            // Merge stored servers, session servers, with default (session servers override persistent ones)
-            const servers = {
-                "filesystem": defaultFilesystemServer,
-                ...storedServers,
-                ...sessionServers
-            };
-            console.log('Final server configuration:', Object.keys(servers));
-            const newConfig = {
-                "servers": servers
-            };
-            // Reinitialize MCP client with new configuration
-            console.log('Reinitializing MCP client with new config:', JSON.stringify(newConfig, null, 2));
-            this.client = MCPClient.fromDict(newConfig);
-            console.log('MCP client reinitialized successfully');
-            // If we have an agent configured, reinitialize it with the new client
-            if (this.commandHandler.isAnyProviderAvailable() && this.commandHandler.getCurrentConfig()) {
-                console.log('Reinitializing agent...');
-                await this.initializeAgent();
-                console.log('✅ Agent reinitialized successfully');
-            }
-            else {
-                console.log('⚠️ No LLM configured, skipping agent initialization');
-            }
-        }
-        catch (error) {
-            console.error('❌ Failed to reinitialize with new servers:', error);
-            if (error instanceof Error) {
-                console.error('Error stack:', error.stack);
-            }
-            // Don't throw here, just log - the old agent should still work
-        }
+    async refreshAgent() {
+        await this.initializeAgent();
     }
     async sendMessage(message, isApiKeyInput, pendingProvider, pendingModel, isServerConfigInput, serverConfigStep, serverConfig) {
         // Handle server configuration input
         if (isServerConfigInput && serverConfigStep) {
             const commandResult = this.commandHandler.handleServerConfigInput(message.trim(), serverConfigStep, serverConfig);
-            // If servers were added successfully, reinitialize the agent
-            if (commandResult.data?.serversAdded || commandResult.data?.serverAdded) {
-                await this.reinitializeWithNewServers();
-            }
             return {
                 response: commandResult.message,
                 toolCalls: [],
                 isCommand: true,
-                commandResult
+                commandResult,
             };
         }
         // Handle API key input
@@ -200,7 +86,7 @@ export class MCPService {
                 response: commandResult.message,
                 toolCalls: [],
                 isCommand: true,
-                commandResult
+                commandResult,
             };
         }
         // Check if it's a slash command
@@ -228,8 +114,10 @@ export class MCPService {
                         toolsMessage += '🔍 Debug steps:\n';
                         toolsMessage += '1. Check console logs for errors\n';
                         toolsMessage += '2. Test server manually: /test-server <name>\n';
-                        toolsMessage += '3. Ask agent "Which tools do you have?" to see fallback tools\n\n';
-                        toolsMessage += '⚠️ If you see Wolfram/Wikipedia tools, MCP integration failed completely.';
+                        toolsMessage +=
+                            '3. Ask agent "Which tools do you have?" to see fallback tools\n\n';
+                        toolsMessage +=
+                            '⚠️ If you see Wolfram/Wikipedia tools, MCP integration failed completely.';
                     }
                     else {
                         toolsMessage += `✅ Found ${toolsResult.tools.length} MCP tools:\n\n`;
@@ -245,23 +133,18 @@ export class MCPService {
                         response: toolsMessage,
                         toolCalls: [],
                         isCommand: true,
-                        commandResult: { type: 'info', message: toolsMessage }
+                        commandResult: { type: 'info', message: toolsMessage },
                     };
                 }
                 // If the command changed the LLM config, reinitialize the agent
                 if (commandResult.data?.llmConfig) {
                     await this.initializeAgent();
                 }
-                // If servers were added, connected, or disconnected, reinitialize the agent
-                if (commandResult.data?.serversAdded || commandResult.data?.serverAdded ||
-                    commandResult.data?.serverConnected || commandResult.data?.serverDisconnected) {
-                    await this.reinitializeWithNewServers();
-                }
                 return {
                     response: commandResult.message,
                     toolCalls: [],
                     isCommand: true,
-                    commandResult
+                    commandResult,
                 };
             }
             catch (error) {
@@ -269,7 +152,7 @@ export class MCPService {
                     response: `Command error: ${error instanceof Error ? error.message : 'Unknown error'}`,
                     toolCalls: [],
                     isCommand: true,
-                    commandResult: { type: 'error', message: 'Command failed' }
+                    commandResult: { type: 'error', message: 'Command failed' },
                 };
             }
         }
@@ -283,7 +166,9 @@ export class MCPService {
             }
             else {
                 const firstProvider = availableProviders[0];
-                const exampleModel = firstProvider ? this.getExampleModel(firstProvider) : 'model-name';
+                const exampleModel = firstProvider
+                    ? this.getExampleModel(firstProvider)
+                    : 'model-name';
                 return {
                     response: `🔧 No model selected.\n\nAvailable providers: ${availableProviders.join(', ')}\n\nUse /model <provider> <model> to get started.\n\nExample: /model ${firstProvider} ${exampleModel}`,
                     toolCalls: [],
@@ -303,7 +188,10 @@ export class MCPService {
             };
         }
         catch (error) {
-            console.error('Error sending message to MCP agent:', error);
+            Logger.error('Error sending message to MCP agent', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
             throw error;
         }
     }
@@ -312,7 +200,7 @@ export class MCPService {
             openai: 'gpt-4o-mini',
             anthropic: 'claude-3-5-sonnet-20241022',
             google: 'gemini-1.5-pro',
-            mistral: 'mistral-large-latest'
+            mistral: 'mistral-large-latest',
         };
         return examples[provider] || 'model-name';
     }
@@ -331,8 +219,14 @@ export class MCPService {
             yield { done: true };
         }
         catch (error) {
-            console.error('Error streaming message:', error);
-            yield { content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`, done: true };
+            Logger.error('Error streaming message:', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            yield {
+                content: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                done: true,
+            };
         }
     }
     isReady() {
@@ -365,71 +259,68 @@ export class MCPService {
     }
     getConnectedServers() {
         const sessionServers = this.commandHandler.getSessionServers();
-        // Always include filesystem as it's built-in and always connected
-        const servers = ['filesystem'];
-        // Add only connected servers (those in sessionServers)
         const connectedCustomServers = Object.keys(sessionServers);
-        servers.push(...connectedCustomServers);
-        return servers;
+        return connectedCustomServers;
     }
     async getAvailableTools() {
+        Logger.debug('Getting available tools - starting check');
         if (!this.agent) {
-            return { tools: [], error: 'No agent initialized' };
+            const error = 'No agent initialized';
+            Logger.warn('Tools check failed - no agent', { error });
+            return { tools: [], error };
         }
         try {
-            // Try to access the MCP client directly to get available tools
             if (this.client) {
-                // Try to call listTools on the client
-                const clientAny = this.client;
-                if (typeof clientAny.listTools === 'function') {
-                    const tools = await clientAny.listTools();
-                    return { tools: tools || [] };
-                }
-                // Try to access servers and their tools
-                if (clientAny.servers) {
-                    const allTools = [];
-                    for (const [serverName, server] of Object.entries(clientAny.servers)) {
-                        const serverAny = server;
-                        if (serverAny.listTools && typeof serverAny.listTools === 'function') {
-                            try {
-                                const serverTools = await serverAny.listTools();
-                                if (Array.isArray(serverTools)) {
-                                    allTools.push(...serverTools.map(tool => ({ ...tool, server: serverName })));
-                                }
-                            }
-                            catch (e) {
-                                console.log(`Failed to get tools from server ${serverName}:`, e);
-                            }
+                Logger.debug('Checking client for tools', {
+                    clientType: this.client.constructor.name,
+                    clientKeys: Object.keys(this.client),
+                });
+                let allTools = [];
+                // Iterate through sessions
+                for (const [sessionName, session] of Object.entries(this.client.getAllActiveSessions())) {
+                    Logger.debug(`Checking session: ${sessionName}`, {
+                        sessionType: typeof session,
+                        sessionConstructor: session?.constructor?.name,
+                        sessionKeys: session ? Object.keys(session) : [],
+                    });
+                    // Try to get tools from connector
+                    if (session.connector) {
+                        Logger.debug(`Checking connector in session ${sessionName}`, {
+                            connectorType: typeof session.connector,
+                            connectorConstructor: session.connector?.constructor?.name,
+                            connectorKeys: session.connector
+                                ? Object.keys(session.connector)
+                                : [],
+                        });
+                        if (session.connector.tools &&
+                            Array.isArray(session.connector.tools)) {
+                            Logger.debug(`Found tools in connector for session ${sessionName}`, {
+                                toolCount: session.connector.tools.length,
+                                tools: session.connector.tools,
+                            });
+                            allTools.push(...session.connector.tools.map((tool) => ({
+                                ...tool,
+                                session: sessionName,
+                            })));
                         }
                     }
-                    if (allTools.length > 0) {
-                        return { tools: allTools };
-                    }
                 }
-            }
-            // Try the agent directly (with type assertions to avoid TS errors)
-            const agentAny = this.agent;
-            if (typeof agentAny.listTools === 'function') {
-                const tools = await agentAny.listTools();
-                return { tools: tools || [] };
-            }
-            else if (typeof agentAny.getTools === 'function') {
-                const tools = await agentAny.getTools();
-                return { tools: tools || [] };
-            }
-            else if (agentAny.tools) {
-                return { tools: agentAny.tools || [] };
-            }
-            else {
-                return { tools: [], error: 'Agent and client do not expose tool listing functionality' };
+                return { tools: allTools };
             }
         }
         catch (error) {
+            const errorMsg = `Failed to get tools: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            Logger.error('Tools check failed with exception', {
+                error: errorMsg,
+                stack: error instanceof Error ? error.stack : undefined,
+            });
             return {
                 tools: [],
-                error: `Failed to get tools: ${error instanceof Error ? error.message : 'Unknown error'}`
+                error: errorMsg,
             };
         }
+        // Default return if client doesn't exist
+        return { tools: [], error: 'No client available' };
     }
 }
 // Export a singleton instance

package/dist/services/agent-service.d.ts

@@ -0,0 +1,56 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolCall, CommandResult } from '../types.js';
+import { LLMService } from './llm-service.js';
+export interface AgentServiceDeps {
+    llmService: LLMService;
+}
+export declare class AgentService {
+    private agent;
+    private client;
+    private llmService;
+    constructor(deps: AgentServiceDeps);
+    isReady(): boolean;
+    sendMessage(message: string): AsyncGenerator<{
+        response?: string;
+        toolCalls?: ToolCall[];
+        thought?: string;
+    }>;
+    getAvailableTools(): Promise<{
+        tools: Tool[];
+        error?: string;
+    }>;
+    /**
+     * Handles the /tools command to list available MCP tools.
+     * @returns A CommandResult indicating that tools should be checked
+     */
+    handleListToolsCommand(): CommandResult;
+    /**
+     * Gets all active MCP sessions.
+     * @returns Object with session names as keys
+     */
+    getActiveSessions(): Record<string, any>;
+    /**
+     * Checks if a specific server is connected.
+     * @param serverName - Name of the server to check
+     * @returns True if the server is connected
+     */
+    isServerConnected(serverName: string): boolean;
+    /**
+     * Gets the list of connected server names.
+     * @returns Array of connected server names
+     */
+    getConnectedServerNames(): string[];
+    /**
+     * Connects a new MCP server without reinitializing the entire agent.
+     * @param serverName - Name of the server to connect
+     * @param serverConfig - Configuration for the server
+     * @returns Promise that resolves when connected
+     */
+    connectServer(serverName: string, serverConfig: any): Promise<void>;
+    /**
+     * Disconnects an MCP server without reinitializing the entire agent.
+     * @param serverName - Name of the server to disconnect
+     * @returns Promise that resolves when disconnected
+     */
+    disconnectServer(serverName: string): Promise<void>;
+}

package/dist/services/agent-service.js

@@ -0,0 +1,203 @@
+import { MCPAgent, MCPClient } from 'mcp-use';
+import { Logger } from '../logger.js';
+export class AgentService {
+    constructor(deps) {
+        Object.defineProperty(this, "agent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "llmService", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.llmService = deps.llmService;
+        this.client = new MCPClient({});
+        this.agent = new MCPAgent({
+            llm: this.llmService.createLLM(),
+            client: this.client,
+            maxSteps: 15,
+            memoryEnabled: true, // Enable built-in conversation memory
+        });
+    }
+    isReady() {
+        return this.agent !== null;
+    }
+    async *sendMessage(message) {
+        if (!this.agent) {
+            throw new Error('Agent not initialized');
+        }
+        try {
+            // The stream method yields AgentSteps for each tool call and returns the final string response.
+            const generator = this.agent.stream(message);
+            let result = await generator.next();
+            while (!result.done) {
+                const agentStep = result.value; // This is of type AgentStep
+                if (agentStep.action) {
+                    // The 'log' contains the "Thought:" part.
+                    if (agentStep.action.log) {
+                        yield { thought: agentStep.action.log };
+                    }
+                    // Map AgentStep to our internal ToolCall type
+                    const toolCall = {
+                        id: `${agentStep.action.tool}-${Date.now()}`, // Create a simple unique ID
+                        role: 'tool',
+                        tool_name: agentStep.action.tool,
+                        tool_input: agentStep.action.toolInput,
+                        tool_output: agentStep.observation,
+                    };
+                    yield { toolCalls: [toolCall] };
+                }
+                result = await generator.next();
+            }
+            // When the generator is done, the final response is in result.value
+            const finalResponse = result.value;
+            if (finalResponse) {
+                yield { response: finalResponse };
+            }
+        }
+        catch (error) {
+            Logger.error('Error sending message to MCP agent', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            throw error;
+        }
+    }
+    async getAvailableTools() {
+        Logger.debug('Getting available tools - starting check');
+        if (!this.client) {
+            const error = 'No agent/client initialized';
+            Logger.warn('Tools check failed - no client', { error });
+            return { tools: [], error };
+        }
+        try {
+            let allTools = [];
+            const sessions = this.client.getAllActiveSessions();
+            for (const [sessionName, session] of Object.entries(sessions)) {
+                if (session.connector?.tools &&
+                    Array.isArray(session.connector.tools)) {
+                    Logger.debug(`Found tools in connector for session ${sessionName}`, {
+                        toolCount: session.connector.tools.length,
+                    });
+                    const sessionTools = session.connector.tools.map((tool) => ({
+                        ...tool,
+                        session: sessionName,
+                    }));
+                    allTools.push(...sessionTools);
+                }
+            }
+            return { tools: allTools };
+        }
+        catch (error) {
+            const errorMsg = `Failed to get tools: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            Logger.error('Tools check failed with exception', {
+                error: errorMsg,
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            return {
+                tools: [],
+                error: errorMsg,
+            };
+        }
+    }
+    /**
+     * Handles the /tools command to list available MCP tools.
+     * @returns A CommandResult indicating that tools should be checked
+     */
+    handleListToolsCommand() {
+        return {
+            type: 'info',
+            message: '🔧 Checking available MCP tools...\n\nThis command will show tools available from connected MCP servers.\nNote: This requires the MCP service to provide tool listing functionality.',
+            data: { checkTools: true },
+        };
+    }
+    /**
+     * Gets all active MCP sessions.
+     * @returns Object with session names as keys
+     */
+    getActiveSessions() {
+        if (!this.client) {
+            return {};
+        }
+        try {
+            return this.client.getAllActiveSessions();
+        }
+        catch (error) {
+            Logger.error('Failed to get active sessions', {
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            return {};
+        }
+    }
+    /**
+     * Checks if a specific server is connected.
+     * @param serverName - Name of the server to check
+     * @returns True if the server is connected
+     */
+    isServerConnected(serverName) {
+        const sessions = this.getActiveSessions();
+        return !!sessions[serverName];
+    }
+    /**
+     * Gets the list of connected server names.
+     * @returns Array of connected server names
+     */
+    getConnectedServerNames() {
+        return Object.keys(this.getActiveSessions());
+    }
+    /**
+     * Connects a new MCP server without reinitializing the entire agent.
+     * @param serverName - Name of the server to connect
+     * @param serverConfig - Configuration for the server
+     * @returns Promise that resolves when connected
+     */
+    async connectServer(serverName, serverConfig) {
+        if (!this.agent || !this.client) {
+            throw new Error('Agent not initialized');
+        }
+        if (this.isServerConnected(serverName)) {
+            throw new Error(`Server "${serverName}" is already connected`);
+        }
+        Logger.info('Connecting to server', serverName);
+        const currentConfig = this.client.getConfig();
+        const newConfig = {
+            mcpServers: {
+                ...currentConfig["mcpServers"],
+                [serverName]: serverConfig,
+            }
+        };
+        this.client = new MCPClient(newConfig);
+        this.agent = new MCPAgent({
+            llm: this.llmService.createLLM(),
+            client: this.client,
+            maxSteps: 30,
+            memoryEnabled: true, // Enable built-in conversation memory
+        });
+        await this.agent?.initialize();
+    }
+    /**
+     * Disconnects an MCP server without reinitializing the entire agent.
+     * @param serverName - Name of the server to disconnect
+     * @returns Promise that resolves when disconnected
+     */
+    async disconnectServer(serverName) {
+        if (!this.agent || !this.client) {
+            throw new Error('Agent not initialized');
+        }
+        if (!this.isServerConnected(serverName)) {
+            throw new Error(`Server "${serverName}" is not connected`);
+        }
+        this.client?.removeServer(serverName);
+        this.agent?.initialize();
+    }
+}