mcp-use 0.0.1

package/dist/src/agents/mcp_agent.js

@@ -0,0 +1,324 @@
+import { AIMessage, HumanMessage, SystemMessage, } from '@langchain/core/messages';
+import { OutputParserException } from '@langchain/core/output_parsers';
+import { ChatPromptTemplate, MessagesPlaceholder, } from '@langchain/core/prompts';
+import { AgentExecutor, createToolCallingAgent, } from 'langchain/agents';
+import { LangChainAdapter } from '../adapters/langchain_adapter.js';
+import { logger } from '../logging.js';
+import { createSystemMessage } from './prompts/system_prompt_builder.js';
+import { DEFAULT_SYSTEM_PROMPT_TEMPLATE, SERVER_MANAGER_SYSTEM_PROMPT_TEMPLATE } from './prompts/templates.js';
+export class MCPAgent {
+    llm;
+    client;
+    connectors;
+    maxSteps;
+    autoInitialize;
+    memoryEnabled;
+    disallowedTools;
+    useServerManager;
+    verbose;
+    systemPrompt;
+    systemPromptTemplateOverride;
+    additionalInstructions;
+    initialized = false;
+    conversationHistory = [];
+    agentExecutor = null;
+    sessions = {};
+    systemMessage = null;
+    tools = [];
+    adapter;
+    serverManager = null;
+    constructor(options) {
+        this.llm = options.llm;
+        this.client = options.client;
+        this.connectors = options.connectors ?? [];
+        this.maxSteps = options.maxSteps ?? 5;
+        this.autoInitialize = options.autoInitialize ?? false;
+        this.memoryEnabled = options.memoryEnabled ?? true;
+        this.systemPrompt = options.systemPrompt ?? null;
+        this.systemPromptTemplateOverride = options.systemPromptTemplate ?? null;
+        this.additionalInstructions = options.additionalInstructions ?? null;
+        this.disallowedTools = options.disallowedTools ?? [];
+        this.useServerManager = options.useServerManager ?? false;
+        this.verbose = options.verbose ?? false;
+        if (!this.client && this.connectors.length === 0) {
+            throw new Error('Either \'client\' or at least one \'connector\' must be provided.');
+        }
+        if (this.useServerManager) {
+            if (!this.client) {
+                throw new Error('\'client\' must be provided when \'useServerManager\' is true.');
+            }
+            if (options.serverManagerFactory) {
+                this.serverManager = options.serverManagerFactory(this.client);
+            }
+            else {
+                throw new Error('No serverManagerFactory passed to MCPAgent constructor.');
+            }
+        }
+        // Let consumers swap allowed tools dynamically
+        this.adapter = options.adapter ?? new LangChainAdapter(this.disallowedTools);
+    }
+    async initialize() {
+        logger.info('🚀 Initializing MCP agent and connecting to services...');
+        // If using server manager, initialize it
+        if (this.useServerManager && this.serverManager) {
+            await this.serverManager.initialize();
+            // Get server management tools
+            const managementTools = await this.serverManager.getServerManagementTools();
+            this.tools = managementTools;
+            logger.info(`🔧 Server manager mode active with ${managementTools.length} management tools`);
+            // Create the system message based on available tools
+            await this.createSystemMessageFromTools(this.tools);
+        }
+        else {
+            // Standard initialization - if using client, get or create sessions
+            if (this.client) {
+                // First try to get existing sessions
+                this.sessions = await this.client.getAllActiveSessions();
+                logger.info(`🔌 Found ${Object.keys(this.sessions).length} existing sessions`);
+                // If no active sessions exist, create new ones
+                if (Object.keys(this.sessions).length === 0) {
+                    logger.info('🔄 No active sessions found, creating new ones...');
+                    this.sessions = await this.client.createAllSessions();
+                    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);
+                logger.info(`🛠️ Created ${this.tools.length} LangChain tools from client`);
+            }
+            else {
+                // Using direct connector - only establish connection
+                logger.info(`🔗 Connecting to ${this.connectors.length} direct connectors...`);
+                for (const connector of this.connectors) {
+                    if (!connector.isClientConnected) {
+                        await connector.connect();
+                    }
+                }
+                // Create LangChain tools using the adapter with connectors
+                this.tools = await this.adapter.createToolsFromConnectors(this.connectors);
+                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`);
+            // Create the system message based on available tools
+            await this.createSystemMessageFromTools(this.tools);
+        }
+        // Create the agent executor and mark initialized
+        this.agentExecutor = this.createAgent();
+        this.initialized = true;
+        logger.info('✨ Agent initialization complete');
+    }
+    async createSystemMessageFromTools(tools) {
+        const systemPromptTemplate = this.systemPromptTemplateOverride
+            ?? DEFAULT_SYSTEM_PROMPT_TEMPLATE;
+        this.systemMessage = createSystemMessage(tools, systemPromptTemplate, SERVER_MANAGER_SYSTEM_PROMPT_TEMPLATE, this.useServerManager, this.disallowedTools, this.systemPrompt ?? undefined, this.additionalInstructions ?? undefined);
+        if (this.memoryEnabled) {
+            this.conversationHistory = [
+                this.systemMessage,
+                ...this.conversationHistory.filter(m => !(m instanceof SystemMessage)),
+            ];
+        }
+    }
+    createAgent() {
+        const systemContent = this.systemMessage?.content ?? 'You are a helpful assistant.';
+        const prompt = ChatPromptTemplate.fromMessages([
+            ['system', systemContent],
+            new MessagesPlaceholder('chat_history'),
+            ['human', '{input}'],
+            new MessagesPlaceholder('agent_scratchpad'),
+        ]);
+        const agent = createToolCallingAgent({
+            llm: this.llm,
+            tools: this.tools,
+            prompt,
+        });
+        return new AgentExecutor({
+            agent,
+            tools: this.tools,
+            maxIterations: this.maxSteps,
+            verbose: this.verbose,
+            returnIntermediateSteps: true,
+        });
+    }
+    getConversationHistory() {
+        return [...this.conversationHistory];
+    }
+    clearConversationHistory() {
+        this.conversationHistory = this.memoryEnabled && this.systemMessage ? [this.systemMessage] : [];
+    }
+    addToHistory(message) {
+        if (this.memoryEnabled)
+            this.conversationHistory.push(message);
+    }
+    getSystemMessage() {
+        return this.systemMessage;
+    }
+    setSystemMessage(message) {
+        this.systemMessage = new SystemMessage(message);
+        if (this.memoryEnabled) {
+            this.conversationHistory = this.conversationHistory.filter(m => !(m instanceof SystemMessage));
+            this.conversationHistory.unshift(this.systemMessage);
+        }
+        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) {
+            logger.debug('Agent already initialized. Changes will take effect on next initialization.');
+        }
+    }
+    getDisallowedTools() {
+        return this.disallowedTools;
+    }
+    async run(query, maxSteps, manageConnector = true, externalHistory) {
+        let result = '';
+        let initializedHere = false;
+        try {
+            if (manageConnector && !this.initialized) {
+                await this.initialize();
+                initializedHere = true;
+            }
+            else if (!this.initialized && this.autoInitialize) {
+                await this.initialize();
+                initializedHere = true;
+            }
+            if (!this.agentExecutor) {
+                throw new Error('MCP agent failed to initialize');
+            }
+            const steps = maxSteps ?? this.maxSteps;
+            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
+            if (this.memoryEnabled) {
+                this.addToHistory(new HumanMessage(query));
+            }
+            const historyToUse = externalHistory ?? this.conversationHistory;
+            const langchainHistory = [];
+            for (const msg of historyToUse) {
+                if (msg instanceof HumanMessage || msg instanceof AIMessage) {
+                    langchainHistory.push(msg);
+                }
+            }
+            const intermediateSteps = [];
+            const inputs = { input: query, chat_history: langchainHistory };
+            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++) {
+                if (this.useServerManager && this.serverManager) {
+                    const currentTools = await this.serverManager.getAllTools();
+                    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
+                        || [...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;
+                        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);
+                    if (nextStepOutput.returnValues) {
+                        logger.info(`✅ Agent finished at step ${stepNum + 1}`);
+                        result = nextStepOutput.returnValues?.output ?? 'No output generated';
+                        break;
+                    }
+                    const stepArray = nextStepOutput;
+                    intermediateSteps.push(...stepArray);
+                    for (const step of stepArray) {
+                        const { action, observation } = step;
+                        const toolName = action.tool;
+                        let toolInputStr = String(action.toolInput);
+                        if (toolInputStr.length > 100)
+                            toolInputStr = `${toolInputStr.slice(0, 97)}...`;
+                        logger.info(`🔧 Tool call: ${toolName} with input: ${toolInputStr}`);
+                        let outputStr = String(observation);
+                        if (outputStr.length > 100)
+                            outputStr = `${outputStr.slice(0, 97)}...`;
+                        outputStr = outputStr.replace(/\n/g, ' ');
+                        logger.info(`📄 Tool result: ${outputStr}`);
+                    }
+                    // Detect direct return
+                    if (stepArray.length) {
+                        const lastStep = stepArray[stepArray.length - 1];
+                        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';
+                            break;
+                        }
+                    }
+                }
+                catch (e) {
+                    if (e instanceof OutputParserException) {
+                        logger.error(`❌ Output parsing error during step ${stepNum + 1}: ${e}`);
+                        result = `Agent stopped due to a parsing error: ${e}`;
+                        break;
+                    }
+                    logger.error(`❌ Error during agent execution step ${stepNum + 1}: ${e}`);
+                    console.error(e);
+                    result = `Agent stopped due to an error: ${e}`;
+                    break;
+                }
+            }
+            // —–– Post‑loop handling
+            if (!result) {
+                logger.warn(`⚠️ Agent stopped after reaching max iterations (${steps})`);
+                result = `Agent stopped after reaching the maximum number of steps (${steps}).`;
+            }
+            if (this.memoryEnabled) {
+                this.addToHistory(new AIMessage(result));
+            }
+            logger.info('🎉 Agent execution complete');
+            return result;
+        }
+        catch (e) {
+            logger.error(`❌ Error running query: ${e}`);
+            if (initializedHere && manageConnector) {
+                logger.info('🧹 Cleaning up resources after initialization error in run');
+                await this.close();
+            }
+            throw e;
+        }
+        finally {
+            if (manageConnector && !this.client && initializedHere) {
+                logger.info('🧹 Closing agent after query completion');
+                await this.close();
+            }
+        }
+    }
+    async close() {
+        logger.info('🔌 Closing MCPAgent resources…');
+        try {
+            this.agentExecutor = null;
+            this.tools = [];
+            if (this.client) {
+                logger.info('🔄 Closing sessions through client');
+                await this.client.closeAllSessions();
+                this.sessions = {};
+            }
+            else {
+                for (const connector of this.connectors) {
+                    logger.info('🔄 Disconnecting connector');
+                    await connector.disconnect();
+                }
+            }
+            if ('connectorToolMap' in this.adapter) {
+                this.adapter = new LangChainAdapter();
+            }
+        }
+        finally {
+            this.initialized = false;
+            logger.info('👋 Agent closed successfully');
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+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

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

@@ -0,0 +1,152 @@
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { logger } from '../logging.js';
+const ServerActionInputSchema = z.object({
+    serverName: z.string().describe('The name of the MCP server'),
+});
+const DisconnectServerInputSchema = z.object({});
+const ListServersInputSchema = z.object({});
+const CurrentServerInputSchema = z.object({});
+export class ServerManager {
+    client;
+    adapter;
+    activeServer = null;
+    initializedServers = {};
+    serverTools = {};
+    constructor(client, adapter) {
+        this.client = client;
+        this.adapter = adapter;
+    }
+    async initialize() {
+        if (!this.client.getServerNames?.().length) {
+            logger.warning('No MCP servers defined in client configuration');
+        }
+    }
+    async getServerManagementTools() {
+        const listServersTool = new DynamicStructuredTool({
+            name: 'list_mcp_servers',
+            description: 'Lists all available MCP (Model Context Protocol) servers that can be connected to, along with the tools available on each server. Use this tool to discover servers and see what functionalities they offer.',
+            schema: ListServersInputSchema,
+            func: async () => this.listServers(),
+        });
+        const connectServerTool = new DynamicStructuredTool({
+            name: 'connect_to_mcp_server',
+            description: 'Connect to a specific MCP (Model Context Protocol) server to use its tools. Use this tool to connect to a specific server and use its tools.',
+            schema: ServerActionInputSchema,
+            func: async ({ serverName }) => this.connectToServer(serverName),
+        });
+        const getActiveServerTool = new DynamicStructuredTool({
+            name: 'get_active_mcp_server',
+            description: 'Get the currently active MCP (Model Context Protocol) server.',
+            schema: CurrentServerInputSchema,
+            func: async () => this.getActiveServer(),
+        });
+        const disconnectServerTool = new DynamicStructuredTool({
+            name: 'disconnect_from_mcp_server',
+            description: 'Disconnect from the currently active MCP (Model Context Protocol) server.',
+            schema: DisconnectServerInputSchema,
+            func: async () => this.disconnectFromServer(),
+        });
+        return [
+            listServersTool,
+            connectServerTool,
+            getActiveServerTool,
+            disconnectServerTool,
+        ];
+    }
+    async listServers() {
+        const servers = this.client.getServerNames?.() ?? [];
+        if (!servers.length)
+            return 'No MCP servers are currently defined.';
+        let out = 'Available MCP servers:\n';
+        for (const [idx, serverName] of servers.entries()) {
+            const active = serverName === this.activeServer ? ' (ACTIVE)' : '';
+            out += `${idx + 1}. ${serverName}${active}\n`;
+            try {
+                const tools = await this.ensureToolsFetched(serverName);
+                out += tools.length
+                    ? `   Tools: ${tools.map(t => t.name).join(', ')}\n`
+                    : '   Tools: (Could not retrieve or none available)\n';
+            }
+            catch (err) {
+                logger?.error?.(`Error listing tools for server '${serverName}':`, err);
+                out += '   Tools: (Error retrieving tools)\n';
+            }
+        }
+        return out;
+    }
+    async connectToServer(serverName) {
+        const servers = this.client.getServerNames() ?? [];
+        if (!servers.includes(serverName)) {
+            return `Server '${serverName}' not found. Available servers: ${servers.join(', ') || 'none'}`;
+        }
+        if (this.activeServer === serverName) {
+            return `Already connected to MCP server '${serverName}'`;
+        }
+        try {
+            const session = await this.ensureSession(serverName, /* create */ true);
+            this.activeServer = serverName;
+            // Ensure tools cached
+            await this.ensureToolsFetched(serverName, session?.connector);
+            const tools = this.serverTools[serverName] ?? [];
+            const toolDetails = tools
+                .map((t, i) => `${i + 1}. ${t.name}: ${t.description}`)
+                .join('\n');
+            return (`Connected to MCP server '${serverName}'. ${tools.length} tools are now available.${tools.length ? `\nAvailable tools for this server:\n${toolDetails}` : ''}`);
+        }
+        catch (err) {
+            logger.error(`Error connecting to server '${serverName}':`, err);
+            return `Failed to connect to server '${serverName}': ${String(err)}`;
+        }
+    }
+    async getActiveServer() {
+        return this.activeServer
+            ? `Currently active MCP server: ${this.activeServer}`
+            : 'No MCP server is currently active. Use connect_to_mcp_server to connect.';
+    }
+    async disconnectFromServer() {
+        if (!this.activeServer) {
+            return 'No MCP server is currently active, so there\'s nothing to disconnect from.';
+        }
+        const was = this.activeServer;
+        this.activeServer = null;
+        return `Successfully disconnected from MCP server '${was}'.`;
+    }
+    async getActiveServerTools() {
+        return this.activeServer ? this.serverTools[this.activeServer] ?? [] : [];
+    }
+    async getAllTools() {
+        return [...(await this.getServerManagementTools()), ...(await this.getActiveServerTools())];
+    }
+    async ensureSession(serverName, createIfMissing = false) {
+        try {
+            return this.client.getSession(serverName);
+        }
+        catch {
+            if (!createIfMissing)
+                return undefined;
+            return this.client.createSession ? await this.client.createSession(serverName) : undefined;
+        }
+    }
+    async ensureToolsFetched(serverName, connector) {
+        if (this.serverTools[serverName])
+            return this.serverTools[serverName];
+        const session = connector ? { connector } : await this.ensureSession(serverName, true);
+        if (!session) {
+            this.serverTools[serverName] = [];
+            return [];
+        }
+        try {
+            const tools = await this.adapter.createToolsFromConnectors([session.connector]);
+            this.serverTools[serverName] = tools;
+            this.initializedServers[serverName] = true;
+            logger.debug(`Fetched ${tools.length} tools for server '${serverName}'.`);
+            return tools;
+        }
+        catch (err) {
+            logger.warning(`Could not fetch tools for server '${serverName}':`, err);
+            this.serverTools[serverName] = [];
+            return [];
+        }
+    }
+}

package/dist/src/client.js

@@ -0,0 +1,124 @@
+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 ?? {});
+    }
+    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) {
+            throw new Error('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) {
+            throw new Error('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}'`);
+        }
+        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');
+        }
+    }
+}