mcp-use 0.2.0 → 1.0.0

package/dist/src/logging.js

@@ -1,232 +0,0 @@
-import { createLogger, format, transports } from 'winston';
-// Conditional imports for Node.js-only modules
-async function getNodeModules() {
-    if (typeof process !== 'undefined' && process.platform) {
-        try {
-            // Use dynamic imports for Node.js environments
-            const fs = await import('node:fs');
-            const path = await import('node:path');
-            return { fs: fs.default, path: path.default };
-        }
-        catch {
-            return { fs: null, path: null };
-        }
-    }
-    return { fs: null, path: null };
-}
-const { combine, timestamp, label, printf, colorize, splat } = format;
-const DEFAULT_LOGGER_NAME = 'mcp-use';
-// Environment detection function (similar to telemetry)
-function isNodeJSEnvironment() {
-    try {
-        // Check for Cloudflare Workers specifically
-        if (typeof navigator !== 'undefined' && navigator.userAgent?.includes('Cloudflare-Workers')) {
-            return false;
-        }
-        // Check for other edge runtime indicators
-        if (typeof globalThis.EdgeRuntime !== 'undefined' || typeof globalThis.Deno !== 'undefined') {
-            return false;
-        }
-        // Check for Node.js specific globals that are not available in edge environments
-        const hasNodeGlobals = (typeof process !== 'undefined'
-            && typeof process.platform !== 'undefined'
-            && typeof __dirname !== 'undefined');
-        // Check for Node.js modules
-        const hasNodeModules = (typeof createLogger === 'function');
-        return hasNodeGlobals && hasNodeModules;
-    }
-    catch {
-        return false;
-    }
-}
-// Simple console logger for non-Node.js environments
-class SimpleConsoleLogger {
-    _level;
-    name;
-    constructor(name = DEFAULT_LOGGER_NAME, level = 'info') {
-        this.name = name;
-        this._level = level;
-    }
-    shouldLog(level) {
-        const levels = ['error', 'warn', 'info', 'http', 'verbose', 'debug', 'silly'];
-        const currentIndex = levels.indexOf(this._level);
-        const messageIndex = levels.indexOf(level);
-        return messageIndex <= currentIndex;
-    }
-    formatMessage(level, message) {
-        const timestamp = new Date().toLocaleTimeString('en-US', { hour12: false });
-        return `${timestamp} [${this.name}] ${level}: ${message}`;
-    }
-    error(message) {
-        if (this.shouldLog('error')) {
-            console.error(this.formatMessage('error', message));
-        }
-    }
-    warn(message) {
-        if (this.shouldLog('warn')) {
-            console.warn(this.formatMessage('warn', message));
-        }
-    }
-    info(message) {
-        if (this.shouldLog('info')) {
-            console.info(this.formatMessage('info', message));
-        }
-    }
-    debug(message) {
-        if (this.shouldLog('debug')) {
-            console.debug(this.formatMessage('debug', message));
-        }
-    }
-    http(message) {
-        if (this.shouldLog('http')) {
-            console.log(this.formatMessage('http', message));
-        }
-    }
-    verbose(message) {
-        if (this.shouldLog('verbose')) {
-            console.log(this.formatMessage('verbose', message));
-        }
-    }
-    silly(message) {
-        if (this.shouldLog('silly')) {
-            console.log(this.formatMessage('silly', message));
-        }
-    }
-    // Make it compatible with Winston interface
-    get level() {
-        return this._level;
-    }
-    set level(newLevel) {
-        this._level = newLevel;
-    }
-}
-function resolveLevel(env) {
-    // Safely access environment variables
-    const envValue = (typeof process !== 'undefined' && process.env) ? env : undefined;
-    switch (envValue?.trim()) {
-        case '2':
-            return 'debug';
-        case '1':
-            return 'info';
-        default:
-            return 'info';
-    }
-}
-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 instances = {};
-    static simpleInstances = {};
-    static currentFormat = 'minimal';
-    static get(name = DEFAULT_LOGGER_NAME) {
-        // Use simple console logger in non-Node.js environments
-        if (!isNodeJSEnvironment()) {
-            if (!this.simpleInstances[name]) {
-                const debugEnv = (typeof process !== 'undefined' && process.env?.DEBUG) || undefined;
-                this.simpleInstances[name] = new SimpleConsoleLogger(name, resolveLevel(debugEnv));
-            }
-            return this.simpleInstances[name];
-        }
-        // Use Winston logger in Node.js environments
-        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.instances[name];
-    }
-    static getFormatter() {
-        switch (this.currentFormat) {
-            case 'minimal':
-                return minimalFormatter;
-            case 'detailed':
-                return detailedFormatter;
-            case 'emoji':
-                return emojiFormatter;
-            default:
-                return minimalFormatter;
-        }
-    }
-    static async configure(options = {}) {
-        const { level, console = true, file, format = 'minimal' } = options;
-        const debugEnv = (typeof process !== 'undefined' && process.env?.DEBUG) || undefined;
-        const resolvedLevel = level ?? resolveLevel(debugEnv);
-        this.currentFormat = format;
-        const root = this.get();
-        root.level = resolvedLevel;
-        // Winston-specific configuration for Node.js environments
-        const winstonRoot = root;
-        // For non-Node.js environments, just update the level
-        if (!isNodeJSEnvironment()) {
-            Object.values(this.simpleInstances).forEach((logger) => {
-                logger.level = resolvedLevel;
-            });
-            return;
-        }
-        winstonRoot.clear();
-        if (console) {
-            winstonRoot.add(new transports.Console());
-        }
-        if (file) {
-            const { fs: nodeFs, path: nodePath } = await getNodeModules();
-            if (nodeFs && nodePath) {
-                const dir = nodePath.dirname(nodePath.resolve(file));
-                if (!nodeFs.existsSync(dir)) {
-                    nodeFs.mkdirSync(dir, { recursive: true });
-                }
-                winstonRoot.add(new transports.File({ filename: file }));
-            }
-        }
-        // Update all existing Winston loggers with new format
-        Object.values(this.instances).forEach((logger) => {
-            if (logger && 'format' in logger) {
-                logger.level = resolvedLevel;
-                logger.format = combine(colorize(), splat(), label({ label: DEFAULT_LOGGER_NAME }), timestamp({ format: 'HH:mm:ss' }), this.getFormatter());
-            }
-        });
-    }
-    static setDebug(enabled) {
-        let level;
-        if (enabled === 2 || enabled === true)
-            level = 'debug';
-        else if (enabled === 1)
-            level = 'info';
-        else
-            level = 'info';
-        // Update both simple and Winston loggers
-        Object.values(this.simpleInstances).forEach((logger) => {
-            logger.level = level;
-        });
-        Object.values(this.instances).forEach((logger) => {
-            if (logger) {
-                logger.level = level;
-            }
-        });
-        // Safely set environment variable
-        if (typeof process !== 'undefined' && process.env) {
-            process.env.DEBUG = enabled ? (enabled === true ? '2' : String(enabled)) : '0';
-        }
-    }
-    static setFormat(format) {
-        this.currentFormat = format;
-        this.configure({ format });
-    }
-}
-// Only configure Winston features if in Node.js environment
-if (isNodeJSEnvironment()) {
-    Logger.configure();
-}
-else {
-    // For non-Node.js environments, just initialize with defaults
-    Logger.configure({ console: true });
-}
-export const logger = Logger.get();

