browser-use 0.1.0 → 0.3.0

package/dist/mcp/client.js

@@ -5,10 +5,10 @@
  * MCP tools are dynamically discovered and registered as browser-use actions.
  *
  * Example usage:
- *     import { Controller } from './controller/service.js';
+ *     import { Tools } from './tools/service.js';
  *     import { MCPClient } from './mcp/client.js';
  *
- *     const controller = new Controller();
+ *     const tools = new Tools();
  *
  *     // Connect to an MCP server
  *     const mcpClient = new MCPClient(
@@ -18,7 +18,7 @@
  *     );
  *
  *     // Register all MCP tools as browser-use actions
- *     await mcpClient.registerToController(controller);
+ *     await mcpClient.registerToTools(tools);
  *
  *     // Now use with Agent as normal - MCP tools are available as actions
  */
@@ -145,19 +145,20 @@ export class MCPClient {
         }
     }
     async _connectWithTimeout(transport, timeoutSeconds) {
-        return new Promise(async (resolve, reject) => {
+        return new Promise((resolve, reject) => {
             const timeoutHandle = setTimeout(() => {
                 reject(new Error(`Failed to connect to MCP server '${this.serverName}' after ${timeoutSeconds} seconds`));
             }, timeoutSeconds * 1000);
-            try {
-                await this.client.connect(transport);
+            this.client
+                .connect(transport)
+                .then(() => {
                 clearTimeout(timeoutHandle);
                 resolve();
-            }
-            catch (error) {
+            })
+                .catch((error) => {
                 clearTimeout(timeoutHandle);
                 reject(error);
-            }
+            });
         });
     }
     /**
@@ -249,17 +250,17 @@ export class MCPClient {
         }
     }
     /**
-     * Register MCP tools as actions in the browser-use controller
+     * Register MCP tools as actions in browser-use tools.
      *
-     * @param controller - Browser-use controller to register actions to
+     * @param tools - Browser-use tools to register actions to
      * @param toolFilter - Optional list of tool names to register (undefined = all tools)
      * @param prefix - Optional prefix to add to action names (e.g., "playwright_")
      */
-    async registerToController(controller, toolFilter, prefix) {
+    async registerToTools(tools, toolFilter, prefix) {
         if (!this._connected) {
             await this.connect();
         }
-        const registry = controller.registry;
+        const registry = tools.registry;
         for (const [toolName, tool] of this._tools.entries()) {
             // Skip if not in filter
             if (toolFilter && !toolFilter.includes(toolName)) {
@@ -277,6 +278,12 @@ export class MCPClient {
         }
         logger.info(`✅ Registered ${this._registeredActions.size} MCP tools from '${this.serverName}' as browser-use actions`);
     }
+    /**
+     * @deprecated Use `registerToTools` instead.
+     */
+    async registerToController(controller, toolFilter, prefix) {
+        await this.registerToTools(controller, toolFilter, prefix);
+    }
     _registerToolAsAction(registry, actionName, tool) {
         /**
          * Register a single MCP tool as a browser-use action
@@ -290,7 +297,6 @@ export class MCPClient {
                 });
             }
             const startTime = Date.now() / 1000;
-            let errorMsg = null;
             try {
                 // Call the MCP tool
                 const result = await this.callTool(tool.name, params || {});
@@ -302,7 +308,7 @@ export class MCPClient {
                 });
             }
             catch (error) {
-                errorMsg = error instanceof Error ? error.message : String(error);
+                const errorMsg = error instanceof Error ? error.message : String(error);
                 logger.error(`MCP tool '${tool.name}' failed: ${errorMsg}`);
                 return new ActionResult({
                     error: `MCP tool '${tool.name}' failed: ${errorMsg}`,

package/dist/mcp/controller.d.ts

@@ -1,6 +1,45 @@
+import type { Registry } from '../tools/registry/service.js';
+import type { Tools } from '../tools/service.js';
+import { MCPClient, type MCPClientOptions } from './client.js';
+export interface MCPToolWrapperOptions {
+    serverName?: string;
+    env?: Record<string, string>;
+    clientOptions?: MCPClientOptions;
+}
+export declare class MCPToolWrapper {
+    private registry;
+    private client;
+    constructor(registry: Registry, mcpCommand: string, mcpArgs?: string[], options?: MCPToolWrapperOptions);
+    connect(toolFilter?: string[], prefix?: string, tools?: Pick<Tools, 'registry'>): Promise<void>;
+    disconnect(): Promise<void>;
+    getClient(): MCPClient;
+    getStats(): {
+        serverName: string;
+        connected: boolean;
+        toolsDiscovered: number;
+        promptsDiscovered: number;
+        toolCallCount: number;
+        errorCount: number;
+        successRate: number;
+        uptime?: number;
+        lastHealthCheck?: number;
+    };
+}
+export declare function registerMcpTools(registry: Registry, mcpCommand: string, mcpArgs?: string[], options?: MCPToolWrapperOptions): Promise<MCPToolWrapper>;
+export interface AddMCPServerOptions {
+    serverName?: string;
+    env?: Record<string, string>;
+    clientOptions?: MCPClientOptions;
+    toolFilter?: string[];
+    prefix?: string;
+    tools?: Pick<Tools, 'registry'>;
+}
 export declare class MCPController {
     private clients;
-    constructor();
-    addServer(command: string, args: string[]): Promise<void>;
-    private registerTools;
+    private tools;
+    constructor(tools?: Pick<Tools, 'registry'> | null);
+    setTools(tools: Pick<Tools, 'registry'>): void;
+    addServer(command: string, args?: string[], options?: AddMCPServerOptions): Promise<MCPClient>;
+    getClients(): MCPClient[];
+    disconnectAll(): Promise<void>;
 }

package/dist/mcp/controller.js

@@ -1,38 +1,63 @@
+import { createLogger } from '../logging-config.js';
 import { MCPClient } from './client.js';
-import { z } from 'zod';
-// This controller integrates MCP tools into the browser-use registry
+const logger = createLogger('browser_use.mcp.controller');
+export class MCPToolWrapper {
+    registry;
+    client;
+    constructor(registry, mcpCommand, mcpArgs = [], options = {}) {
+        this.registry = registry;
+        this.client = new MCPClient(options.serverName ?? 'browser-use-mcp-tools', mcpCommand, mcpArgs, options.env, options.clientOptions);
+    }
+    async connect(toolFilter, prefix, tools) {
+        if (!this.client.isConnected()) {
+            await this.client.connect();
+        }
+        const targetTools = tools ?? { registry: this.registry };
+        await this.client.registerToTools(targetTools, toolFilter, prefix);
+    }
+    async disconnect() {
+        await this.client.disconnect();
+    }
+    getClient() {
+        return this.client;
+    }
+    getStats() {
+        return this.client.getStats();
+    }
+}
+export async function registerMcpTools(registry, mcpCommand, mcpArgs = [], options = {}) {
+    const wrapper = new MCPToolWrapper(registry, mcpCommand, mcpArgs, options);
+    await wrapper.connect();
+    return wrapper;
+}
+// Backward-compatible helper that can manage multiple MCP clients.
 export class MCPController {
     clients = [];
-    constructor() { }
-    async addServer(command, args) {
-        const client = new MCPClient('browser-use-client', command, args);
+    tools;
+    constructor(tools = null) {
+        this.tools = tools;
+    }
+    setTools(tools) {
+        this.tools = tools;
+    }
+    async addServer(command, args = [], options = {}) {
+        const client = new MCPClient(options.serverName ?? `browser-use-client-${this.clients.length + 1}`, command, args, options.env, options.clientOptions);
         await client.connect();
-        this.clients.push(client);
-        await this.registerTools(client);
-    }
-    async registerTools(client) {
-        const tools = await client.listTools();
-        for (const tool of tools) {
-            // We need to convert JSON schema to Zod schema dynamically if we want to validate
-            // For now, we might just use a generic schema or skip validation at the registry level
-            // and let the MCP server validate.
-            // However, the Registry expects a Zod schema.
-            // We can create a dynamic Zod schema that accepts anything if we can't easily convert.
-            // Or we can try to convert using json-schema-to-zod (if we had it) or just use z.any()
-            const paramModel = z.any().describe(tool.description || '');
-            // Register the action
-            // Note: We need to access the singleton registry or pass it in.
-            // Assuming we can use the decorator or manual registration.
-            // Since we are registering dynamically, we might need a method on Registry to register actions at runtime.
-            // Let's assume Registry has a static method or we can access the instance.
-            // In the migration plan, Registry is a class.
-            // We might need to modify Registry to support runtime registration if it doesn't already.
-            // But wait, the Registry in `src/controller/registry/service.ts` has an `action` method which is a decorator.
-            // It also has a `registry` property which holds the actions.
-            // We'll assume we can access the global registry or pass it to this controller.
-            // For now, I'll just log it as a placeholder for actual registration logic which might require
-            // more complex integration with the Controller class.
-            console.log(`Discovered MCP tool: ${tool.name}`);
+        const targetTools = options.tools ?? this.tools;
+        if (targetTools) {
+            await client.registerToTools(targetTools, options.toolFilter, options.prefix);
+        }
+        else {
+            logger.warning('MCPController.addServer connected but skipped tool registration because no Tools instance was provided');
         }
+        this.clients.push(client);
+        return client;
+    }
+    getClients() {
+        return [...this.clients];
+    }
+    async disconnectAll() {
+        await Promise.all(this.clients.map((client) => client.disconnect()));
+        this.clients = [];
     }
 }

package/dist/mcp/server.d.ts

@@ -50,16 +50,30 @@ export declare class MCPServer {
     private toolExecutionCount;
     private errorCount;
     private abortController;
+    private activeSessions;
+    private sessionTimeoutMinutes;
+    private sessionCleanupInterval;
     constructor(name: string, version: string);
     private resolvePath;
     private getDefaultProfileConfig;
     private getDefaultLlmConfig;
+    private seedOpenAiApiKeyFromConfig;
+    private createLlmFromModelName;
     private sanitizeProfileConfig;
     private buildDirectSessionProfile;
     private buildRetryProfile;
     private initializeLlmForDirectTools;
     private initializeFileSystem;
     private formatRetryResult;
+    private trackSession;
+    private updateSessionActivity;
+    private serializeTrackedSessions;
+    private shutdownSession;
+    private closeSessionById;
+    private closeAllTrackedSessions;
+    private cleanupExpiredSessions;
+    private startSessionCleanupLoop;
+    private stopSessionCleanupLoop;
     private setupHandlers;
     private ensureController;
     private ensureBrowserSession;