mcp-use 0.2.0 → 0.3.0

package/dist/src/observability/manager.js

@@ -1,199 +0,0 @@
-/**
- * Observability callbacks manager for MCP-use.
- *
- * This module provides a centralized manager for handling observability callbacks
- * from various platforms (Langfuse, Laminar, etc.) in a clean and extensible way.
- */
-import { logger } from '../logging.js';
-export class ObservabilityManager {
-    customCallbacks;
-    availableHandlers = [];
-    handlerNames = [];
-    initialized = false;
-    verbose;
-    observe;
-    agentId;
-    metadata;
-    metadataProvider;
-    tagsProvider;
-    constructor(config = {}) {
-        this.customCallbacks = config.customCallbacks;
-        this.verbose = config.verbose ?? false;
-        this.observe = config.observe ?? true;
-        this.agentId = config.agentId;
-        this.metadata = config.metadata;
-        this.metadataProvider = config.metadataProvider;
-        this.tagsProvider = config.tagsProvider;
-    }
-    /**
-     * Collect all available observability handlers from configured platforms.
-     */
-    async collectAvailableHandlers() {
-        if (this.initialized) {
-            return;
-        }
-        // Import handlers lazily to avoid circular imports
-        try {
-            const { langfuseHandler, langfuseInitPromise } = await import('./langfuse.js');
-            // If we have an agent ID, metadata, or providers, we need to reinitialize Langfuse
-            if (this.agentId || this.metadata || this.metadataProvider || this.tagsProvider) {
-                // Import the initialization function directly
-                const { initializeLangfuse } = await import('./langfuse.js');
-                await initializeLangfuse(this.agentId, this.metadata, this.metadataProvider, this.tagsProvider);
-                logger.debug(`ObservabilityManager: Reinitialized Langfuse with agent ID: ${this.agentId}, metadata: ${JSON.stringify(this.metadata)}`);
-            }
-            else {
-                // Wait for existing initialization to complete
-                const initPromise = langfuseInitPromise();
-                if (initPromise) {
-                    await initPromise;
-                }
-            }
-            const handler = langfuseHandler();
-            if (handler) {
-                this.availableHandlers.push(handler);
-                this.handlerNames.push('Langfuse');
-                logger.debug('ObservabilityManager: Langfuse handler available');
-            }
-        }
-        catch {
-            logger.debug('ObservabilityManager: Langfuse module not available');
-        }
-        // Future: Add more platforms here...
-        this.initialized = true;
-    }
-    /**
-     * Get the list of callbacks to use.
-     * @returns List of callbacks - either custom callbacks if provided, or all available observability handlers.
-     */
-    async getCallbacks() {
-        // If observability is disabled, return empty array
-        if (!this.observe) {
-            logger.debug('ObservabilityManager: Observability disabled via observe=false');
-            return [];
-        }
-        // If custom callbacks were provided, use those
-        if (this.customCallbacks) {
-            logger.debug(`ObservabilityManager: Using ${this.customCallbacks.length} custom callbacks`);
-            return this.customCallbacks;
-        }
-        // Otherwise, collect and return all available handlers
-        await this.collectAvailableHandlers();
-        if (this.availableHandlers.length > 0) {
-            logger.debug(`ObservabilityManager: Using ${this.availableHandlers.length} handlers`);
-        }
-        else {
-            logger.debug('ObservabilityManager: No callbacks configured');
-        }
-        return this.availableHandlers;
-    }
-    /**
-     * Get the names of available handlers.
-     * @returns List of handler names (e.g., ["Langfuse", "Laminar"])
-     */
-    async getHandlerNames() {
-        // If observability is disabled, return empty array
-        if (!this.observe) {
-            return [];
-        }
-        if (this.customCallbacks) {
-            // For custom callbacks, try to get their class names
-            return this.customCallbacks.map(cb => cb.constructor.name);
-        }
-        await this.collectAvailableHandlers();
-        return this.handlerNames;
-    }
-    /**
-     * Check if any callbacks are available.
-     * @returns True if callbacks are available, False otherwise.
-     */
-    async hasCallbacks() {
-        // If observability is disabled, no callbacks are available
-        if (!this.observe) {
-            return false;
-        }
-        const callbacks = await this.getCallbacks();
-        return callbacks.length > 0;
-    }
-    /**
-     * Add a callback to the custom callbacks list.
-     * @param callback The callback to add.
-     */
-    addCallback(callback) {
-        if (!this.customCallbacks) {
-            this.customCallbacks = [];
-        }
-        this.customCallbacks.push(callback);
-        logger.debug(`ObservabilityManager: Added custom callback: ${callback.constructor.name}`);
-    }
-    /**
-     * Clear all custom callbacks.
-     */
-    clearCallbacks() {
-        this.customCallbacks = [];
-        logger.debug('ObservabilityManager: Cleared all custom callbacks');
-    }
-    /**
-     * Flush all pending traces to observability platforms.
-     * Important for serverless environments and short-lived processes.
-     */
-    async flush() {
-        // Flush Langfuse traces
-        const callbacks = await this.getCallbacks();
-        for (const callback of callbacks) {
-            if ('flushAsync' in callback && typeof callback.flushAsync === 'function') {
-                await callback.flushAsync();
-            }
-        }
-        logger.debug('ObservabilityManager: All traces flushed');
-    }
-    /**
-     * Shutdown all handlers gracefully (for serverless environments).
-     */
-    async shutdown() {
-        // Flush before shutdown
-        await this.flush();
-        // Shutdown other callbacks
-        const callbacks = await this.getCallbacks();
-        for (const callback of callbacks) {
-            // Check if the callback has a shutdown method (like Langfuse)
-            if ('shutdownAsync' in callback && typeof callback.shutdownAsync === 'function') {
-                await callback.shutdownAsync();
-            }
-            else if ('shutdown' in callback && typeof callback.shutdown === 'function') {
-                await callback.shutdown();
-            }
-        }
-        logger.debug('ObservabilityManager: All handlers shutdown');
-    }
-    /**
-     * String representation of the ObservabilityManager.
-     */
-    toString() {
-        const names = this.handlerNames;
-        if (names.length > 0) {
-            return `ObservabilityManager(handlers=${names.join(', ')})`;
-        }
-        return 'ObservabilityManager(no handlers)';
-    }
-}
-// Singleton instance for easy access
-let defaultManager = null;
-/**
- * Get the default ObservabilityManager instance.
- * @returns The default ObservabilityManager instance (singleton).
- */
-export function getDefaultManager() {
-    if (!defaultManager) {
-        defaultManager = new ObservabilityManager();
-    }
-    return defaultManager;
-}
-/**
- * Create a new ObservabilityManager instance.
- * @param config Configuration options
- * @returns A new ObservabilityManager instance.
- */
-export function createManager(config = {}) {
-    return new ObservabilityManager(config);
-}

