browser-use 0.2.0 → 0.3.0

package/dist/llm/schema.js

@@ -1,6 +1,25 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+export const zodSchemaToJsonSchema = (schema, options = {}) => {
+    try {
+        const toJSONSchema = z?.toJSONSchema;
+        if (typeof toJSONSchema === 'function') {
+            const converted = toJSONSchema(schema);
+            if (converted && typeof converted === 'object') {
+                return converted;
+            }
+        }
+    }
+    catch {
+        // Fall back to zod-to-json-schema below.
+    }
+    return zodToJsonSchema(schema, options);
+};
 export class SchemaOptimizer {
-    static createOptimizedJsonSchema(schema) {
+    static createOptimizedJsonSchema(schema, options = {}) {
         const defsLookup = schema.$defs ?? {};
+        const removeMinItems = options.removeMinItems ?? false;
+        const removeDefaults = options.removeDefaults ?? false;
         const optimize = (obj, inProperties = false) => {
             if (Array.isArray(obj)) {
                 return obj.map((item) => optimize(item, inProperties));
@@ -13,6 +32,11 @@ export class SchemaOptimizer {
                         continue;
                     if (key === 'title' && !inProperties)
                         continue;
+                    if (removeMinItems && (key === 'minItems' || key === 'min_items')) {
+                        continue;
+                    }
+                    if (removeDefaults && key === 'default')
+                        continue;
                     if (key === '$ref' && typeof value === 'string') {
                         const refName = value.split('/').pop();
                         if (defsLookup[refName]) {
@@ -54,10 +78,66 @@ export class SchemaOptimizer {
                 Object.values(obj).forEach(ensureAdditionalProperties);
             }
         };
+        const stripStructuredDoneSuccess = (obj) => {
+            if (Array.isArray(obj)) {
+                obj.forEach(stripStructuredDoneSuccess);
+                return;
+            }
+            if (!obj || typeof obj !== 'object') {
+                return;
+            }
+            const properties = obj.properties;
+            if (obj.type === 'object' &&
+                properties &&
+                typeof properties === 'object' &&
+                !Array.isArray(properties)) {
+                const dataSchema = properties.data;
+                const successSchema = properties.success;
+                const looksLikeStructuredDone = dataSchema &&
+                    successSchema &&
+                    successSchema.type === 'boolean' &&
+                    successSchema.description ===
+                        'True if user_request completed successfully';
+                if (looksLikeStructuredDone) {
+                    delete properties.success;
+                    if (Array.isArray(obj.required)) {
+                        obj.required = obj.required.filter((name) => name !== 'success');
+                    }
+                }
+            }
+            Object.values(obj).forEach(stripStructuredDoneSuccess);
+        };
+        const stripExtractOutputSchema = (obj, parentKey = null) => {
+            if (Array.isArray(obj)) {
+                obj.forEach((item) => stripExtractOutputSchema(item, parentKey));
+                return;
+            }
+            if (!obj || typeof obj !== 'object') {
+                return;
+            }
+            const isExtractActionSchema = parentKey === 'extract_structured_data' || parentKey === 'extract';
+            if (isExtractActionSchema && obj.type === 'object') {
+                const props = obj.properties;
+                if (props && typeof props === 'object' && !Array.isArray(props)) {
+                    delete props.output_schema;
+                }
+                if (Array.isArray(obj.required)) {
+                    obj.required = obj.required.filter((name) => name !== 'output_schema');
+                }
+            }
+            for (const [key, value] of Object.entries(obj)) {
+                stripExtractOutputSchema(value, key);
+            }
+        };
         ensureAdditionalProperties(optimizedSchema);
+        stripStructuredDoneSuccess(optimizedSchema);
+        stripExtractOutputSchema(optimizedSchema);
         SchemaOptimizer.makeStrictCompatible(optimizedSchema);
         return optimizedSchema;
     }
+    static createGeminiOptimizedSchema(schema) {
+        return SchemaOptimizer.createOptimizedJsonSchema(schema);
+    }
     static makeStrictCompatible(schema) {
         if (Array.isArray(schema)) {
             schema.forEach(SchemaOptimizer.makeStrictCompatible);

package/dist/llm/vercel/chat.d.ts

@@ -0,0 +1,50 @@
+import type { BaseChatModel, ChatInvokeOptions } from '../base.js';
+import type { Message } from '../messages.js';
+import { ChatInvokeCompletion } from '../views.js';
+export interface ChatVercelOptions {
+    model?: string;
+    apiKey?: string;
+    baseURL?: string;
+    timeout?: number | null;
+    temperature?: number | null;
+    maxTokens?: number | null;
+    topP?: number | null;
+    seed?: number | null;
+    maxRetries?: number;
+    defaultHeaders?: Record<string, string> | null;
+    defaultQuery?: Record<string, string | undefined> | null;
+    fetchImplementation?: typeof fetch;
+    fetchOptions?: RequestInit | null;
+    reasoningModels?: string[] | null;
+    providerOptions?: Record<string, unknown> | null;
+    extraBody?: Record<string, unknown> | null;
+    removeMinItemsFromSchema?: boolean;
+    removeDefaultsFromSchema?: boolean;
+}
+export declare class ChatVercel implements BaseChatModel {
+    model: string;
+    provider: string;
+    private client;
+    private temperature;
+    private maxTokens;
+    private topP;
+    private seed;
+    private reasoningModels;
+    private providerOptions;
+    private extraBody;
+    private removeMinItemsFromSchema;
+    private removeDefaultsFromSchema;
+    constructor(options?: string | ChatVercelOptions);
+    get name(): string;
+    get model_name(): string;
+    private getUsage;
+    private getExtraBodyPayload;
+    private cloneMessages;
+    private appendJsonInstructionToMessages;
+    private parseStructuredJson;
+    private parseOutput;
+    ainvoke(messages: Message[], output_format?: undefined, options?: ChatInvokeOptions): Promise<ChatInvokeCompletion<string>>;
+    ainvoke<T>(messages: Message[], output_format: {
+        parse: (input: string) => T;
+    } | undefined, options?: ChatInvokeOptions): Promise<ChatInvokeCompletion<T>>;
+}

package/dist/llm/vercel/chat.js

@@ -0,0 +1,276 @@
+import OpenAI from 'openai';
+import { ModelProviderError, ModelRateLimitError } from '../exceptions.js';
+import { SchemaOptimizer, zodSchemaToJsonSchema } from '../schema.js';
+import { ChatInvokeCompletion } from '../views.js';
+import { VercelMessageSerializer } from './serializer.js';
+const DEFAULT_REASONING_MODELS = [
+    'o1',
+    'o3',
+    'o4',
+    'gpt-oss',
+    'deepseek-r1',
+    'qwen3-next-80b-a3b-thinking',
+];
+export class ChatVercel {
+    model;
+    provider = 'vercel';
+    client;
+    temperature;
+    maxTokens;
+    topP;
+    seed;
+    reasoningModels;
+    providerOptions;
+    extraBody;
+    removeMinItemsFromSchema;
+    removeDefaultsFromSchema;
+    constructor(options = {}) {
+        const normalizedOptions = typeof options === 'string' ? { model: options } : options;
+        const { model = 'openai/gpt-4o', apiKey = process.env.VERCEL_API_KEY, baseURL = process.env.VERCEL_BASE_URL ||
+            'https://ai-gateway.vercel.sh/v1', timeout = null, temperature = null, maxTokens = null, topP = null, seed = null, maxRetries = 5, defaultHeaders = null, defaultQuery = null, fetchImplementation, fetchOptions = null, reasoningModels = [...DEFAULT_REASONING_MODELS], providerOptions = null, extraBody = null, removeMinItemsFromSchema = false, removeDefaultsFromSchema = false, } = normalizedOptions;
+        this.model = model;
+        this.temperature = temperature;
+        this.maxTokens = maxTokens;
+        this.topP = topP;
+        this.seed = seed;
+        this.reasoningModels = reasoningModels ? [...reasoningModels] : null;
+        this.providerOptions = providerOptions;
+        this.extraBody = extraBody;
+        this.removeMinItemsFromSchema = removeMinItemsFromSchema;
+        this.removeDefaultsFromSchema = removeDefaultsFromSchema;
+        this.client = new OpenAI({
+            apiKey,
+            baseURL,
+            timeout: timeout ?? undefined,
+            maxRetries,
+            defaultHeaders: defaultHeaders ?? undefined,
+            defaultQuery: defaultQuery ?? undefined,
+            fetch: fetchImplementation,
+            fetchOptions: (fetchOptions ?? undefined),
+        });
+    }
+    get name() {
+        return this.model;
+    }
+    get model_name() {
+        return this.model;
+    }
+    getUsage(response) {
+        if (!response.usage) {
+            return null;
+        }
+        return {
+            prompt_tokens: response.usage.prompt_tokens,
+            prompt_cached_tokens: response.usage.prompt_tokens_details?.cached_tokens ?? null,
+            prompt_cache_creation_tokens: null,
+            prompt_image_tokens: null,
+            completion_tokens: response.usage.completion_tokens,
+            total_tokens: response.usage.total_tokens,
+        };
+    }
+    getExtraBodyPayload() {
+        const payload = {
+            ...(this.extraBody ?? {}),
+        };
+        if (this.providerOptions) {
+            payload.providerOptions = this.providerOptions;
+        }
+        return Object.keys(payload).length > 0 ? payload : undefined;
+    }
+    cloneMessages(messages) {
+        return messages.map((message) => ({
+            ...message,
+            content: Array.isArray(message?.content)
+                ? message.content.map((part) => ({ ...part }))
+                : message?.content,
+        }));
+    }
+    appendJsonInstructionToMessages(messages, schema) {
+        const cloned = this.cloneMessages(messages);
+        const instruction = '\n\nIMPORTANT: You must respond with ONLY a valid JSON object ' +
+            '(no markdown, no code blocks, no explanations) that exactly matches this schema:\n' +
+            `${JSON.stringify(schema, null, 2)}`;
+        if (cloned.length > 0 && cloned[0]?.role === 'system') {
+            if (typeof cloned[0].content === 'string') {
+                cloned[0].content = `${cloned[0].content}${instruction}`;
+            }
+            else if (Array.isArray(cloned[0].content)) {
+                cloned[0].content = [
+                    ...cloned[0].content,
+                    { type: 'text', text: instruction },
+                ];
+            }
+            else {
+                cloned[0].content = instruction;
+            }
+            return cloned;
+        }
+        for (let i = cloned.length - 1; i >= 0; i -= 1) {
+            if (cloned[i]?.role === 'user') {
+                if (typeof cloned[i].content === 'string') {
+                    cloned[i].content = `${cloned[i].content}${instruction}`;
+                }
+                else if (Array.isArray(cloned[i].content)) {
+                    cloned[i].content = [
+                        ...cloned[i].content,
+                        { type: 'text', text: instruction },
+                    ];
+                }
+                else {
+                    cloned[i].content = instruction;
+                }
+                return cloned;
+            }
+        }
+        cloned.unshift({
+            role: 'system',
+            content: instruction,
+        });
+        return cloned;
+    }
+    parseStructuredJson(text) {
+        let jsonText = String(text ?? '').trim();
+        if (jsonText.startsWith('```json') && jsonText.endsWith('```')) {
+            jsonText = jsonText.slice(7, -3).trim();
+        }
+        else if (jsonText.startsWith('```') && jsonText.endsWith('```')) {
+            jsonText = jsonText.slice(3, -3).trim();
+        }
+        return JSON.parse(jsonText);
+    }
+    parseOutput(output_format, payload) {
+        const output = output_format;
+        if (output &&
+            typeof output === 'object' &&
+            output.schema &&
+            typeof output.schema.parse === 'function') {
+            return output.schema.parse(payload);
+        }
+        return output.parse(payload);
+    }
+    async ainvoke(messages, output_format, options = {}) {
+        const serializer = new VercelMessageSerializer();
+        const vercelMessages = serializer.serialize(messages);
+        const modelParams = {};
+        if (this.temperature !== null) {
+            modelParams.temperature = this.temperature;
+        }
+        if (this.maxTokens !== null) {
+            modelParams.max_tokens = this.maxTokens;
+        }
+        if (this.topP !== null) {
+            modelParams.top_p = this.topP;
+        }
+        if (this.seed !== null) {
+            modelParams.seed = this.seed;
+        }
+        const zodSchemaCandidate = (() => {
+            const output = output_format;
+            if (output &&
+                typeof output === 'object' &&
+                typeof output.safeParse === 'function' &&
+                typeof output.parse === 'function') {
+                return output;
+            }
+            if (output &&
+                typeof output === 'object' &&
+                output.schema &&
+                typeof output.schema.safeParse === 'function' &&
+                typeof output.schema.parse === 'function') {
+                return output.schema;
+            }
+            return null;
+        })();
+        const extraBodyPayload = this.getExtraBodyPayload();
+        const isGoogleModel = this.model.startsWith('google/');
+        const isAnthropicModel = this.model.startsWith('anthropic/');
+        const isReasoningModel = (this.reasoningModels ?? []).some((pattern) => String(this.model).toLowerCase().includes(String(pattern).toLowerCase()));
+        if (output_format &&
+            zodSchemaCandidate &&
+            (isGoogleModel || isAnthropicModel || isReasoningModel)) {
+            try {
+                const rawJsonSchema = zodSchemaToJsonSchema(zodSchemaCandidate, {
+                    name: 'agent_output',
+                    target: 'jsonSchema7',
+                });
+                const optimizedJsonSchema = SchemaOptimizer.createGeminiOptimizedSchema(rawJsonSchema);
+                const requestMessages = this.appendJsonInstructionToMessages(vercelMessages, optimizedJsonSchema);
+                const request = {
+                    model: this.model,
+                    messages: requestMessages,
+                    ...modelParams,
+                };
+                if (extraBodyPayload) {
+                    request.extra_body = extraBodyPayload;
+                }
+                const response = await this.client.chat.completions.create(request, options.signal ? { signal: options.signal } : undefined);
+                const content = response.choices[0].message.content || '';
+                const usage = this.getUsage(response);
+                const stopReason = response.choices[0].finish_reason ?? null;
+                const completion = this.parseOutput(output_format, this.parseStructuredJson(content));
+                return new ChatInvokeCompletion(completion, usage, null, null, stopReason);
+            }
+            catch (error) {
+                throw new ModelProviderError(`Failed to parse JSON response: ${error?.message ?? String(error)}`, 500, this.model);
+            }
+        }
+        let responseFormat = undefined;
+        if (zodSchemaCandidate) {
+            try {
+                const rawJsonSchema = zodSchemaToJsonSchema(zodSchemaCandidate, {
+                    name: 'agent_output',
+                    target: 'jsonSchema7',
+                });
+                const optimizedJsonSchema = SchemaOptimizer.createOptimizedJsonSchema(rawJsonSchema, {
+                    removeMinItems: this.removeMinItemsFromSchema,
+                    removeDefaults: this.removeDefaultsFromSchema,
+                });
+                responseFormat = {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'agent_output',
+                        schema: optimizedJsonSchema,
+                        strict: true,
+                    },
+                };
+            }
+            catch {
+                responseFormat = undefined;
+            }
+        }
+        const request = {
+            model: this.model,
+            messages: vercelMessages,
+            response_format: responseFormat,
+            ...modelParams,
+        };
+        if (extraBodyPayload) {
+            request.extra_body = extraBodyPayload;
+        }
+        try {
+            const response = await this.client.chat.completions.create(request, options.signal ? { signal: options.signal } : undefined);
+            const content = response.choices[0].message.content || '';
+            const usage = this.getUsage(response);
+            const stopReason = response.choices[0].finish_reason ?? null;
+            let completion = content;
+            if (output_format) {
+                if (zodSchemaCandidate) {
+                    completion = this.parseOutput(output_format, JSON.parse(content));
+                }
+                else {
+                    completion = this.parseOutput(output_format, content);
+                }
+            }
+            return new ChatInvokeCompletion(completion, usage, null, null, stopReason);
+        }
+        catch (error) {
+            if (error?.status === 429) {
+                throw new ModelRateLimitError(error?.message ?? 'Rate limit exceeded', 429, this.model);
+            }
+            if (error?.status >= 500) {
+                throw new ModelProviderError(error?.message ?? 'Server error', error.status, this.model);
+            }
+            throw new ModelProviderError(error?.message ?? String(error), error?.status ?? 500, this.model);
+        }
+    }
+}

package/dist/llm/vercel/index.d.ts

@@ -0,0 +1 @@
+export * from './chat.js';

package/dist/llm/vercel/index.js

@@ -0,0 +1 @@
+export * from './chat.js';

package/dist/llm/vercel/serializer.d.ts

@@ -0,0 +1,5 @@
+import type { ChatCompletionMessageParam } from 'openai/resources/index.mjs';
+import type { Message } from '../messages.js';
+export declare class VercelMessageSerializer {
+    serialize(messages: Message[]): ChatCompletionMessageParam[];
+}

package/dist/llm/vercel/serializer.js

@@ -0,0 +1,7 @@
+import { OpenAIMessageSerializer } from '../openai/serializer.js';
+export class VercelMessageSerializer {
+    serialize(messages) {
+        const serializer = new OpenAIMessageSerializer();
+        return serializer.serialize(messages);
+    }
+}

package/dist/llm/views.d.ts

@@ -11,5 +11,6 @@ export declare class ChatInvokeCompletion<T = string> {
     usage: ChatInvokeUsage | null;
     thinking: string | null;
     redacted_thinking: string | null;
-    constructor(completion: T, usage?: ChatInvokeUsage | null, thinking?: string | null, redacted_thinking?: string | null);
+    stop_reason: string | null;
+    constructor(completion: T, usage?: ChatInvokeUsage | null, thinking?: string | null, redacted_thinking?: string | null, stop_reason?: string | null);
 }

package/dist/llm/views.js

@@ -3,10 +3,12 @@ export class ChatInvokeCompletion {
     usage;
     thinking;
     redacted_thinking;
-    constructor(completion, usage = null, thinking = null, redacted_thinking = null) {
+    stop_reason;
+    constructor(completion, usage = null, thinking = null, redacted_thinking = null, stop_reason = null) {
         this.completion = completion;
         this.usage = usage;
         this.thinking = thinking;
         this.redacted_thinking = redacted_thinking;
+        this.stop_reason = stop_reason;
     }
 }

package/dist/logging-config.d.ts

@@ -4,6 +4,8 @@ interface SetupLoggingOptions {
     stream?: Writable;
     logLevel?: LogLevel;
     forceSetup?: boolean;
+    debugLogFile?: string | null;
+    infoLogFile?: string | null;
 }
 export declare class Logger {
     private readonly name;

package/dist/logging-config.js

@@ -1,3 +1,5 @@
+import fs from 'node:fs';
+import path from 'node:path';
 const LEVEL_PRIORITY = {
     debug: 10,
     info: 20,
@@ -6,8 +8,17 @@ const LEVEL_PRIORITY = {
     error: 40,
 };
 let configured = false;
-let globalLevel = process.env.BROWSER_USE_LOGGING_LEVEL || 'info';
-let outputStream = process.stderr;
+let consoleLevel = process.env.BROWSER_USE_LOGGING_LEVEL || 'info';
+let consoleStream = process.stderr;
+let debugLogStream = null;
+let infoLogStream = null;
+const normalizeLogLevel = (candidate, fallback) => {
+    if (!candidate) {
+        return fallback;
+    }
+    const normalized = candidate.toLowerCase();
+    return normalized in LEVEL_PRIORITY ? normalized : fallback;
+};
 const formatMessage = (level, name, message) => {
     if (level === 'result') {
         return message;
@@ -15,39 +26,66 @@ const formatMessage = (level, name, message) => {
     const paddedLevel = level.toUpperCase().padEnd(7, ' ');
     return `${paddedLevel} [${name}] ${message}`;
 };
+const formatFileMessage = (level, name, message) => `${new Date().toISOString()} ${formatMessage(level, name, message)}`;
+const writePayload = (stream, level, payload) => {
+    if ('write' in stream) {
+        stream.write(`${payload}\n`);
+        return;
+    }
+    switch (level) {
+        case 'error':
+            console.error(payload);
+            break;
+        case 'warning':
+            console.warn(payload);
+            break;
+        default:
+            console.log(payload);
+            break;
+    }
+};
+const ensureFilePathReady = (filePath) => {
+    fs.mkdirSync(path.dirname(path.resolve(filePath)), { recursive: true });
+};
+const closeFileStreams = () => {
+    if (debugLogStream) {
+        debugLogStream.end();
+        debugLogStream = null;
+    }
+    if (infoLogStream) {
+        infoLogStream.end();
+        infoLogStream = null;
+    }
+};
 export class Logger {
     name;
     constructor(name) {
         this.name = name;
     }
-    shouldLog(level) {
-        return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[globalLevel];
+    shouldLog(level, threshold) {
+        return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[threshold];
     }
     get level() {
-        return globalLevel;
+        return consoleLevel;
     }
     emit(level, message, ...args) {
-        if (!this.shouldLog(level)) {
-            return;
-        }
+        const argsPayload = args.length
+            ? args
+                .map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg)))
+                .join(' ')
+            : '';
         const formatted = formatMessage(level, this.name, message);
-        const payload = args.length
-            ? `${formatted} ${args.map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' ')}`
-            : formatted;
-        if ('write' in outputStream) {
-            outputStream.write(`${payload}\n`);
+        const payload = argsPayload ? `${formatted} ${argsPayload}` : formatted;
+        if (this.shouldLog(level, consoleLevel)) {
+            writePayload(consoleStream, level, payload);
         }
-        else {
-            switch (level) {
-                case 'error':
-                    console.error(payload);
-                    break;
-                case 'warning':
-                    console.warn(payload);
-                    break;
-                default:
-                    console.log(payload);
-            }
+        if (debugLogStream && this.shouldLog(level, 'debug')) {
+            const filePayload = formatFileMessage(level, this.name, message);
+            debugLogStream.write(`${argsPayload ? `${filePayload} ${argsPayload}` : filePayload}\n`);
+        }
+        if (infoLogStream && this.shouldLog(level, 'info')) {
+            const filePayload = formatFileMessage(level, this.name, message);
+            infoLogStream.write(`${argsPayload ? `${filePayload} ${argsPayload}` : filePayload}\n`);
         }
     }
     debug(message, ...args) {
@@ -78,12 +116,27 @@ export const setupLogging = (options = {}) => {
     if (configured && !options.forceSetup) {
         return createLogger('browser_use');
     }
-    globalLevel =
-        options.logLevel ||
-            process.env.BROWSER_USE_LOGGING_LEVEL ||
-            'info';
-    outputStream = options.stream || process.stderr;
+    closeFileStreams();
+    consoleLevel = normalizeLogLevel(options.logLevel ?? process.env.BROWSER_USE_LOGGING_LEVEL, 'info');
+    consoleStream = options.stream || process.stderr;
+    const debugLogFile = options.debugLogFile ?? process.env.BROWSER_USE_DEBUG_LOG_FILE ?? null;
+    if (debugLogFile && debugLogFile.trim().length > 0) {
+        ensureFilePathReady(debugLogFile);
+        debugLogStream = fs.createWriteStream(path.resolve(debugLogFile), {
+            flags: 'a',
+            encoding: 'utf-8',
+        });
+    }
+    const infoLogFile = options.infoLogFile ?? process.env.BROWSER_USE_INFO_LOG_FILE ?? null;
+    if (infoLogFile && infoLogFile.trim().length > 0) {
+        ensureFilePathReady(infoLogFile);
+        infoLogStream = fs.createWriteStream(path.resolve(infoLogFile), {
+            flags: 'a',
+            encoding: 'utf-8',
+        });
+    }
     configured = true;
     return createLogger('browser_use');
 };
+setupLogging();
 export const logger = createLogger('browser_use');

package/dist/mcp/client.d.ts

@@ -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,12 +18,13 @@
  *     );
  *
  *     // 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
  */
 import { type Tool, type Prompt } from '@modelcontextprotocol/sdk/types.js';
 import type { Controller } from '../controller/service.js';
+import type { Tools } from '../tools/service.js';
 export interface MCPClientOptions {
     /** Maximum number of connection retry attempts (default: 3) */
     maxRetries?: number;
@@ -76,12 +77,16 @@ export declare class MCPClient {
      */
     callTool(name: string, args: any): Promise<any>;
     /**
-     * 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_")
      */
+    registerToTools(tools: Pick<Tools, 'registry'>, toolFilter?: string[], prefix?: string): Promise<void>;
+    /**
+     * @deprecated Use `registerToTools` instead.
+     */
     registerToController(controller: Controller<any>, toolFilter?: string[], prefix?: string): Promise<void>;
     private _registerToolAsAction;
     private _convertToolSchemaToParamModel;