mcp-use 0.1.20 → 0.3.0

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);
-}

package/dist/src/telemetry/telemetry.js

@@ -1,324 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { PostHog } from 'posthog-node';
-import { v4 as uuidv4 } from 'uuid';
-import { logger } from '../logging.js';
-import { MCPAgentExecutionEvent } from './events.js';
-import { getPackageVersion } from './utils.js';
-// Environment detection function
-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 fs !== 'undefined'
-            && typeof os !== 'undefined'
-            && typeof fs.existsSync === 'function');
-        return hasNodeGlobals && hasNodeModules;
-    }
-    catch {
-        return false;
-    }
-}
-// Simple Scarf event logger implementation
-class ScarfEventLogger {
-    endpoint;
-    timeout;
-    constructor(endpoint, timeout = 3000) {
-        this.endpoint = endpoint;
-        this.timeout = timeout;
-    }
-    async logEvent(properties) {
-        try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-            const response = await fetch(this.endpoint, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(properties),
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-        }
-        catch (error) {
-            // Silently fail - telemetry should not break the application
-            logger.debug(`Failed to send Scarf event: ${error}`);
-        }
-    }
-}
-function getCacheHome() {
-    // Return a safe fallback for non-Node.js environments
-    if (!isNodeJSEnvironment()) {
-        return '/tmp/mcp_use_cache';
-    }
-    // XDG_CACHE_HOME for Linux and manually set envs
-    const envVar = process.env.XDG_CACHE_HOME;
-    if (envVar && path.isAbsolute(envVar)) {
-        return envVar;
-    }
-    const platform = process.platform;
-    const homeDir = os.homedir();
-    if (platform === 'win32') {
-        const appdata = process.env.LOCALAPPDATA || process.env.APPDATA;
-        if (appdata) {
-            return appdata;
-        }
-        return path.join(homeDir, 'AppData', 'Local');
-    }
-    else if (platform === 'darwin') {
-        // macOS
-        return path.join(homeDir, 'Library', 'Caches');
-    }
-    else {
-        // Linux or other Unix
-        return path.join(homeDir, '.cache');
-    }
-}
-export class Telemetry {
-    static instance = null;
-    USER_ID_PATH = path.join(getCacheHome(), 'mcp_use_3', 'telemetry_user_id');
-    VERSION_DOWNLOAD_PATH = path.join(getCacheHome(), 'mcp_use', 'download_version');
-    PROJECT_API_KEY = 'phc_lyTtbYwvkdSbrcMQNPiKiiRWrrM1seyKIMjycSvItEI';
-    HOST = 'https://eu.i.posthog.com';
-    SCARF_GATEWAY_URL = 'https://mcpuse.gateway.scarf.sh/events-ts';
-    UNKNOWN_USER_ID = 'UNKNOWN_USER_ID';
-    _currUserId = null;
-    _posthogClient = null;
-    _scarfClient = null;
-    _source = 'typescript';
-    constructor() {
-        // Check if we're in a Node.js environment first
-        const isNodeJS = isNodeJSEnvironment();
-        // Safely access environment variables
-        const telemetryDisabled = (typeof process !== 'undefined' && process.env?.MCP_USE_ANONYMIZED_TELEMETRY?.toLowerCase() === 'false') || false;
-        // Check for source from environment variable, default to 'typescript'
-        this._source = (typeof process !== 'undefined' && process.env?.MCP_USE_TELEMETRY_SOURCE) || 'typescript';
-        if (telemetryDisabled) {
-            this._posthogClient = null;
-            this._scarfClient = null;
-            logger.debug('Telemetry disabled via environment variable');
-        }
-        else if (!isNodeJS) {
-            this._posthogClient = null;
-            this._scarfClient = null;
-            logger.debug('Telemetry disabled - non-Node.js environment detected (e.g., Cloudflare Workers)');
-        }
-        else {
-            logger.info('Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable.');
-            // Initialize PostHog
-            try {
-                this._posthogClient = new PostHog(this.PROJECT_API_KEY, {
-                    host: this.HOST,
-                    disableGeoip: false,
-                });
-            }
-            catch (e) {
-                logger.warn(`Failed to initialize PostHog telemetry: ${e}`);
-                this._posthogClient = null;
-            }
-            // Initialize Scarf
-            try {
-                this._scarfClient = new ScarfEventLogger(this.SCARF_GATEWAY_URL, 3000);
-            }
-            catch (e) {
-                logger.warn(`Failed to initialize Scarf telemetry: ${e}`);
-                this._scarfClient = null;
-            }
-        }
-    }
-    static getInstance() {
-        if (!Telemetry.instance) {
-            Telemetry.instance = new Telemetry();
-        }
-        return Telemetry.instance;
-    }
-    /**
-     * Set the source identifier for telemetry events.
-     * This allows tracking usage from different applications.
-     * @param source - The source identifier (e.g., "my-app", "cli", "vs-code-extension")
-     */
-    setSource(source) {
-        this._source = source;
-        logger.debug(`Telemetry source set to: ${source}`);
-    }
-    /**
-     * Get the current source identifier.
-     */
-    getSource() {
-        return this._source;
-    }
-    get userId() {
-        if (this._currUserId) {
-            return this._currUserId;
-        }
-        // If we're not in a Node.js environment, just return a static user ID
-        if (!isNodeJSEnvironment()) {
-            this._currUserId = this.UNKNOWN_USER_ID;
-            return this._currUserId;
-        }
-        try {
-            const isFirstTime = !fs.existsSync(this.USER_ID_PATH);
-            if (isFirstTime) {
-                logger.debug(`Creating user ID path: ${this.USER_ID_PATH}`);
-                fs.mkdirSync(path.dirname(this.USER_ID_PATH), { recursive: true });
-                const newUserId = uuidv4();
-                fs.writeFileSync(this.USER_ID_PATH, newUserId);
-                this._currUserId = newUserId;
-                logger.debug(`User ID path created: ${this.USER_ID_PATH}`);
-            }
-            else {
-                this._currUserId = fs.readFileSync(this.USER_ID_PATH, 'utf-8').trim();
-            }
-            // Always check for version-based download tracking
-            // Note: We can't await here since this is a getter, so we fire and forget
-            this.trackPackageDownload({
-                triggered_by: 'user_id_property',
-            }).catch(e => logger.debug(`Failed to track package download: ${e}`));
-        }
-        catch (e) {
-            logger.debug(`Failed to get/create user ID: ${e}`);
-            this._currUserId = this.UNKNOWN_USER_ID;
-        }
-        return this._currUserId;
-    }
-    async capture(event) {
-        if (!this._posthogClient && !this._scarfClient) {
-            return;
-        }
-        // Send to PostHog
-        if (this._posthogClient) {
-            try {
-                // Add package version, language flag, and source to all events
-                const properties = { ...event.properties };
-                properties.mcp_use_version = getPackageVersion();
-                properties.language = 'typescript';
-                properties.source = this._source;
-                this._posthogClient.capture({
-                    distinctId: this.userId,
-                    event: event.name,
-                    properties,
-                });
-            }
-            catch (e) {
-                logger.debug(`Failed to track PostHog event ${event.name}: ${e}`);
-            }
-        }
-        // Send to Scarf (when implemented)
-        if (this._scarfClient) {
-            try {
-                // Add package version, user_id, language flag, and source to all events
-                const properties = {};
-                properties.mcp_use_version = getPackageVersion();
-                properties.user_id = this.userId;
-                properties.event = event.name;
-                properties.language = 'typescript';
-                properties.source = this._source;
-                await this._scarfClient.logEvent(properties);
-            }
-            catch (e) {
-                logger.debug(`Failed to track Scarf event ${event.name}: ${e}`);
-            }
-        }
-    }
-    async trackPackageDownload(properties) {
-        if (!this._scarfClient) {
-            return;
-        }
-        // Skip tracking in non-Node.js environments
-        if (!isNodeJSEnvironment()) {
-            return;
-        }
-        try {
-            const currentVersion = getPackageVersion();
-            let shouldTrack = false;
-            let firstDownload = false;
-            // Check if version file exists
-            if (!fs.existsSync(this.VERSION_DOWNLOAD_PATH)) {
-                // First download
-                shouldTrack = true;
-                firstDownload = true;
-                // Create directory and save version
-                fs.mkdirSync(path.dirname(this.VERSION_DOWNLOAD_PATH), { recursive: true });
-                fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
-            }
-            else {
-                // Read saved version
-                const savedVersion = fs.readFileSync(this.VERSION_DOWNLOAD_PATH, 'utf-8').trim();
-                // Compare versions (simple string comparison for now)
-                if (currentVersion > savedVersion) {
-                    shouldTrack = true;
-                    firstDownload = false;
-                    // Update saved version
-                    fs.writeFileSync(this.VERSION_DOWNLOAD_PATH, currentVersion);
-                }
-            }
-            if (shouldTrack) {
-                logger.debug(`Tracking package download event with properties: ${JSON.stringify(properties)}`);
-                // Add package version, user_id, language flag, and source to event
-                const eventProperties = { ...(properties || {}) };
-                eventProperties.mcp_use_version = currentVersion;
-                eventProperties.user_id = this.userId;
-                eventProperties.event = 'package_download';
-                eventProperties.first_download = firstDownload;
-                eventProperties.language = 'typescript';
-                eventProperties.source = this._source;
-                await this._scarfClient.logEvent(eventProperties);
-            }
-        }
-        catch (e) {
-            logger.debug(`Failed to track Scarf package_download event: ${e}`);
-        }
-    }
-    async trackAgentExecution(data) {
-        const event = new MCPAgentExecutionEvent(data);
-        await this.capture(event);
-    }
-    flush() {
-        // Flush PostHog
-        if (this._posthogClient) {
-            try {
-                this._posthogClient.flush();
-                logger.debug('PostHog client telemetry queue flushed');
-            }
-            catch (e) {
-                logger.debug(`Failed to flush PostHog client: ${e}`);
-            }
-        }
-        // Scarf events are sent immediately, no flush needed
-        if (this._scarfClient) {
-            logger.debug('Scarf telemetry events sent immediately (no flush needed)');
-        }
-    }
-    shutdown() {
-        // Shutdown PostHog
-        if (this._posthogClient) {
-            try {
-                this._posthogClient.shutdown();
-                logger.debug('PostHog client shutdown successfully');
-            }
-            catch (e) {
-                logger.debug(`Error shutting down PostHog client: ${e}`);
-            }
-        }
-        // Scarf doesn't require explicit shutdown
-        if (this._scarfClient) {
-            logger.debug('Scarf telemetry client shutdown (no action needed)');
-        }
-    }
-}