package/dist/src/observability/types.js

@@ -1,4 +0,0 @@
-/**
- * Type definitions for observability module
- */
-export {};

package/dist/src/session.js

@@ -1,23 +0,0 @@
-export class MCPSession {
-    connector;
-    autoConnect;
-    constructor(connector, autoConnect = true) {
-        this.connector = connector;
-        this.autoConnect = autoConnect;
-    }
-    async connect() {
-        await this.connector.connect();
-    }
-    async disconnect() {
-        await this.connector.disconnect();
-    }
-    async initialize() {
-        if (!this.isConnected && this.autoConnect) {
-            await this.connect();
-        }
-        await this.connector.initialize();
-    }
-    get isConnected() {
-        return this.connector && this.connector.isClientConnected;
-    }
-}

package/dist/src/task_managers/base.js

@@ -1,127 +0,0 @@
-import { logger } from '../logging.js';
-export class ConnectionManager {
-    _readyPromise;
-    _readyResolver;
-    _donePromise;
-    _doneResolver;
-    _exception = null;
-    _connection = null;
-    _task = null;
-    _abortController = null;
-    constructor() {
-        this.reset();
-    }
-    /**
-     * Start the connection manager and establish a connection.
-     *
-     * @returns The established connection.
-     * @throws If the connection cannot be established.
-     */
-    async start() {
-        // Reset internal state before starting
-        this.reset();
-        logger.debug(`Starting ${this.constructor.name}`);
-        // Kick off the background task that manages the connection
-        this._task = this.connectionTask();
-        // Wait until the connection is ready or an error occurs
-        await this._readyPromise;
-        // If an exception occurred during startup, re‑throw it
-        if (this._exception) {
-            throw this._exception;
-        }
-        if (this._connection === null) {
-            throw new Error('Connection was not established');
-        }
-        return this._connection;
-    }
-    /**
-     * Stop the connection manager and close the connection.
-     */
-    async stop() {
-        if (this._task && this._abortController) {
-            logger.debug(`Cancelling ${this.constructor.name} task`);
-            this._abortController.abort();
-            try {
-                await this._task;
-            }
-            catch (e) {
-                if (e instanceof Error && e.name === 'AbortError') {
-                    logger.debug(`${this.constructor.name} task aborted successfully`);
-                }
-                else {
-                    logger.warn(`Error stopping ${this.constructor.name} task: ${e}`);
-                }
-            }
-        }
-        // Wait until the connection cleanup has completed
-        await this._donePromise;
-        logger.debug(`${this.constructor.name} task completed`);
-    }
-    /**
-     * Reset all internal state.
-     */
-    reset() {
-        this._readyPromise = new Promise(res => (this._readyResolver = res));
-        this._donePromise = new Promise(res => (this._doneResolver = res));
-        this._exception = null;
-        this._connection = null;
-        this._task = null;
-        this._abortController = new AbortController();
-    }
-    /**
-     * The background task responsible for establishing and maintaining the
-     * connection until it is cancelled.
-     */
-    async connectionTask() {
-        logger.debug(`Running ${this.constructor.name} task`);
-        try {
-            // Establish the connection
-            this._connection = await this.establishConnection();
-            logger.debug(`${this.constructor.name} connected successfully`);
-            // Signal that the connection is ready
-            this._readyResolver();
-            // Keep the task alive until it is cancelled
-            await this.waitForAbort();
-        }
-        catch (err) {
-            this._exception = err;
-            logger.error(`Error in ${this.constructor.name} task: ${err}`);
-            // Ensure the ready promise resolves so that start() can handle the error
-            this._readyResolver();
-        }
-        finally {
-            // Clean up the connection if it was established
-            if (this._connection !== null) {
-                try {
-                    await this.closeConnection(this._connection);
-                }
-                catch (closeErr) {
-                    logger.warn(`Error closing connection in ${this.constructor.name}: ${closeErr}`);
-                }
-                this._connection = null;
-            }
-            // Signal that cleanup is finished
-            this._doneResolver();
-        }
-    }
-    /**
-     * Helper that returns a promise which resolves when the abort signal fires.
-     */
-    async waitForAbort() {
-        return new Promise((_resolve, _reject) => {
-            if (!this._abortController) {
-                return;
-            }
-            const signal = this._abortController.signal;
-            if (signal.aborted) {
-                _resolve();
-                return;
-            }
-            const onAbort = () => {
-                signal.removeEventListener('abort', onAbort);
-                _resolve();
-            };
-            signal.addEventListener('abort', onAbort);
-        });
-    }
-}

