mcp-use 0.1.20 → 0.3.0

package/dist/examples/structured_output.js

@@ -1,95 +0,0 @@
-/**
- * Structured Output Example - City Research with Playwright
- *
- * This example demonstrates intelligent structured output by researching Padova, Italy.
- * The agent becomes schema-aware and will intelligently retry to gather missing
- * information until all required fields can be populated.
- */
-import { ChatOpenAI } from '@langchain/openai';
-import { config } from 'dotenv';
-import { z } from 'zod';
-import { MCPAgent, MCPClient } from '../index.js';
-// Load environment variables from .env file
-config();
-// Define the structured output schema using Zod
-const CityInfoSchema = z.object({
-    name: z.string().describe('Official name of the city'),
-    country: z.string().describe('Country where the city is located'),
-    region: z.string().describe('Region or state within the country'),
-    population: z.number().describe('Current population count'),
-    area_km2: z.number().describe('Area in square kilometers'),
-    foundation_date: z.string().describe('When the city was founded (approximate year or period)'),
-    mayor: z.string().describe('Current mayor or city leader'),
-    famous_landmarks: z.array(z.string()).describe('List of famous landmarks, monuments, or attractions'),
-    universities: z.array(z.string()).describe('List of major universities or educational institutions'),
-    economy_sectors: z.array(z.string()).describe('Main economic sectors or industries'),
-    sister_cities: z.array(z.string()).describe('Twin cities or sister cities partnerships'),
-    historical_significance: z.string().describe('Brief description of historical importance'),
-    climate_type: z.string().nullable().describe('Type of climate (e.g., Mediterranean, Continental)'),
-    elevation_meters: z.number().nullable().describe('Elevation above sea level in meters'),
-});
-async function main() {
-    const mcpConfig = {
-        mcpServers: {
-            playwright: {
-                command: 'npx',
-                args: ['@playwright/mcp@latest'],
-                env: {
-                    DISPLAY: ':1',
-                },
-            },
-        },
-    };
-    const client = new MCPClient(mcpConfig);
-    const llm = new ChatOpenAI({ model: 'gpt-4o' });
-    const agent = new MCPAgent({ llm, client, maxSteps: 50, memoryEnabled: true });
-    try {
-        // Use structured output with intelligent retry
-        // The agent will:
-        // 1. Know exactly what information it needs to collect
-        // 2. Attempt structured output at finish points
-        // 3. Continue execution if required information is missing
-        // 4. Only finish when all required fields can be populated
-        const result = await agent.run(`
-      Research comprehensive information about the city of Padova (also known as Padua) in Italy.
-      
-      Visit multiple reliable sources like Wikipedia, official city websites, tourism sites,
-      and university websites to gather detailed information including demographics, history,
-      governance, education, economy, landmarks, and international relationships.
-      `, 50, // maxSteps
-        true, // manageConnector
-        [], // externalHistory
-        CityInfoSchema);
-        // Now you have strongly-typed, validated data!
-        console.log(`Name: ${result.name}`);
-        console.log(`Country: ${result.country}`);
-        console.log(`Region: ${result.region}`);
-        console.log(`Population: ${result.population.toLocaleString()}`);
-        console.log(`Area: ${result.area_km2} km²`);
-        console.log(`Foundation: ${result.foundation_date}`);
-        console.log(`Mayor: ${result.mayor}`);
-        console.log(`Universities: ${result.universities.join(', ')}`);
-        console.log(`Economy: ${result.economy_sectors.join(', ')}`);
-        console.log(`Landmarks: ${result.famous_landmarks.join(', ')}`);
-        console.log(`Sister Cities: ${result.sister_cities.length > 0 ? result.sister_cities.join(', ') : 'None'}`);
-        console.log(`Historical Significance: ${result.historical_significance}`);
-        if (result.climate_type) {
-            console.log(`Climate: ${result.climate_type}`);
-        }
-        if (result.elevation_meters !== null) {
-            console.log(`Elevation: ${result.elevation_meters} meters`);
-        }
-    }
-    catch (error) {
-        console.error('Error:', error);
-    }
-    finally {
-        await agent.close();
-    }
-}
-// Handle unhandled promise rejections
-process.on('unhandledRejection', (reason, promise) => {
-    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-    process.exit(1);
-});
-main().catch(console.error);

package/dist/src/adapters/base.js