package/dist/src/telemetry/utils.js

@@ -1,39 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-export function getPackageVersion() {
-    try {
-        // Check if we're in a Node.js environment with file system access
-        if (typeof __dirname === 'undefined' || typeof fs === 'undefined') {
-            return 'unknown';
-        }
-        const packagePath = path.join(__dirname, '../../package.json');
-        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
-        return packageJson.version || 'unknown';
-    }
-    catch {
-        return 'unknown';
-    }
-}
-export function getModelProvider(llm) {
-    // Use LangChain's standard _llm_type property for identification
-    return llm._llm_type || llm.constructor.name.toLowerCase();
-}
-export function getModelName(llm) {
-    // First try _identifying_params which may contain model info
-    if ('_identifyingParams' in llm) {
-        const identifyingParams = llm._identifyingParams;
-        if (typeof identifyingParams === 'object' && identifyingParams !== null) {
-            // Common keys that contain model names
-            for (const key of ['model', 'modelName', 'model_name', 'modelId', 'model_id', 'deploymentName', 'deployment_name']) {
-                if (key in identifyingParams) {
-                    return String(identifyingParams[key]);
-                }
-            }
-        }
-    }
-    // Fallback to direct model attributes
-    return llm.model || llm.modelName || llm.constructor.name;
-}
-export function extractModelInfo(llm) {
-    return [getModelProvider(llm), getModelName(llm)];
-}