package/dist/src/task_managers/index.js

@@ -1,5 +0,0 @@
-export { ConnectionManager } from './base.js';
-export { SseConnectionManager } from './sse.js';
-export { StdioConnectionManager } from './stdio.js';
-export { StreamableHttpConnectionManager } from './streamable_http.js';
-export { WebSocketConnectionManager } from './websocket.js';

package/dist/src/task_managers/sse.js

@@ -1,43 +0,0 @@
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
-import { logger } from '../logging.js';
-import { ConnectionManager } from './base.js';
-export class SseConnectionManager extends ConnectionManager {
-    url;
-    opts;
-    _transport = null;
-    /**
-     * Create an SSE connection manager.
-     *
-     * @param url  The SSE endpoint URL.
-     * @param opts Optional transport options (auth, headers, etc.).
-     */
-    constructor(url, opts) {
-        super();
-        this.url = typeof url === 'string' ? new URL(url) : url;
-        this.opts = opts;
-    }
-    /**
-     * Spawn a new `SSEClientTransport` and start the connection.
-     */
-    async establishConnection() {
-        this._transport = new SSEClientTransport(this.url, this.opts);
-        logger.debug(`${this.constructor.name} connected successfully`);
-        return this._transport;
-    }
-    /**
-     * Close the underlying transport and clean up resources.
-     */
-    async closeConnection(_connection) {
-        if (this._transport) {
-            try {
-                await this._transport.close();
-            }
-            catch (e) {
-                logger.warn(`Error closing SSE transport: ${e}`);
-            }
-            finally {
-                this._transport = null;
-            }
-        }
-    }
-}

