mcp-use 0.0.4 → 0.0.8

package/dist/src/logging.js

@@ -1,59 +1,92 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { createLogger, format, transports } from 'winston';
-const { combine, timestamp, label, printf } = format;
-let MCP_USE_DEBUG = 0;
-const debugEnv = process.env.DEBUG?.toLowerCase();
-if (debugEnv === '2') {
-    MCP_USE_DEBUG = 2;
-}
-else if (debugEnv === '1') {
-    MCP_USE_DEBUG = 1;
+const { combine, timestamp, label, printf, colorize, splat } = format;
+const DEFAULT_LOGGER_NAME = 'mcp-use';
+function resolveLevel(env) {
+    switch (env?.trim()) {
+        case '2':
+            return 'debug';
+        case '1':
+            return 'info';
+        default:
+            return 'warn';
+    }
 }
-const defaultFormat = printf(({ level, message, label, timestamp }) => `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`);
+const minimalFormatter = printf(({ level, message, label, timestamp }) => {
+    return `${timestamp} [${label}] ${level}: ${message}`;
+});
+const detailedFormatter = printf(({ level, message, label, timestamp }) => {
+    return `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`;
+});
+const emojiFormatter = printf(({ level, message, label, timestamp }) => {
+    return `${timestamp} [${label}] ${level.toUpperCase()}: ${message}`;
+});
 export class Logger {
-    static loggers = {};
-    static getLogger(name = 'mcp_use') {
-        if (!this.loggers[name]) {
-            this.loggers[name] = createLogger({
-                level: 'warn',
-                format: combine(label({ label: name }), timestamp(), defaultFormat),
+    static instances = {};
+    static currentFormat = 'minimal';
+    static get(name = DEFAULT_LOGGER_NAME) {
+        if (!this.instances[name]) {
+            this.instances[name] = createLogger({
+                level: resolveLevel(process.env.DEBUG),
+                format: combine(colorize(), splat(), label({ label: name }), timestamp({ format: 'HH:mm:ss' }), this.getFormatter()),
                 transports: [],
             });
         }
-        return this.loggers[name];
+        return this.instances[name];
     }
-    static configure(level, toConsole = true, toFile) {
-        const root = this.getLogger();
-        if (!level) {
-            level
-                = MCP_USE_DEBUG === 2
-                    ? 'debug'
-                    : MCP_USE_DEBUG === 1 ? 'info' : 'warn';
+    static getFormatter() {
+        switch (this.currentFormat) {
+            case 'minimal':
+                return minimalFormatter;
+            case 'detailed':
+                return detailedFormatter;
+            case 'emoji':
+                return emojiFormatter;
+            default:
+                return minimalFormatter;
         }
-        root.level = level;
+    }
+    static configure(options = {}) {
+        const { level, console = true, file, format = 'minimal' } = options;
+        const resolvedLevel = level ?? resolveLevel(process.env.DEBUG);
+        this.currentFormat = format;
+        const root = this.get();
+        root.level = resolvedLevel;
         root.clear();
-        if (toConsole) {
+        if (console) {
             root.add(new transports.Console());
         }
-        if (toFile) {
-            const dir = path.dirname(toFile);
-            if (dir && !fs.existsSync(dir)) {
+        if (file) {
+            const dir = path.dirname(path.resolve(file));
+            if (!fs.existsSync(dir)) {
                 fs.mkdirSync(dir, { recursive: true });
             }
-            root.add(new transports.File({ filename: toFile }));
+            root.add(new transports.File({ filename: file }));
         }
+        // Update all existing loggers with new format
+        Object.values(this.instances).forEach((logger) => {
+            logger.level = resolvedLevel;
+            logger.format = combine(colorize(), splat(), label({ label: DEFAULT_LOGGER_NAME }), timestamp({ format: 'HH:mm:ss' }), this.getFormatter());
+        });
     }
-    static setDebug(debugLevel = 2) {
-        MCP_USE_DEBUG = debugLevel;
-        process.env.LANGCHAIN_VERBOSE = debugLevel >= 1 ? 'true' : 'false';
-        const newLevel = debugLevel === 2
-            ? 'debug'
-            : debugLevel === 1 ? 'info' : 'warn';
-        Object.values(this.loggers).forEach((log) => {
-            log.level = newLevel;
+    static setDebug(enabled) {
+        let level;
+        if (enabled === 2 || enabled === true)
+            level = 'debug';
+        else if (enabled === 1)
+            level = 'info';
+        else
+            level = 'warn';
+        Object.values(this.instances).forEach((logger) => {
+            logger.level = level;
         });
+        process.env.DEBUG = enabled ? (enabled === true ? '2' : String(enabled)) : '0';
+    }
+    static setFormat(format) {
+        this.currentFormat = format;
+        this.configure({ format });
     }
 }
 Logger.configure();
-export const logger = Logger.getLogger();
+export const logger = Logger.get();

package/dist/src/managers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './server_manager.js';
+export * from './tools/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/managers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/managers/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,kBAAkB,CAAA"}

package/dist/src/managers/index.js

@@ -0,0 +1,2 @@
+export * from './server_manager.js';
+export * from './tools/index.js';

package/dist/src/managers/server_manager.d.ts

@@ -0,0 +1,15 @@
+import type { StructuredToolInterface } from '@langchain/core/tools';
+import type { LangChainAdapter } from '../adapters/langchain_adapter.js';
+import type { MCPClient } from '../client.js';
+export declare class ServerManager {
+    readonly initializedServers: Record<string, boolean>;
+    readonly serverTools: Record<string, StructuredToolInterface[]>;
+    readonly client: MCPClient;
+    readonly adapter: LangChainAdapter;
+    activeServer: string | null;
+    constructor(client: MCPClient, adapter: LangChainAdapter);
+    initialize(): void;
+    prefetchServerTools(): Promise<void>;
+    get tools(): StructuredToolInterface[];
+}
+//# sourceMappingURL=server_manager.d.ts.map

package/dist/src/managers/server_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server_manager.d.ts","sourceRoot":"","sources":["../../../src/managers/server_manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAA;AACxE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAU7C,qBAAa,aAAa;IACxB,SAAgB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAK;IAChE,SAAgB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAAK;IAE3E,SAAgB,MAAM,EAAE,SAAS,CAAA;IACjC,SAAgB,OAAO,EAAE,gBAAgB,CAAA;IAClC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAO;gBAE7B,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,gBAAgB;IAKxD,UAAU,IAAI,IAAI;IAOZ,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAoD1C,IAAI,KAAK,IAAI,uBAAuB,EAAE,CAOrC;CACF"}

package/dist/src/managers/server_manager.js

@@ -0,0 +1,72 @@
+import { isEqual } from 'lodash-es';
+import { logger } from '../logging.js';
+import { AcquireActiveMCPServerTool } from './tools/acquire_active_mcp_server.js';
+import { ConnectMCPServerTool } from './tools/connect_mcp_server.js';
+import { ListMCPServersTool } from './tools/list_mcp_servers.js';
+import { ReleaseMCPServerConnectionTool } from './tools/release_mcp_server_connection.js';
+export class ServerManager {
+    initializedServers = {};
+    serverTools = {};
+    client;
+    adapter;
+    activeServer = null;
+    constructor(client, adapter) {
+        this.client = client;
+        this.adapter = adapter;
+    }
+    initialize() {
+        const serverNames = this.client.getServerNames?.();
+        if (serverNames.length === 0) {
+            logger.warning('No MCP servers defined in client configuration');
+        }
+    }
+    async prefetchServerTools() {
+        const servers = this.client.getServerNames();
+        for (const serverName of servers) {
+            try {
+                let session = null;
+                session = this.client.getSession(serverName);
+                logger.debug(`Using existing session for server '${serverName}' to prefetch tools.`);
+                if (!session) {
+                    session = await this.client.createSession(serverName).catch((createSessionError) => {
+                        logger.warn(`Could not create session for '${serverName}' during prefetch: ${createSessionError}`);
+                        return null;
+                    });
+                    logger.debug(`Temporarily created session for '${serverName}' to prefetch tools.`);
+                }
+                if (session) {
+                    const connector = session.connector;
+                    let tools = [];
+                    try {
+                        tools = await this.adapter.createToolsFromConnectors([connector]);
+                    }
+                    catch (toolFetchError) {
+                        logger.error(`Failed to create tools from connector for server '${serverName}': ${toolFetchError}`);
+                        continue;
+                    }
+                    const cachedTools = this.serverTools[serverName];
+                    const toolsChanged = !cachedTools || !isEqual(cachedTools, tools);
+                    if (toolsChanged) {
+                        this.serverTools[serverName] = tools;
+                        this.initializedServers[serverName] = true;
+                        logger.debug(`Prefetched ${tools.length} tools for server '${serverName}'.`);
+                    }
+                    else {
+                        logger.debug(`Tools for server '${serverName}' unchanged, using cached version.`);
+                    }
+                }
+            }
+            catch (outerError) {
+                logger.error(`Error prefetching tools for server '${serverName}': ${outerError}`);
+            }
+        }
+    }
+    get tools() {
+        return [
+            new ListMCPServersTool(this),
+            new ConnectMCPServerTool(this),
+            new AcquireActiveMCPServerTool(this),
+            new ReleaseMCPServerConnectionTool(this),
+        ];
+    }
+}

package/dist/src/managers/tools/acquire_active_mcp_server.d.ts

@@ -0,0 +1,13 @@
+import type { ServerManager } from '../server_manager.js';
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+declare const PresentActiveServerSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare class AcquireActiveMCPServerTool extends MCPServerTool<typeof PresentActiveServerSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    constructor(manager: ServerManager);
+    _call(): Promise<string>;
+}
+export {};
+//# sourceMappingURL=acquire_active_mcp_server.d.ts.map

package/dist/src/managers/tools/acquire_active_mcp_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquire_active_mcp_server.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/acquire_active_mcp_server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,QAAA,MAAM,yBAAyB,gDAAe,CAAA;AAE9C,qBAAa,0BAA2B,SAAQ,aAAa,CAAC,OAAO,yBAAyB,CAAC;IACpF,IAAI,SAA0B;IAC9B,WAAW,SAAiE;IAC5E,MAAM,iDAA4B;gBAE/B,OAAO,EAAE,aAAa;IAI5B,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;CAO/B"}

package/dist/src/managers/tools/acquire_active_mcp_server.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+const PresentActiveServerSchema = z.object({});
+export class AcquireActiveMCPServerTool extends MCPServerTool {
+    name = 'get_active_mcp_server';
+    description = 'Get the currently active MCP (Model Context Protocol) server';
+    schema = PresentActiveServerSchema;
+    constructor(manager) {
+        super(manager);
+    }
+    async _call() {
+        if (!this.manager.activeServer) {
+            return `No MCP server is currently active. Use connect_to_mcp_server to connect to a server.`;
+        }
+        return `Currently active MCP server: ${this.manager.activeServer}`;
+    }
+}

package/dist/src/managers/tools/base.d.ts

@@ -0,0 +1,24 @@
+import type { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
+import type { ToolParams, ToolRunnableConfig, ToolSchemaBase } from '@langchain/core/tools';
+import type { JSONSchema } from '@langchain/core/utils/json_schema';
+import type z from 'zod';
+import type { ServerManager } from '../server_manager.js';
+import { StructuredTool } from '@langchain/core/tools';
+export type ToolOutputT = any;
+export type SchemaOutputT<T extends ToolSchemaBase> = T extends z.ZodSchema ? z.output<T> : T extends JSONSchema ? unknown : never;
+export interface MCPServerToolOptions extends ToolParams {
+    name?: string;
+    description?: string;
+    returnDirect?: boolean;
+    sandboxId?: string;
+}
+export declare class MCPServerTool<SchemaT extends ToolSchemaBase> extends StructuredTool<SchemaT, SchemaOutputT<SchemaT>> {
+    name: string;
+    description: string;
+    schema: SchemaT;
+    private readonly _manager;
+    constructor(manager: ServerManager);
+    protected _call(_arg: SchemaOutputT<SchemaT>, _runManager?: CallbackManagerForToolRun, _parentConfig?: ToolRunnableConfig): Promise<ToolOutputT>;
+    get manager(): ServerManager;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/src/managers/tools/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC3F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AACnE,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEtD,MAAM,MAAM,WAAW,GAAG,GAAG,CAAA;AAC7B,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,cAAc,IAAI,CAAC,SAAS,CAAC,CAAC,SAAS,GACvE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,GACX,CAAC,SAAS,UAAU,GAClB,OAAO,GACP,KAAK,CAAA;AAEX,MAAM,WAAW,oBAAqB,SAAQ,UAAU;IACtD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,qBAAa,aAAa,CAAC,OAAO,SAAS,cAAc,CAAE,SAAQ,cAAc,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACvG,IAAI,EAAE,MAAM,CAAoB;IAChC,WAAW,EAAE,MAAM,CAAyC;IAC5D,MAAM,EAAG,OAAO,CAAA;IAEzB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;gBAE5B,OAAO,EAAE,aAAa;cAKlB,KAAK,CACnB,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,WAAW,CAAC,EAAE,yBAAyB,EACvC,aAAa,CAAC,EAAE,kBAAkB,GACjC,OAAO,CAAC,WAAW,CAAC;IAIvB,IAAI,OAAO,IAAI,aAAa,CAE3B;CACF"}

package/dist/src/managers/tools/base.js

@@ -0,0 +1,17 @@
+import { StructuredTool } from '@langchain/core/tools';
+export class MCPServerTool extends StructuredTool {
+    name = 'mcp_server_tool';
+    description = 'Base tool for MCP server operations.';
+    schema;
+    _manager;
+    constructor(manager) {
+        super();
+        this._manager = manager;
+    }
+    async _call(_arg, _runManager, _parentConfig) {
+        throw new Error('Method not implemented.');
+    }
+    get manager() {
+        return this._manager;
+    }
+}

package/dist/src/managers/tools/connect_mcp_server.d.ts

@@ -0,0 +1,26 @@
+import type { ServerManager } from '../server_manager.js';
+import type { SchemaOutputT } from './base.js';
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+declare const ConnectMCPServerSchema: z.ZodObject<{
+    serverName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    serverName: string;
+}, {
+    serverName: string;
+}>;
+export declare class ConnectMCPServerTool extends MCPServerTool<typeof ConnectMCPServerSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{
+        serverName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        serverName: string;
+    }, {
+        serverName: string;
+    }>;
+    constructor(manager: ServerManager);
+    _call({ serverName }: SchemaOutputT<typeof ConnectMCPServerSchema>): Promise<string>;
+}
+export {};
+//# sourceMappingURL=connect_mcp_server.d.ts.map

package/dist/src/managers/tools/connect_mcp_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect_mcp_server.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/connect_mcp_server.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,QAAA,MAAM,sBAAsB;;;;;;EAE1B,CAAA;AAEF,qBAAa,oBAAqB,SAAQ,aAAa,CAAC,OAAO,sBAAsB,CAAC;IAC3E,IAAI,SAA0B;IAC9B,WAAW,SAAiJ;IAC5J,MAAM;;;;;;OAAyB;gBAE5B,OAAO,EAAE,aAAa;IAI5B,KAAK,CAAC,EAAE,UAAU,EAAE,EAAE,aAAa,CAAC,OAAO,sBAAsB,CAAC;CAmCzE"}

package/dist/src/managers/tools/connect_mcp_server.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { logger } from '../../logging.js';
+import { MCPServerTool } from './base.js';
+const ConnectMCPServerSchema = z.object({
+    serverName: z.string().describe('The name of the MCP server.'),
+});
+export class ConnectMCPServerTool extends MCPServerTool {
+    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 = ConnectMCPServerSchema;
+    constructor(manager) {
+        super(manager);
+    }
+    async _call({ serverName }) {
+        const serverNames = this.manager.client.getServerNames();
+        if (!serverNames.includes(serverName)) {
+            const available = serverNames.length > 0 ? serverNames.join(', ') : 'none';
+            return `Server '${serverName}' not found. Available servers: ${available}`;
+        }
+        if (this.manager.activeServer === serverName) {
+            return `Already connected to MCP server '${serverName}'`;
+        }
+        try {
+            let session = this.manager.client.getSession(serverName);
+            logger.debug(`Using existing session for server '${serverName}'`);
+            if (!session) {
+                logger.debug(`Creating new session for server '${serverName}'`);
+                session = await this.manager.client.createSession(serverName);
+            }
+            this.manager.activeServer = serverName;
+            if (this.manager.serverTools[serverName]) {
+                const connector = session.connector;
+                const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
+                this.manager.serverTools[serverName] = tools;
+                this.manager.initializedServers[serverName] = true;
+            }
+            const serverTools = this.manager.serverTools[serverName] || [];
+            const numTools = serverTools.length;
+            return `Connected to MCP server '${serverName}'. ${numTools} tools are now available.`;
+        }
+        catch (error) {
+            logger.error(`Error connecting to server '${serverName}': ${String(error)}`);
+            return `Failed to connect to server '${serverName}': ${String(error)}`;
+        }
+    }
+}

package/dist/src/managers/tools/index.d.ts

@@ -0,0 +1,5 @@
+export * from './acquire_active_mcp_server.js';
+export * from './connect_mcp_server.js';
+export * from './list_mcp_servers.js';
+export * from './release_mcp_server_connection.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/managers/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAA;AAC9C,cAAc,yBAAyB,CAAA;AACvC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oCAAoC,CAAA"}

package/dist/src/managers/tools/index.js

@@ -0,0 +1,4 @@
+export * from './acquire_active_mcp_server.js';
+export * from './connect_mcp_server.js';
+export * from './list_mcp_servers.js';
+export * from './release_mcp_server_connection.js';

package/dist/src/managers/tools/list_mcp_servers.d.ts

@@ -0,0 +1,13 @@
+import type { ServerManager } from '../server_manager.js';
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+declare const EnumerateServersSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare class ListMCPServersTool extends MCPServerTool<typeof EnumerateServersSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    constructor(manager: ServerManager);
+    _call(): Promise<string>;
+}
+export {};
+//# sourceMappingURL=list_mcp_servers.d.ts.map

package/dist/src/managers/tools/list_mcp_servers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list_mcp_servers.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/list_mcp_servers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,QAAA,MAAM,sBAAsB,gDAAe,CAAA;AAE3C,qBAAa,kBAAmB,SAAQ,aAAa,CAAC,OAAO,sBAAsB,CAAC;IACzE,IAAI,SAAqB;IACzB,WAAW,SAAiN;IAC5N,MAAM,iDAAyB;gBAE5B,OAAO,EAAE,aAAa;IAI5B,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;CAwB/B"}

package/dist/src/managers/tools/list_mcp_servers.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { logger } from '../../logging.js';
+import { MCPServerTool } from './base.js';
+const EnumerateServersSchema = z.object({});
+export class ListMCPServersTool extends MCPServerTool {
+    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 = EnumerateServersSchema;
+    constructor(manager) {
+        super(manager);
+    }
+    async _call() {
+        const serverNames = this.manager.client.getServerNames();
+        if (serverNames.length === 0) {
+            return `No MCP servers are currently defined.`;
+        }
+        const outputLines = ['Available MCP servers:'];
+        for (const serverName of serverNames) {
+            const isActiveServer = serverName === this.manager.activeServer;
+            const activeFlag = isActiveServer ? ' (ACTIVE)' : '';
+            outputLines.push(`- ${serverName}${activeFlag}`);
+            try {
+                const serverTools = this.manager.serverTools?.[serverName] ?? [];
+                const numberOfTools = Array.isArray(serverTools) ? serverTools.length : 0;
+                outputLines.push(`${numberOfTools} tools available for this server\n`);
+            }
+            catch (error) {
+                logger.error(`Unexpected error listing tools for server '${serverName}': ${String(error)}`);
+            }
+        }
+        return outputLines.join('\n');
+    }
+}

package/dist/src/managers/tools/release_mcp_server_connection.d.ts

@@ -0,0 +1,13 @@
+import type { ServerManager } from '../server_manager.js';
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+declare const ReleaseConnectionSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare class ReleaseMCPServerConnectionTool extends MCPServerTool<typeof ReleaseConnectionSchema> {
+    name: string;
+    description: string;
+    schema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    constructor(manager: ServerManager);
+    _call(): Promise<string>;
+}
+export {};
+//# sourceMappingURL=release_mcp_server_connection.d.ts.map

package/dist/src/managers/tools/release_mcp_server_connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release_mcp_server_connection.d.ts","sourceRoot":"","sources":["../../../../src/managers/tools/release_mcp_server_connection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,QAAA,MAAM,uBAAuB,gDAAe,CAAA;AAE5C,qBAAa,8BAA+B,SAAQ,aAAa,CAAC,OAAO,uBAAuB,CAAC;IACtF,IAAI,SAA+B;IACnC,WAAW,SAA6E;IACxF,MAAM,iDAA0B;gBAE7B,OAAO,EAAE,aAAa;IAI5B,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;CAQ/B"}

package/dist/src/managers/tools/release_mcp_server_connection.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { MCPServerTool } from './base.js';
+const ReleaseConnectionSchema = z.object({});
+export class ReleaseMCPServerConnectionTool extends MCPServerTool {
+    name = 'disconnect_from_mcp_server';
+    description = 'Disconnect from the currently active MCP (Model Context Protocol) server';
+    schema = ReleaseConnectionSchema;
+    constructor(manager) {
+        super(manager);
+    }
+    async _call() {
+        if (!this.manager.activeServer) {
+            return `No MCP server is currently active, so there's nothing to disconnect from.`;
+        }
+        const serverName = this.manager.activeServer;
+        this.manager.activeServer = null;
+        return `Successfully disconnected from MCP server '${serverName}'.`;
+    }
+}

package/dist/src/session.d.ts

@@ -2,18 +2,10 @@ import type { BaseConnector } from './connectors/base.js';
 export declare class MCPSession {
     readonly connector: BaseConnector;
     private autoConnect;
-    private _sessionInfo;
-    private _tools;
     constructor(connector: BaseConnector, autoConnect?: boolean);
-    open(): Promise<this>;
-    close(): Promise<void>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    initialize(): Promise<Record<string, any>>;
+    initialize(): Promise<void>;
     get isConnected(): boolean;
-    get sessionInfo(): Record<string, any> | null;
-    get tools(): Record<string, any>[];
-    discoverTools(): Promise<Record<string, any>[]>;
-    callTool(name: string, args: Record<string, any>): Promise<any>;
 }
 //# sourceMappingURL=session.d.ts.map

package/dist/src/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAGzD,qBAAa,UAAU;IACrB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAmC;IACvD,OAAO,CAAC,MAAM,CAA4B;gBAE9B,SAAS,EAAE,aAAa,EAAE,WAAW,UAAO;IAKlD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAUhD,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,WAAW,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,CAE5C;IAED,IAAI,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAEjC;IAEK,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;IAK/C,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC;CAOtE"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AAEzD,qBAAa,UAAU;IACrB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,OAAO,CAAC,WAAW,CAAS;gBAEhB,SAAS,EAAE,aAAa,EAAE,WAAW,UAAO;IAKlD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAOjC,IAAI,WAAW,IAAI,OAAO,CAEzB;CACF"}

package/dist/src/session.js

@@ -1,20 +1,10 @@
-import { logger } from './logging.js';
 export class MCPSession {
     connector;
     autoConnect;
-    _sessionInfo = null;
-    _tools = [];
     constructor(connector, autoConnect = true) {
         this.connector = connector;
         this.autoConnect = autoConnect;
     }
-    async open() {
-        await this.connect();
-        return this;
-    }
-    async close() {
-        await this.disconnect();
-    }
     async connect() {
         await this.connector.connect();
     }
@@ -25,28 +15,9 @@ export class MCPSession {
         if (!this.isConnected && this.autoConnect) {
             await this.connect();
         }
-        this._sessionInfo = await this.connector.initialize() ?? {};
-        await this.discoverTools();
-        return this._sessionInfo;
+        await this.connector.initialize();
     }
     get isConnected() {
         return this.connector && this.connector.isClientConnected;
     }
-    get sessionInfo() {
-        return this._sessionInfo;
-    }
-    get tools() {
-        return this._tools;
-    }
-    async discoverTools() {
-        this._tools = this.connector.tools;
-        return this._tools;
-    }
-    async callTool(name, args) {
-        if (!this.isConnected && this.autoConnect) {
-            await this.connect();
-        }
-        logger.debug(`MCPSession calling tool '${name}'`);
-        return await this.connector.callTool(name, args);
-    }
 }

package/dist/src/task_managers/sse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/task_managers/sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAA;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAA;AAE5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAE7C,qBAAa,oBAAqB,SAAQ,iBAAiB,CAAC,kBAAkB,CAAC;IAC7E,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAK;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAA2B;IACjD,OAAO,CAAC,UAAU,CAAkC;IAEpD;;;;;OAKG;gBACS,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,yBAAyB;IAM/D;;OAEG;cACa,mBAAmB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAQlE;;OAEG;cACa,eAAe,CAAC,WAAW,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAahF"}
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/task_managers/sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAA;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAA;AAE5E,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAE7C,qBAAa,oBAAqB,SAAQ,iBAAiB,CAAC,kBAAkB,CAAC;IAC7E,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAK;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAA2B;IACjD,OAAO,CAAC,UAAU,CAAkC;IAEpD;;;;;OAKG;gBACS,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,yBAAyB;IAM/D;;OAEG;cACa,mBAAmB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAOlE;;OAEG;cACa,eAAe,CAAC,WAAW,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAahF"}

package/dist/src/task_managers/sse.js

@@ -21,7 +21,6 @@ export class SseConnectionManager extends ConnectionManager {
      */
     async establishConnection() {
         this._transport = new SSEClientTransport(this.url, this.opts);
-        // await this._transport.start()
         logger.debug(`${this.constructor.name} connected successfully`);
         return this._transport;
     }

package/dist/src/task_managers/stdio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../src/task_managers/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAA;AACtF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAEhF,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAE7C,qBAAa,sBAAuB,SAAQ,iBAAiB,CAAC,oBAAoB,CAAC;IACjF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,UAAU,CAAoC;IAEtD;;;;;;OAMG;gBACS,YAAY,EAAE,qBAAqB,EAAE,MAAM,GAAE,QAAyB;IAMlF;;;OAGG;cACa,mBAAmB,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAcpE;;;OAGG;cACa,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;CAalF"}
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../src/task_managers/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAA;AACtF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAA;AAEhF,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAE7C,qBAAa,sBAAuB,SAAQ,iBAAiB,CAAC,oBAAoB,CAAC;IACjF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IACjC,OAAO,CAAC,UAAU,CAAoC;IAEtD;;;;;;OAMG;gBACS,YAAY,EAAE,qBAAqB,EAAE,MAAM,GAAE,QAAyB;IAMlF;;;OAGG;cACa,mBAAmB,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAapE;;;OAGG;cACa,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;CAalF"}

package/dist/src/task_managers/stdio.js

@@ -24,7 +24,6 @@ export class StdioConnectionManager extends ConnectionManager {
     async establishConnection() {
         // Instantiate and start the transport
         this._transport = new StdioClientTransport(this.serverParams);
-        // await this._transport.start()
         // If stderr was piped, forward it to `errlog` for visibility
         if (this._transport.stderr && typeof this._transport.stderr.pipe === 'function') {
             this._transport.stderr.pipe(this.errlog);