@@ -1,124 +0,0 @@
-import { logger } from '../logging.js';
-/**
- * Abstract base class for converting MCP tools to other framework formats.
- *
- * This class defines the common interface that all adapter implementations
- * should follow to ensure consistency across different frameworks.
- */
-export class BaseAdapter {
-    /**
-     * List of tool names that should not be available.
-     */
-    disallowedTools;
-    /**
-     * Internal cache that maps a connector instance to the list of tools
-     * generated for it.
-     */
-    connectorToolMap = new Map();
-    constructor(disallowedTools) {
-        this.disallowedTools = disallowedTools ?? [];
-    }
-    /**
-     * Create tools from an MCPClient instance.
-     *
-     * This is the recommended way to create tools from an MCPClient, as it handles
-     * session creation and connector extraction automatically.
-     *
-     * @param client          The MCPClient to extract tools from.
-     * @param disallowedTools Optional list of tool names to exclude.
-     * @returns               A promise that resolves with a list of converted tools.
-     */
-    static async createTools(client, disallowedTools) {
-        // Create the adapter
-        const adapter = new this(disallowedTools);
-        // Ensure we have active sessions
-        if (!client.activeSessions || Object.keys(client.activeSessions).length === 0) {
-            logger.info('No active sessions found, creating new ones...');
-            await client.createAllSessions();
-        }
-        // Get all active sessions
-        const sessions = client.getAllActiveSessions();
-        // Extract connectors from sessions
-        const connectors = Object.values(sessions).map(session => session.connector);
-        // Create tools from connectors
-        return adapter.createToolsFromConnectors(connectors);
-    }
-    /**
-     * Dynamically load tools for a specific connector.
-     *
-     * @param connector The connector to load tools for.
-     * @returns         The list of tools that were loaded in the target framework's format.
-     */
-    async loadToolsForConnector(connector) {
-        // Return cached tools if we already processed this connector
-        if (this.connectorToolMap.has(connector)) {
-            const cached = this.connectorToolMap.get(connector);
-            logger.debug(`Returning ${cached.length} existing tools for connector`);
-            return cached;
-        }
-        const connectorTools = [];
-        // Make sure the connector is initialized and has tools
-        const success = await this.ensureConnectorInitialized(connector);
-        if (!success) {
-            return [];
-        }
-        // Convert and collect tools
-        for (const tool of connector.tools) {
-            const converted = this.convertTool(tool, connector);
-            if (converted) {
-                connectorTools.push(converted);
-            }
-        }
-        // Cache the tools for this connector
-        this.connectorToolMap.set(connector, connectorTools);
-        // Log for debugging purposes
-        logger.debug(`Loaded ${connectorTools.length} new tools for connector: ${connectorTools
-            .map((t) => t?.name ?? String(t))
-            .join(', ')}`);
-        return connectorTools;
-    }
-    /**
-     * Create tools from MCP tools in all provided connectors.
-     *
-     * @param connectors List of MCP connectors to create tools from.
-     * @returns         A promise that resolves with all converted tools.
-     */
-    async createToolsFromConnectors(connectors) {
-        const tools = [];
-        for (const connector of connectors) {
-            const connectorTools = await this.loadToolsForConnector(connector);
-            tools.push(...connectorTools);
-        }
-        logger.debug(`Available tools: ${tools.length}`);
-        return tools;
-    }
-    /**
-     * Check if a connector is initialized and has tools.
-     *
-     * @param connector The connector to check.
-     * @returns         True if the connector is initialized and has tools, false otherwise.
-     */
-    checkConnectorInitialized(connector) {
-        return Boolean(connector.tools && connector.tools.length);
-    }
-    /**
-     * Ensure a connector is initialized.
-     *
-     * @param connector The connector to initialize.
-     * @returns         True if initialization succeeded, false otherwise.
-     */
-    async ensureConnectorInitialized(connector) {
-        if (!this.checkConnectorInitialized(connector)) {
-            logger.debug('Connector doesn\'t have tools, initializing it');
-            try {
-                await connector.initialize();
-                return true;
-            }
-            catch (err) {
-                logger.error(`Error initializing connector: ${err}`);
-                return false;
-            }
-        }
-        return true;
-    }
-}

package/dist/src/adapters/index.js

@@ -1,2 +0,0 @@
-export { BaseAdapter } from './base.js';
-export { LangChainAdapter } from './langchain_adapter.js';

package/dist/src/adapters/langchain_adapter.js

@@ -1,49 +0,0 @@
-import { JSONSchemaToZod } from '@dmitryrechkin/json-schema-to-zod';
-import { DynamicStructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import { logger } from '../logging.js';
-import { BaseAdapter } from './base.js';
-function schemaToZod(schema) {
-    try {
-        return JSONSchemaToZod.convert(schema);
-    }
-    catch (err) {
-        logger.warn(`Failed to convert JSON schema to Zod: ${err}`);
-        return z.any();
-    }
-}
-export class LangChainAdapter extends BaseAdapter {
-    constructor(disallowedTools = []) {
-        super(disallowedTools);
-    }
-    /**
-     * Convert a single MCP tool specification into a LangChainJS structured tool.
-     */
-    convertTool(mcpTool, connector) {
-        // Filter out disallowed tools early.
-        if (this.disallowedTools.includes(mcpTool.name)) {
-            return null;
-        }
-        // Derive a strict Zod schema for the tool's arguments.
-        const argsSchema = mcpTool.inputSchema
-            ? schemaToZod(mcpTool.inputSchema)
-            : z.object({}).optional();
-        const tool = new DynamicStructuredTool({
-            name: mcpTool.name ?? 'NO NAME',
-            description: mcpTool.description ?? '', // Blank is acceptable but discouraged.
-            schema: argsSchema,
-            func: async (input) => {
-                logger.debug(`MCP tool \"${mcpTool.name}\" received input: ${JSON.stringify(input)}`);
-                try {
-                    const result = await connector.callTool(mcpTool.name, input);
-                    return JSON.stringify(result);
-                }
-                catch (err) {
-                    logger.error(`Error executing MCP tool: ${err.message}`);
-                    return `Error executing MCP tool: ${String(err)}`;
-                }
-            },
-        });
-        return tool;
-    }
-}

package/dist/src/agents/base.js

@@ -1,9 +0,0 @@
-export class BaseAgent {
-    session;
-    /**
-     * @param session MCP session used for tool invocation
-     */
-    constructor(session) {
-        this.session = session;
-    }
-}

package/dist/src/agents/index.js

@@ -1,3 +0,0 @@
-export { BaseAgent } from './base.js';
-export { MCPAgent } from './mcp_agent.js';
-export { RemoteAgent } from './remote.js';