mcp-use 0.1.20 → 0.3.0

package/dist/src/connectors/base.js

@@ -1,143 +0,0 @@
-import { logger } from '../logging.js';
-/**
- * Base class for MCP connectors.
- */
-export class BaseConnector {
-    client = null;
-    connectionManager = null;
-    toolsCache = null;
-    connected = false;
-    opts;
-    constructor(opts = {}) {
-        this.opts = opts;
-    }
-    /** Disconnect and release resources. */
-    async disconnect() {
-        if (!this.connected) {
-            logger.debug('Not connected to MCP implementation');
-            return;
-        }
-        logger.debug('Disconnecting from MCP implementation');
-        await this.cleanupResources();
-        this.connected = false;
-        logger.debug('Disconnected from MCP implementation');
-    }
-    /** Check if the client is connected */
-    get isClientConnected() {
-        return this.client != null;
-    }
-    /**
-     * Initialise the MCP session **after** `connect()` has succeeded.
-     *
-     * In the SDK, `Client.connect(transport)` automatically performs the
-     * protocol‑level `initialize` handshake, so we only need to cache the list of
-     * tools and expose some server info.
-     */
-    async initialize(defaultRequestOptions = this.opts.defaultRequestOptions ?? {}) {
-        if (!this.client) {
-            throw new Error('MCP client is not connected');
-        }
-        logger.debug('Caching server capabilities & tools');
-        // Cache server capabilities for callers who need them.
-        const capabilities = this.client.getServerCapabilities();
-        // Fetch and cache tools
-        const listToolsRes = await this.client.listTools(undefined, defaultRequestOptions);
-        this.toolsCache = (listToolsRes.tools ?? []);
-        logger.debug(`Fetched ${this.toolsCache.length} tools from server`);
-        return capabilities;
-    }
-    /** Lazily expose the cached tools list. */
-    get tools() {
-        if (!this.toolsCache) {
-            throw new Error('MCP client is not initialized; call initialize() first');
-        }
-        return this.toolsCache;
-    }
-    /** Call a tool on the server. */
-    async callTool(name, args, options) {
-        if (!this.client) {
-            throw new Error('MCP client is not connected');
-        }
-        logger.debug(`Calling tool '${name}' with args`, args);
-        const res = await this.client.callTool({ name, arguments: args }, undefined, options);
-        logger.debug(`Tool '${name}' returned`, res);
-        return res;
-    }
-    /** List resources from the server. */
-    async listResources(options) {
-        if (!this.client) {
-            throw new Error('MCP client is not connected');
-        }
-        logger.debug('Listing resources');
-        return await this.client.listResources(undefined, options);
-    }
-    /** Read a resource by URI. */
-    async readResource(uri, options) {
-        if (!this.client) {
-            throw new Error('MCP client is not connected');
-        }
-        logger.debug(`Reading resource ${uri}`);
-        const res = await this.client.readResource({ uri }, options);
-        return { content: res.content, mimeType: res.mimeType };
-    }
-    async listPrompts() {
-        if (!this.client) {
-            throw new Error('MCP client is not connected');
-        }
-        logger.debug('Listing prompt');
-        return await this.client.listPrompts();
-    }
-    async getPrompt(name, args) {
-        if (!this.client) {
-            throw new Error('MCP client is not connected');
-        }
-        logger.debug(`Getting prompt ${name}`);
-        return await this.client.getPrompt({ name, arguments: args });
-    }
-    /** Send a raw request through the client. */
-    async request(method, params = null, options) {
-        if (!this.client) {
-            throw new Error('MCP client is not connected');
-        }
-        logger.debug(`Sending raw request '${method}' with params`, params);
-        return await this.client.request({ method, params: params ?? {} }, undefined, options);
-    }
-    /**
-     * Helper to tear down the client & connection manager safely.
-     */
-    async cleanupResources() {
-        const issues = [];
-        if (this.client) {
-            try {
-                if (typeof this.client.close === 'function') {
-                    await this.client.close();
-                }
-            }
-            catch (e) {
-                const msg = `Error closing client: ${e}`;
-                logger.warn(msg);
-                issues.push(msg);
-            }
-            finally {
-                this.client = null;
-            }
-        }
-        if (this.connectionManager) {
-            try {
-                await this.connectionManager.stop();
-            }
-            catch (e) {
-                const msg = `Error stopping connection manager: ${e}`;
-                logger.warn(msg);
-                issues.push(msg);
-            }
-            finally {
-                this.connectionManager = null;
-            }
-        }
-        this.toolsCache = null;
-        if (issues.length) {
-            logger.warn(`Resource cleanup finished with ${issues.length} issue(s)`);
-        }
-    }
-}