package/dist/src/task_managers/stdio.js

@@ -1,51 +0,0 @@
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { logger } from '../logging.js';
-import { ConnectionManager } from './base.js';
-export class StdioConnectionManager extends ConnectionManager {
-    serverParams;
-    errlog;
-    _transport = null;
-    /**
-     * Create a new stdio connection manager.
-     *
-     * @param serverParams Parameters for the stdio server process.
-     * @param errlog       Stream to which the server's stderr should be piped.
-     *                     Defaults to `process.stderr`.
-     */
-    constructor(serverParams, errlog = process.stderr) {
-        super();
-        this.serverParams = serverParams;
-        this.errlog = errlog;
-    }
-    /**
-     * Establish the stdio connection by spawning the server process and starting
-     * the SDK's transport. Returns the live `StdioClientTransport` instance.
-     */
-    async establishConnection() {
-        // Instantiate and start the transport
-        this._transport = new StdioClientTransport(this.serverParams);
-        // 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);
-        }
-        logger.debug(`${this.constructor.name} connected successfully`);
-        return this._transport;
-    }
-    /**
-     * Close the stdio connection, making sure the transport cleans up the child
-     * process and associated resources.
-     */
-    async closeConnection(_connection) {
-        if (this._transport) {
-            try {
-                await this._transport.close();
-            }
-            catch (e) {
-                logger.warn(`Error closing stdio transport: ${e}`);
-            }
-            finally {
-                this._transport = null;
-            }
-        }
-    }
-}

package/dist/src/task_managers/streamable_http.js

@@ -1,50 +0,0 @@
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-import { logger } from '../logging.js';
-import { ConnectionManager } from './base.js';
-export class StreamableHttpConnectionManager extends ConnectionManager {
-    url;
-    opts;
-    _transport = null;
-    /**
-     * Create a Streamable HTTP connection manager.
-     *
-     * @param url  The HTTP endpoint URL.
-     * @param opts Optional transport options (auth, headers, etc.).
-     */
-    constructor(url, opts) {
-        super();
-        this.url = typeof url === 'string' ? new URL(url) : url;
-        this.opts = opts;
-    }
-    /**
-     * Spawn a new `StreamableHTTPClientTransport` and return it.
-     * The Client.connect() method will handle starting the transport.
-     */
-    async establishConnection() {
-        this._transport = new StreamableHTTPClientTransport(this.url, this.opts);
-        logger.debug(`${this.constructor.name} created successfully`);
-        return this._transport;
-    }
-    /**
-     * Close the underlying transport and clean up resources.
-     */
-    async closeConnection(_connection) {
-        if (this._transport) {
-            try {
-                await this._transport.close();
-            }
-            catch (e) {
-                logger.warn(`Error closing Streamable HTTP transport: ${e}`);
-            }
-            finally {
-                this._transport = null;
-            }
-        }
-    }
-    /**
-     * Get the session ID from the transport if available.
-     */
-    get sessionId() {
-        return this._transport?.sessionId;
-    }
-}

package/dist/src/task_managers/websocket.js

