browser-use 0.2.0 → 0.3.0

package/dist/controller/registry/service.d.ts

@@ -10,7 +10,12 @@ export interface SensitiveDataMap {
 export interface ExecuteActionContext<Context> {
     context?: Context;
     browser_session?: BrowserSession | null;
+    browser?: BrowserSession | null;
+    browser_context?: BrowserSession | null;
+    page_url?: string | null;
+    cdp_client?: unknown;
     page_extraction_llm?: BaseChatModel | null;
+    extraction_schema?: Record<string, unknown> | null;
     file_system?: FileSystem | null;
     available_file_paths?: string[] | null;
     sensitive_data?: SensitiveDataMap | null;
@@ -22,16 +27,20 @@ export type RegistryActionHandler<Params = any, Context = unknown> = (params: Pa
 }) => Promise<unknown> | unknown;
 export interface ActionOptions {
     param_model?: ZodTypeAny;
+    action_name?: string;
     domains?: string[] | null;
     allowed_domains?: string[] | null;
     page_filter?: ((page: Page) => boolean) | null;
+    terminates_sequence?: boolean;
 }
 export declare class Registry<Context = unknown> {
     private registry;
     private excludeActions;
     constructor(exclude_actions?: string[] | null);
-    action(description: string, options?: ActionOptions): <Params = any>(handler: RegistryActionHandler<Params, Context>) => RegistryActionHandler<Params, Context>;
+    action(description: string, options?: ActionOptions): <Params = any>(handler: RegistryActionHandler<Params, Context>) => any;
     get_action(action_name: string): RegisteredAction | null;
+    exclude_action(action_name: string): void;
+    remove_action(action_name: string): void;
     get_all_actions(): Map<string, RegisteredAction>;
     execute_action: (...args: any[]) => any;
     private replace_sensitive_data;

package/dist/controller/registry/service.js

@@ -1,10 +1,145 @@
 import { z } from 'zod';
+import { createHmac } from 'node:crypto';
 import { createLogger } from '../../logging-config.js';
 import { observe_debug } from '../../observability.js';
 import { time_execution_async } from '../../utils.js';
 import { is_new_tab_page, match_url_with_domain_pattern } from '../../utils.js';
+import { BrowserError } from '../../browser/views.js';
 import { ActionModel, ActionRegistry, RegisteredAction } from './views.js';
 const logger = createLogger('browser_use.controller.registry');
+const SPECIAL_PARAM_NAMES = new Set([
+    'context',
+    'browser_session',
+    'browser',
+    'browser_context',
+    'page',
+    'page_url',
+    'cdp_client',
+    'page_extraction_llm',
+    'available_file_paths',
+    'has_sensitive_data',
+    'file_system',
+    'extraction_schema',
+    'sensitive_data',
+    'signal',
+]);
+const splitTopLevelParameters = (paramsSource) => {
+    const segments = [];
+    let current = '';
+    let depthParen = 0;
+    let depthBrace = 0;
+    let depthBracket = 0;
+    let quote = null;
+    let escaped = false;
+    const flush = () => {
+        const trimmed = current.trim();
+        if (trimmed) {
+            segments.push(trimmed);
+        }
+        current = '';
+    };
+    for (const char of paramsSource) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            current += char;
+            if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"' || char === '`') {
+            current += char;
+            quote = char;
+            continue;
+        }
+        if (char === '(')
+            depthParen += 1;
+        else if (char === ')')
+            depthParen -= 1;
+        else if (char === '{')
+            depthBrace += 1;
+        else if (char === '}')
+            depthBrace -= 1;
+        else if (char === '[')
+            depthBracket += 1;
+        else if (char === ']')
+            depthBracket -= 1;
+        if (char === ',' &&
+            depthParen === 0 &&
+            depthBrace === 0 &&
+            depthBracket === 0) {
+            flush();
+            continue;
+        }
+        current += char;
+    }
+    flush();
+    return segments;
+};
+const extractFunctionParameters = (fn) => {
+    const source = fn.toString().trim();
+    if (!source) {
+        return null;
+    }
+    let paramsSource;
+    const arrowIndex = source.indexOf('=>');
+    if (arrowIndex !== -1) {
+        let lhs = source.slice(0, arrowIndex).trim();
+        if (lhs.startsWith('async ')) {
+            lhs = lhs.slice('async '.length).trim();
+        }
+        if (lhs.startsWith('(') && lhs.endsWith(')')) {
+            paramsSource = lhs.slice(1, -1);
+        }
+        else {
+            paramsSource = lhs;
+        }
+    }
+    else {
+        const openIndex = source.indexOf('(');
+        const closeIndex = source.indexOf(')', openIndex + 1);
+        if (openIndex === -1 || closeIndex === -1) {
+            return null;
+        }
+        paramsSource = source.slice(openIndex + 1, closeIndex);
+    }
+    const tokens = splitTopLevelParameters(paramsSource);
+    if (!tokens.length) {
+        return [];
+    }
+    const parsed = [];
+    for (const token of tokens) {
+        if (token.startsWith('...')) {
+            const fnName = fn.name || '<anonymous>';
+            throw new Error(`Action '${fnName}' has ${token} which is not allowed. Actions must have explicit positional parameters only.`);
+        }
+        if (token.includes('{') ||
+            token.includes('}') ||
+            token.includes('[') ||
+            token.includes(']')) {
+            return null;
+        }
+        const eqIndex = token.indexOf('=');
+        const name = (eqIndex === -1 ? token : token.slice(0, eqIndex)).trim();
+        if (!name) {
+            return null;
+        }
+        parsed.push({
+            name,
+            hasDefault: eqIndex !== -1,
+        });
+    }
+    return parsed;
+};
 const isAbortError = (error) => error instanceof Error && error.name === 'AbortError';
 const createAbortError = (reason) => {
     if (isAbortError(reason)) {
@@ -19,6 +154,9 @@ const createAbortError = (reason) => {
     return error;
 };
 const wrapActionExecutionError = (actionName, error) => {
+    if (error instanceof BrowserError) {
+        return error;
+    }
     const message = error instanceof Error ? error.message : String(error);
     const wrapped = new Error(`Error executing action ${actionName}: ${message}`);
     if (error !== undefined) {
@@ -26,6 +164,61 @@ const wrapActionExecutionError = (actionName, error) => {
     }
     return wrapped;
 };
+const isSpecialContextMissingError = (error) => {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return (error.message.includes('requires browser_session but none provided') ||
+        error.message.includes('requires page_extraction_llm but none provided'));
+};
+const safeJsonStringify = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const isTimeoutError = (error) => error instanceof Error && error.name === 'TimeoutError';
+const BASE32_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+const decodeBase32Secret = (secret) => {
+    const sanitized = secret.toUpperCase().replace(/[^A-Z2-7]/g, '');
+    if (!sanitized.length) {
+        throw new Error('Invalid TOTP secret: empty base32 payload');
+    }
+    let bits = 0;
+    let bitBuffer = 0;
+    const bytes = [];
+    for (const char of sanitized) {
+        const value = BASE32_ALPHABET.indexOf(char);
+        if (value < 0) {
+            throw new Error(`Invalid base32 character in TOTP secret: ${char}`);
+        }
+        bitBuffer = (bitBuffer << 5) | value;
+        bits += 5;
+        while (bits >= 8) {
+            bytes.push((bitBuffer >>> (bits - 8)) & 0xff);
+            bits -= 8;
+        }
+    }
+    if (!bytes.length) {
+        throw new Error('Invalid TOTP secret: failed to decode base32 payload');
+    }
+    return Buffer.from(bytes);
+};
+const generateTotpCode = (secret) => {
+    const key = decodeBase32Secret(secret);
+    const counter = Math.floor(Date.now() / 1000 / 30);
+    const counterBuffer = Buffer.alloc(8);
+    counterBuffer.writeBigUInt64BE(BigInt(counter));
+    const hmac = createHmac('sha1', key).update(counterBuffer).digest();
+    const offset = hmac[hmac.length - 1] & 0x0f;
+    const binaryCode = ((hmac[offset] & 0x7f) << 24) |
+        ((hmac[offset + 1] & 0xff) << 16) |
+        ((hmac[offset + 2] & 0xff) << 8) |
+        (hmac[offset + 3] & 0xff);
+    return String(binaryCode % 1_000_000).padStart(6, '0');
+};
 export class Registry {
     registry = new ActionRegistry();
     excludeActions;
@@ -33,21 +226,68 @@ export class Registry {
         this.excludeActions = new Set(exclude_actions ?? []);
     }
     action(description, options = {}) {
-        const schema = options.param_model ?? z.object({}).strict();
+        if (options.allowed_domains && options.domains) {
+            throw new Error("Cannot specify both 'domains' and 'allowed_domains' - they are aliases for the same parameter");
+        }
+        let schema = options.param_model ?? z.object({}).strict();
+        const actionNameOverride = options.action_name ?? null;
         const domains = options.allowed_domains ?? options.domains ?? null;
         const pageFilter = options.page_filter ?? null;
+        const terminatesSequence = options.terminates_sequence ?? false;
         return (handler) => {
-            if (this.excludeActions.has(handler.name)) {
+            const actionName = actionNameOverride ?? handler.name;
+            if (this.excludeActions.has(actionName)) {
                 return handler;
             }
-            const action = new RegisteredAction(handler.name, description, handler, schema, domains, pageFilter);
+            const parsedHandlerParams = extractFunctionParameters(handler);
+            let normalizedHandler = handler;
+            if (!options.param_model) {
+                const supportsCompatSignature = Boolean(parsedHandlerParams &&
+                    parsedHandlerParams.length > 0 &&
+                    !(parsedHandlerParams.length <= 2 &&
+                        parsedHandlerParams[0]?.name === 'params'));
+                if (supportsCompatSignature && parsedHandlerParams) {
+                    const actionParams = parsedHandlerParams.filter((entry) => !SPECIAL_PARAM_NAMES.has(entry.name));
+                    const shape = Object.fromEntries(actionParams.map((entry) => [
+                        entry.name,
+                        entry.hasDefault ? z.any().optional() : z.any(),
+                    ]));
+                    schema = z.object(shape).strict();
+                    normalizedHandler = ((params, ctx) => {
+                        const args = parsedHandlerParams.map((entry) => {
+                            if (SPECIAL_PARAM_NAMES.has(entry.name)) {
+                                const value = ctx[entry.name];
+                                if ((value === null || value === undefined) &&
+                                    !entry.hasDefault) {
+                                    throw new Error(`Action ${actionName} requires ${entry.name} but none provided.`);
+                                }
+                                return value;
+                            }
+                            const value = params[entry.name];
+                            if (value === undefined && !entry.hasDefault) {
+                                throw new Error(`${actionName}() missing required parameter '${entry.name}'`);
+                            }
+                            return value;
+                        });
+                        return handler(...args);
+                    });
+                }
+            }
+            const action = new RegisteredAction(actionName, description, normalizedHandler, schema, domains, pageFilter, terminatesSequence);
             this.registry.register(action);
-            return handler;
+            return normalizedHandler;
         };
     }
     get_action(action_name) {
         return this.registry.get(action_name);
     }
+    exclude_action(action_name) {
+        this.excludeActions.add(action_name);
+        this.registry.remove(action_name);
+    }
+    remove_action(action_name) {
+        this.registry.remove(action_name);
+    }
     get_all_actions() {
         return this.registry.actionsMap;
     }
@@ -55,14 +295,14 @@ export class Registry {
         name: 'execute_action',
         ignore_input: true,
         ignore_output: true,
-    })(time_execution_async('--execute_action')(async (action_name, params, { browser_session = null, page_extraction_llm = null, file_system = null, sensitive_data = null, available_file_paths = null, signal = null, context = null, } = {}) => {
+    })(time_execution_async('--execute_action')(async (action_name, params, { browser_session = null, page_extraction_llm = null, extraction_schema = null, file_system = null, sensitive_data = null, available_file_paths = null, signal = null, context = null, } = {}) => {
         const action = this.registry.get(action_name);
         if (!action) {
             throw new Error(`Action ${action_name} not found`);
         }
         const parsed = action.paramSchema.safeParse(params);
         if (!parsed.success) {
-            throw new Error(`Invalid parameters for action ${action_name}: ${parsed.error.message}`);
+            throw new Error(`Invalid parameters ${safeJsonStringify(params)} for action ${action_name}: ${parsed.error.message}`);
         }
         let validatedParams = parsed.data;
         let currentUrl = null;
@@ -86,11 +326,16 @@ export class Registry {
             browser: browser_session,
             browser_context: browser_session,
             page,
+            page_url: currentUrl,
+            cdp_client: browser_session?.cdp_client ?? null,
             page_extraction_llm,
+            extraction_schema,
             file_system,
             available_file_paths,
+            sensitive_data,
             signal,
-            has_sensitive_data: action_name === 'input_text' && Boolean(sensitive_data),
+            has_sensitive_data: (action_name === 'input_text' || action_name === 'input') &&
+                Boolean(sensitive_data),
         };
         if (signal?.aborted) {
             throw createAbortError(signal.reason);
@@ -102,6 +347,12 @@ export class Registry {
             if (signal?.aborted || isAbortError(error)) {
                 throw createAbortError(signal?.reason ?? error);
             }
+            if (isTimeoutError(error)) {
+                throw new Error(`Error executing action ${action_name} due to timeout.`, { cause: error });
+            }
+            if (isSpecialContextMissingError(error)) {
+                throw error;
+            }
             throw wrapActionExecutionError(action_name, error);
         }
     }));
@@ -134,10 +385,15 @@ export class Registry {
         const missing = new Set();
         const traverse = (value) => {
             if (typeof value === 'string') {
-                return value.replace(secretPattern, (_, placeholder) => {
+                return value.replace(secretPattern, (_, placeholderValue) => {
+                    const placeholder = String(placeholderValue);
                     if (placeholder in applicableSecrets) {
                         replaced.add(placeholder);
-                        return applicableSecrets[placeholder];
+                        const replacement = applicableSecrets[placeholder];
+                        if (placeholder.endsWith('bu_2fa_code')) {
+                            return generateTotpCode(replacement);
+                        }
+                        return replacement;
                     }
                     missing.add(placeholder);
                     return `<secret>${placeholder}</secret>`;
@@ -165,7 +421,7 @@ export class Registry {
             return;
         }
         const urlInfo = currentUrl && !is_new_tab_page(currentUrl) ? ` on ${currentUrl}` : '';
-        logger.info(`🔒 Using sensitive data placeholders: ${Array.from(placeholders).join(', ')}${urlInfo}`);
+        logger.info(`🔒 Using sensitive data placeholders: ${Array.from(placeholders).sort().join(', ')}${urlInfo}`);
     }
     create_action_model(options = {}) {
         const { include_actions = null, page = null } = options;

package/dist/controller/registry/views.d.ts

@@ -11,7 +11,8 @@ export declare class RegisteredAction {
     readonly paramSchema: ZodTypeAny;
     readonly domains: string[] | null;
     readonly pageFilter: ((page: Page) => boolean) | null;
-    constructor(name: string, description: string, handler: ActionHandler, paramSchema: ZodTypeAny, domains?: string[] | null, pageFilter?: ((page: Page) => boolean) | null);
+    readonly terminates_sequence: boolean;
+    constructor(name: string, description: string, handler: ActionHandler, paramSchema: ZodTypeAny, domains?: string[] | null, pageFilter?: ((page: Page) => boolean) | null, terminates_sequence?: boolean);
     promptDescription(): string;
 }
 export declare class ActionModel {
@@ -30,6 +31,7 @@ export declare class ActionModel {
 export declare class ActionRegistry {
     private actions;
     register(action: RegisteredAction): void;
+    remove(name: string): void;
     get(name: string): RegisteredAction | null;
     getAll(): RegisteredAction[];
     get actionsMap(): Map<string, RegisteredAction>;
@@ -46,6 +48,7 @@ export declare class SpecialActionParameters {
     browser_context: BrowserSession | null;
     page: Page | null;
     page_extraction_llm: BaseChatModel | null;
+    extraction_schema: Record<string, unknown> | null;
     file_system: FileSystem | null;
     available_file_paths: string[] | null;
     signal: AbortSignal | null;

package/dist/controller/registry/views.js

@@ -22,13 +22,15 @@ export class RegisteredAction {
     paramSchema;
     domains;
     pageFilter;
-    constructor(name, description, handler, paramSchema, domains = null, pageFilter = null) {
+    terminates_sequence;
+    constructor(name, description, handler, paramSchema, domains = null, pageFilter = null, terminates_sequence = false) {
         this.name = name;
         this.description = description;
         this.handler = handler;
         this.paramSchema = paramSchema;
         this.domains = domains;
         this.pageFilter = pageFilter;
+        this.terminates_sequence = terminates_sequence;
     }
     promptDescription() {
         const skipKeys = new Set(['title']);
@@ -36,8 +38,25 @@ export class RegisteredAction {
         description += `{${this.name}: `;
         const schemaShape = (this.paramSchema instanceof z.ZodObject && this.paramSchema.shape) ||
             ('shape' in this.paramSchema ? this.paramSchema.shape : null);
+        const hideStructuredDoneSuccess = Boolean(this.name === 'done' &&
+            schemaShape &&
+            typeof schemaShape === 'object' &&
+            Object.prototype.hasOwnProperty.call(schemaShape, 'data') &&
+            Object.prototype.hasOwnProperty.call(schemaShape, 'success'));
+        if (hideStructuredDoneSuccess) {
+            skipKeys.add('success');
+        }
+        const hideExtractOutputSchema = Boolean(this.name === 'extract_structured_data' &&
+            schemaShape &&
+            typeof schemaShape === 'object' &&
+            Object.prototype.hasOwnProperty.call(schemaShape, 'output_schema'));
+        if (hideExtractOutputSchema) {
+            skipKeys.add('output_schema');
+        }
         if (schemaShape) {
-            const props = Object.fromEntries(Object.entries(schemaShape).map(([key, value]) => {
+            const props = Object.fromEntries(Object.entries(schemaShape)
+                .filter(([key]) => !skipKeys.has(key))
+                .map(([key, value]) => {
                 const entries = value instanceof z.ZodType ? value._def : value;
                 const cleanEntries = Object.fromEntries(Object.entries(entries).filter(([propKey]) => !skipKeys.has(propKey)));
                 return [key, cleanEntries];
@@ -97,6 +116,9 @@ export class ActionRegistry {
     register(action) {
         this.actions.set(action.name, action);
     }
+    remove(name) {
+        this.actions.delete(name);
+    }
     get(name) {
         return this.actions.get(name) ?? null;
     }
@@ -164,6 +186,7 @@ export class SpecialActionParameters {
     browser_context = null;
     page = null;
     page_extraction_llm = null;
+    extraction_schema = null;
     file_system = null;
     available_file_paths = null;
     signal = null;

package/dist/controller/service.d.ts

@@ -28,22 +28,31 @@ export interface ActParams<Context = unknown> {
 export declare class Controller<Context = unknown> {
     registry: Registry<Context>;
     private displayFilesInDoneText;
+    private outputModel;
+    private coordinateClickingEnabled;
+    private clickActionHandler;
     private logger;
     constructor(options?: ControllerOptions<Context>);
     private registerDefaultActions;
     private registerNavigationActions;
     private registerElementActions;
+    private registerClickActions;
     private registerTabActions;
     private registerContentActions;
+    private registerExplorationActions;
     private registerScrollActions;
     private registerFileSystemActions;
+    private registerUtilityActions;
     private registerKeyboardActions;
     private registerDropdownActions;
     private registerSheetsActions;
     private gotoSheetsRange;
     private registerDoneAction;
     use_structured_output_action(outputModel: z.ZodTypeAny): void;
-    action(description: string, options?: {}): <Params = any>(handler: import("./index.js").RegistryActionHandler<Params, Context>) => import("./index.js").RegistryActionHandler<Params, Context>;
+    get_output_model(): z.ZodTypeAny | null;
+    exclude_action(actionName: string): void;
+    set_coordinate_clicking(enabled: boolean): void;
+    action(description: string, options?: {}): <Params = any>(handler: import("./index.js").RegistryActionHandler<Params, Context>) => any;
     act(action: Record<string, unknown>, { browser_session, page_extraction_llm, sensitive_data, available_file_paths, file_system, context, signal, }: ActParams<Context>): Promise<ActionResult>;
 }
 export {};