package/dist/src/connectors/http.js

@@ -1,150 +0,0 @@
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StreamableHTTPError } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { logger } from '../logging.js';
-import { SseConnectionManager } from '../task_managers/sse.js';
-import { StreamableHttpConnectionManager } from '../task_managers/streamable_http.js';
-import { BaseConnector } from './base.js';
-export class HttpConnector extends BaseConnector {
-    baseUrl;
-    headers;
-    timeout;
-    sseReadTimeout;
-    clientInfo;
-    preferSse;
-    transportType = null;
-    constructor(baseUrl, opts = {}) {
-        super(opts);
-        this.baseUrl = baseUrl.replace(/\/$/, '');
-        this.headers = { ...(opts.headers ?? {}) };
-        if (opts.authToken) {
-            this.headers.Authorization = `Bearer ${opts.authToken}`;
-        }
-        this.timeout = opts.timeout ?? 5;
-        this.sseReadTimeout = opts.sseReadTimeout ?? 60 * 5;
-        this.clientInfo = opts.clientInfo ?? { name: 'http-connector', version: '1.0.0' };
-        this.preferSse = opts.preferSse ?? false;
-    }
-    /** Establish connection to the MCP implementation via HTTP (streamable or SSE). */
-    async connect() {
-        if (this.connected) {
-            logger.debug('Already connected to MCP implementation');
-            return;
-        }
-        const baseUrl = this.baseUrl;
-        // If preferSse is set, skip directly to SSE
-        if (this.preferSse) {
-            logger.debug(`Connecting to MCP implementation via HTTP/SSE: ${baseUrl}`);
-            await this.connectWithSse(baseUrl);
-            return;
-        }
-        // Try streamable HTTP first, then fall back to SSE
-        logger.debug(`Connecting to MCP implementation via HTTP: ${baseUrl}`);
-        try {
-            // Try streamable HTTP transport first
-            logger.debug('Attempting streamable HTTP transport...');
-            await this.connectWithStreamableHttp(baseUrl);
-        }
-        catch (err) {
-            // Check if this is a 4xx error that indicates we should try SSE fallback
-            let fallbackReason = 'Unknown error';
-            if (err instanceof StreamableHTTPError) {
-                if (err.code === 404 || err.code === 405) {
-                    fallbackReason = `Server returned ${err.code} - server likely doesn't support streamable HTTP`;
-                    logger.debug(fallbackReason);
-                }
-                else {
-                    fallbackReason = `Server returned ${err.code}: ${err.message}`;
-                    logger.debug(fallbackReason);
-                }
-            }
-            else if (err instanceof Error) {
-                // Check for 404/405 in error message as fallback detection
-                const errorStr = err.toString();
-                if (errorStr.includes('405 Method Not Allowed') || errorStr.includes('404 Not Found')) {
-                    fallbackReason = 'Server doesn\'t support streamable HTTP (405/404)';
-                    logger.debug(fallbackReason);
-                }
-                else {
-                    fallbackReason = `Streamable HTTP failed: ${err.message}`;
-                    logger.debug(fallbackReason);
-                }
-            }
-            // Always try SSE fallback for maximum compatibility
-            logger.debug('Falling back to SSE transport...');
-            try {
-                await this.connectWithSse(baseUrl);
-            }
-            catch (sseErr) {
-                logger.error(`Failed to connect with both transports:`);
-                logger.error(`  Streamable HTTP: ${fallbackReason}`);
-                logger.error(`  SSE: ${sseErr}`);
-                await this.cleanupResources();
-                throw new Error('Could not connect to server with any available transport');
-            }
-        }
-    }
-    async connectWithStreamableHttp(baseUrl) {
-        try {
-            // Create and start the streamable HTTP connection manager
-            this.connectionManager = new StreamableHttpConnectionManager(baseUrl, {
-                requestInit: {
-                    headers: this.headers,
-                },
-                // Pass through timeout and other options
-                reconnectionOptions: {
-                    maxReconnectionDelay: 30000,
-                    initialReconnectionDelay: 1000,
-                    reconnectionDelayGrowFactor: 1.5,
-                    maxRetries: 2,
-                },
-            });
-            const transport = await this.connectionManager.start();
-            // Create and connect the client
-            this.client = new Client(this.clientInfo, this.opts.clientOptions);
-            await this.client.connect(transport);
-            this.connected = true;
-            this.transportType = 'streamable-http';
-            logger.debug(`Successfully connected to MCP implementation via streamable HTTP: ${baseUrl}`);
-        }
-        catch (err) {
-            // Clean up partial resources before throwing
-            await this.cleanupResources();
-            throw err;
-        }
-    }
-    async connectWithSse(baseUrl) {
-        try {
-            // Create and start the SSE connection manager
-            this.connectionManager = new SseConnectionManager(baseUrl, {
-                requestInit: {
-                    headers: this.headers,
-                },
-            });
-            const transport = await this.connectionManager.start();
-            // Create and connect the client
-            this.client = new Client(this.clientInfo, this.opts.clientOptions);
-            await this.client.connect(transport);
-            this.connected = true;
-            this.transportType = 'sse';
-            logger.debug(`Successfully connected to MCP implementation via HTTP/SSE: ${baseUrl}`);
-        }
-        catch (err) {
-            // Clean up partial resources before throwing
-            await this.cleanupResources();
-            throw err;
-        }
-    }
-    get publicIdentifier() {
-        return {
-            type: 'http',
-            url: this.baseUrl,
-            transport: this.transportType || 'unknown',
-        };
-    }
-    /**
-     * Get the transport type being used (streamable-http or sse)
-     */
-    getTransportType() {
-        return this.transportType;
-    }
-}