@@ -1,67 +0,0 @@
-import WS from 'ws';
-import { logger } from '../logging.js';
-import { ConnectionManager } from './base.js';
-export class WebSocketConnectionManager extends ConnectionManager {
-    url;
-    headers;
-    _ws = null;
-    /**
-     * @param url     The WebSocket URL to connect to.
-     * @param headers Optional headers to include in the connection handshake.
-     */
-    constructor(url, headers = {}) {
-        super();
-        this.url = url;
-        this.headers = headers;
-    }
-    /** Establish a WebSocket connection and wait until it is open. */
-    async establishConnection() {
-        logger.debug(`Connecting to WebSocket: ${this.url}`);
-        return new Promise((resolve, reject) => {
-            const ws = new WS(this.url, { headers: this.headers });
-            this._ws = ws;
-            const onOpen = () => {
-                // eslint-disable-next-line ts/no-use-before-define
-                cleanup();
-                logger.debug('WebSocket connected successfully');
-                resolve(ws);
-            };
-            const onError = (err) => {
-                // eslint-disable-next-line ts/no-use-before-define
-                cleanup();
-                logger.error(`Failed to connect to WebSocket: ${err}`);
-                reject(err);
-            };
-            const cleanup = () => {
-                ws.off('open', onOpen);
-                ws.off('error', onError);
-            };
-            // Register listeners (browser vs Node API differences handled)
-            ws.on('open', onOpen);
-            ws.on('error', onError);
-        });
-    }
-    /** Cleanly close the WebSocket connection. */
-    async closeConnection(connection) {
-        logger.debug('Closing WebSocket connection');
-        return new Promise((resolve) => {
-            const onClose = () => {
-                connection.off('close', onClose);
-                this._ws = null;
-                resolve();
-            };
-            if (connection.readyState === WS.CLOSED) {
-                onClose();
-                return;
-            }
-            connection.on('close', onClose);
-            try {
-                connection.close();
-            }
-            catch (e) {
-                logger.warn(`Error closing WebSocket connection: ${e}`);
-                onClose();
-            }
-        });
-    }
-}

package/dist/src/telemetry/events.js

@@ -1,44 +0,0 @@
-export class BaseTelemetryEvent {
-}
-export class MCPAgentExecutionEvent extends BaseTelemetryEvent {
-    data;
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-    get name() {
-        return 'mcp_agent_execution';
-    }
-    get properties() {
-        return {
-            // Core execution info
-            execution_method: this.data.executionMethod,
-            query: this.data.query,
-            query_length: this.data.query.length,
-            success: this.data.success,
-            // Agent configuration
-            model_provider: this.data.modelProvider,
-            model_name: this.data.modelName,
-            server_count: this.data.serverCount,
-            server_identifiers: this.data.serverIdentifiers,
-            total_tools_available: this.data.totalToolsAvailable,
-            tools_available_names: this.data.toolsAvailableNames,
-            max_steps_configured: this.data.maxStepsConfigured,
-            memory_enabled: this.data.memoryEnabled,
-            use_server_manager: this.data.useServerManager,
-            // Execution parameters (always include, even if null)
-            max_steps_used: this.data.maxStepsUsed,
-            manage_connector: this.data.manageConnector,
-            external_history_used: this.data.externalHistoryUsed,
-            // Execution results (always include, even if null)
-            steps_taken: this.data.stepsTaken ?? null,
-            tools_used_count: this.data.toolsUsedCount ?? null,
-            tools_used_names: this.data.toolsUsedNames ?? null,
-            response: this.data.response ?? null,
-            response_length: this.data.response ? this.data.response.length : null,
-            execution_time_ms: this.data.executionTimeMs ?? null,
-            error_type: this.data.errorType ?? null,
-            conversation_history_length: this.data.conversationHistoryLength ?? null,
-        };
-    }
-}

package/dist/src/telemetry/index.js

@@ -1,8 +0,0 @@
-import { Telemetry } from './telemetry.js';
-export { BaseTelemetryEvent, MCPAgentExecutionEvent } from './events.js';
-export { Telemetry } from './telemetry.js';
-export { extractModelInfo, getModelName, getModelProvider, getPackageVersion } from './utils.js';
-// Convenience function to set telemetry source globally
-export function setTelemetrySource(source) {
-    Telemetry.getInstance().setSource(source);
-}