package/dist/src/managers/index.js

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

package/dist/src/managers/server_manager.js

@@ -1,106 +0,0 @@
-import { isEqual } from 'lodash-es';
-import { logger } from '../logging.js';
-import { AcquireActiveMCPServerTool } from './tools/acquire_active_mcp_server.js';
-import { AddMCPServerFromConfigTool } from './tools/add_server_from_config.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;
-    overrideManagementTools;
-    constructor(client, adapter, managementTools) {
-        this.client = client;
-        this.adapter = adapter;
-        this.overrideManagementTools = managementTools;
-    }
-    setManagementTools(tools) {
-        this.overrideManagementTools = tools;
-        logger.info(`Overriding default management tools with a new set of ${tools.length} tools.`);
-    }
-    logState(context) {
-        const allServerNames = this.client.getServerNames();
-        const activeSessionNames = Object.keys(this.client.getAllActiveSessions());
-        if (allServerNames.length === 0) {
-            logger.info('Server Manager State: No servers configured.');
-            return;
-        }
-        const tableData = allServerNames.map(name => ({
-            'Server Name': name,
-            'Connected': activeSessionNames.includes(name) ? '✅' : '❌',
-            'Initialized': this.initializedServers[name] ? '✅' : '❌',
-            'Tool Count': this.serverTools[name]?.length ?? 0,
-            'Active': this.activeServer === name ? '✅' : '❌',
-        }));
-        logger.info(`Server Manager State: [${context}]`);
-        console.table(tableData);
-    }
-    initialize() {
-        const serverNames = this.client.getServerNames?.();
-        if (serverNames.length === 0) {
-            logger.warn('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() {
-        if (logger.level === 'debug') {
-            this.logState('Providing tools to agent');
-        }
-        const managementTools = this.overrideManagementTools ?? [
-            new AddMCPServerFromConfigTool(this),
-            new ListMCPServersTool(this),
-            new ConnectMCPServerTool(this),
-            new AcquireActiveMCPServerTool(this),
-            new ReleaseMCPServerConnectionTool(this),
-        ];
-        if (this.activeServer && this.serverTools[this.activeServer]) {
-            const activeTools = this.serverTools[this.activeServer];
-            logger.debug(`Adding ${activeTools.length} tools from active server '${this.activeServer}'`);
-            return [...managementTools, ...activeTools];
-        }
-        return managementTools;
-    }
-}

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

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

@@ -1,40 +0,0 @@
-import { StructuredTool } from 'langchain/tools';
-import { z } from 'zod';
-import { logger } from '../../logging.js';
-export class AddMCPServerFromConfigTool extends StructuredTool {
-    name = 'add_mcp_server_from_config';
-    description = 'Adds a new MCP server to the client from a configuration object and connects to it, making its tools available.';
-    schema = z.object({
-        serverName: z.string().describe('The name for the new MCP server.'),
-        serverConfig: z
-            .any()
-            .describe('The configuration object for the server. This should not include the top-level "mcpServers" key.'),
-    });
-    manager;
-    constructor(manager) {
-        super();
-        this.manager = manager;
-    }
-    async _call({ serverName, serverConfig, }) {
-        try {
-            this.manager.client.addServer(serverName, serverConfig);
-            let result = `Server '${serverName}' added to the client.`;
-            logger.debug(`Connecting to new server '${serverName}' and discovering tools.`);
-            const session = await this.manager.client.createSession(serverName);
-            const connector = session.connector;
-            const tools = await this.manager.adapter.createToolsFromConnectors([connector]);
-            this.manager.serverTools[serverName] = tools;
-            this.manager.initializedServers[serverName] = true;
-            this.manager.activeServer = serverName; // Set as active server
-            const numTools = tools.length;
-            result += ` Session created and connected. '${serverName}' is now the active server with ${numTools} tools available.`;
-            result += `\n\n${tools.map(t => t.name).join('\n')}`;
-            logger.info(result);
-            return result;
-        }
-        catch (e) {
-            logger.error(`Failed to add or connect to server '${serverName}': ${e.message}`);
-            return `Failed to add or connect to server '${serverName}': ${e.message}`;
-        }
-    }
-}

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

@@ -1,17 +0,0 @@
-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.js

@@ -1,46 +0,0 @@
-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.js

@@ -1,5 +0,0 @@
-export * from './acquire_active_mcp_server.js';
-export * from './add_server_from_config.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.js

@@ -1,33 +0,0 @@
-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.js

@@ -1,19 +0,0 @@
-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}'.`;
-    }
-}