package/dist/src/connectors/index.js

@@ -1,4 +0,0 @@
-export { BaseConnector } from './base.js';
-export { HttpConnector } from './http.js';
-export { StdioConnector } from './stdio.js';
-export { WebSocketConnector } from './websocket.js';

package/dist/src/connectors/stdio.js

@@ -1,68 +0,0 @@
-import process from 'node:process';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { logger } from '../logging.js';
-import { StdioConnectionManager } from '../task_managers/stdio.js';
-import { BaseConnector } from './base.js';
-export class StdioConnector extends BaseConnector {
-    command;
-    args;
-    env;
-    errlog;
-    clientInfo;
-    constructor({ command = 'npx', args = [], env, errlog = process.stderr, ...rest } = {}) {
-        super(rest);
-        this.command = command;
-        this.args = args;
-        this.env = env;
-        this.errlog = errlog;
-        this.clientInfo = rest.clientInfo ?? { name: 'stdio-connector', version: '1.0.0' };
-    }
-    /** Establish connection to the MCP implementation. */
-    async connect() {
-        if (this.connected) {
-            logger.debug('Already connected to MCP implementation');
-            return;
-        }
-        logger.debug(`Connecting to MCP implementation via stdio: ${this.command}`);
-        try {
-            // 1. Build server parameters for the transport
-            // Merge env with process.env, filtering out undefined values
-            let mergedEnv;
-            if (this.env) {
-                mergedEnv = {};
-                // First add process.env values (excluding undefined)
-                for (const [key, value] of Object.entries(process.env)) {
-                    if (value !== undefined) {
-                        mergedEnv[key] = value;
-                    }
-                }
-                // Then override with provided env
-                Object.assign(mergedEnv, this.env);
-            }
-            const serverParams = {
-                command: this.command,
-                args: this.args,
-                env: mergedEnv,
-            };
-            // 2. Start the connection manager -> returns a live transport
-            this.connectionManager = new StdioConnectionManager(serverParams, this.errlog);
-            const transport = await this.connectionManager.start();
-            // 3. Create & connect the MCP client
-            this.client = new Client(this.clientInfo, this.opts.clientOptions);
-            await this.client.connect(transport);
-            this.connected = true;
-            logger.debug(`Successfully connected to MCP implementation: ${this.command}`);
-        }
-        catch (err) {
-            logger.error(`Failed to connect to MCP implementation: ${err}`);
-            await this.cleanupResources();
-            throw err;
-        }
-    }
-    get publicIdentifier() {
-        return {
-            'type': 'stdio',
-            'command&args': `${this.command} ${this.args.join(' ')}`,
-        };
-    }
-}

package/dist/src/connectors/websocket.js

@@ -1,157 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../logging.js';
-import { WebSocketConnectionManager } from '../task_managers/websocket.js';
-import { BaseConnector } from './base.js';
-export class WebSocketConnector extends BaseConnector {
-    url;
-    headers;
-    connectionManager = null;
-    ws = null;
-    receiverTask = null;
-    pending = new Map();
-    toolsCache = null;
-    constructor(url, opts = {}) {
-        super();
-        this.url = url;
-        this.headers = { ...(opts.headers ?? {}) };
-        if (opts.authToken)
-            this.headers.Authorization = `Bearer ${opts.authToken}`;
-    }
-    async connect() {
-        if (this.connected) {
-            logger.debug('Already connected to MCP implementation');
-            return;
-        }
-        logger.debug(`Connecting via WebSocket: ${this.url}`);
-        try {
-            this.connectionManager = new WebSocketConnectionManager(this.url, this.headers);
-            this.ws = await this.connectionManager.start();
-            this.receiverTask = this.receiveLoop();
-            this.connected = true;
-            logger.debug('WebSocket connected successfully');
-        }
-        catch (e) {
-            logger.error(`Failed to connect: ${e}`);
-            await this.cleanupResources();
-            throw e;
-        }
-    }
-    async disconnect() {
-        if (!this.connected) {
-            logger.debug('Not connected to MCP implementation');
-            return;
-        }
-        logger.debug('Disconnecting …');
-        await this.cleanupResources();
-        this.connected = false;
-    }
-    sendRequest(method, params = null) {
-        if (!this.ws)
-            throw new Error('WebSocket is not connected');
-        const id = uuidv4();
-        const payload = JSON.stringify({ id, method, params: params ?? {} });
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
-            this.ws.send(payload, (err) => {
-                if (err) {
-                    this.pending.delete(id);
-                    reject(err);
-                }
-            });
-        });
-    }
-    async receiveLoop() {
-        if (!this.ws)
-            return;
-        const socket = this.ws; // Node.ws or browser WS
-        const onMessage = (msg) => {
-            let data;
-            try {
-                data = JSON.parse(msg.data ?? msg);
-            }
-            catch (e) {
-                logger.warn('Received non‑JSON frame', e);
-                return;
-            }
-            const id = data.id;
-            if (id && this.pending.has(id)) {
-                const { resolve, reject } = this.pending.get(id);
-                this.pending.delete(id);
-                if ('result' in data)
-                    resolve(data.result);
-                else if ('error' in data)
-                    reject(data.error);
-            }
-            else {
-                logger.debug('Received unsolicited message', data);
-            }
-        };
-        socket.addEventListener ? socket.addEventListener('message', onMessage) : socket.on('message', onMessage);
-        // keep promise pending until close
-        return new Promise((resolve) => {
-            const onClose = () => {
-                socket.removeEventListener ? socket.removeEventListener('message', onMessage) : socket.off('message', onMessage);
-                this.rejectAll(new Error('WebSocket closed'));
-                resolve();
-            };
-            socket.addEventListener ? socket.addEventListener('close', onClose) : socket.on('close', onClose);
-        });
-    }
-    rejectAll(err) {
-        for (const { reject } of this.pending.values())
-            reject(err);
-        this.pending.clear();
-    }
-    async initialize() {
-        logger.debug('Initializing MCP session over WebSocket');
-        const result = await this.sendRequest('initialize');
-        const toolsList = await this.listTools();
-        this.toolsCache = toolsList.map(t => t);
-        logger.debug(`Initialized with ${this.toolsCache.length} tools`);
-        return result;
-    }
-    async listTools() {
-        const res = await this.sendRequest('tools/list');
-        return res.tools ?? [];
-    }
-    async callTool(name, args) {
-        return await this.sendRequest('tools/call', { name, arguments: args });
-    }
-    async listResources() {
-        const resources = await this.sendRequest('resources/list');
-        return { resources: Array.isArray(resources) ? resources : [] };
-    }
-    async readResource(uri) {
-        const res = await this.sendRequest('resources/read', { uri });
-        return { content: res.content, mimeType: res.mimeType };
-    }
-    async request(method, params = null) {
-        return await this.sendRequest(method, params);
-    }
-    get tools() {
-        if (!this.toolsCache)
-            throw new Error('MCP client is not initialized');
-        return this.toolsCache;
-    }
-    async cleanupResources() {
-        // Stop receiver
-        if (this.receiverTask)
-            await this.receiverTask.catch(() => { });
-        this.receiverTask = null;
-        // Reject pending
-        this.rejectAll(new Error('WebSocket disconnected'));
-        // Stop connection manager → closes socket
-        if (this.connectionManager) {
-            await this.connectionManager.stop();
-            this.connectionManager = null;
-            this.ws = null;
-        }
-        this.toolsCache = null;
-    }
-    get publicIdentifier() {
-        return {
-            type: 'websocket',
-            url: this.url,
-        };
-    }
-}