browser-use 0.2.0 → 0.4.0

package/dist/config.js

@@ -92,6 +92,12 @@ class OldConfig {
         }
         return url;
     }
+    get BROWSER_USE_DEBUG_LOG_FILE() {
+        return process.env.BROWSER_USE_DEBUG_LOG_FILE ?? null;
+    }
+    get BROWSER_USE_INFO_LOG_FILE() {
+        return process.env.BROWSER_USE_INFO_LOG_FILE ?? null;
+    }
     get XDG_CACHE_HOME() {
         return resolve_path(process.env.XDG_CACHE_HOME ?? '~/.cache');
     }
@@ -134,8 +140,11 @@ class OldConfig {
     get DEEPSEEK_API_KEY() {
         return process.env.DEEPSEEK_API_KEY ?? '';
     }
+    get GROQ_API_KEY() {
+        return process.env.GROQ_API_KEY ?? process.env.GROK_API_KEY ?? '';
+    }
     get GROK_API_KEY() {
-        return process.env.GROK_API_KEY ?? '';
+        return this.GROQ_API_KEY;
     }
     get NOVITA_API_KEY() {
         return process.env.NOVITA_API_KEY ?? '';
@@ -149,12 +158,18 @@ class OldConfig {
     get SKIP_LLM_API_KEY_VERIFICATION() {
         return string_to_bool(process.env.SKIP_LLM_API_KEY_VERIFICATION, false);
     }
+    get DEFAULT_LLM() {
+        return process.env.DEFAULT_LLM ?? '';
+    }
     get IN_DOCKER() {
         return (string_to_bool(process.env.IN_DOCKER, false) || is_running_in_docker());
     }
     get IS_IN_EVALS() {
         return string_to_bool(process.env.IS_IN_EVALS, false);
     }
+    get BROWSER_USE_VERSION_CHECK() {
+        return string_to_bool(process.env.BROWSER_USE_VERSION_CHECK, true);
+    }
     get WIN_FONT_DIR() {
         return process.env.WIN_FONT_DIR ?? 'C:\\Windows\\Fonts';
     }
@@ -188,6 +203,12 @@ class FlatEnvConfig {
     get BROWSER_USE_CLOUD_UI_URL() {
         return process.env.BROWSER_USE_CLOUD_UI_URL ?? '';
     }
+    get BROWSER_USE_DEBUG_LOG_FILE() {
+        return process.env.BROWSER_USE_DEBUG_LOG_FILE ?? null;
+    }
+    get BROWSER_USE_INFO_LOG_FILE() {
+        return process.env.BROWSER_USE_INFO_LOG_FILE ?? null;
+    }
     get XDG_CACHE_HOME() {
         return resolve_path(process.env.XDG_CACHE_HOME ?? '~/.cache');
     }
@@ -211,8 +232,11 @@ class FlatEnvConfig {
     get DEEPSEEK_API_KEY() {
         return process.env.DEEPSEEK_API_KEY ?? '';
     }
+    get GROQ_API_KEY() {
+        return process.env.GROQ_API_KEY ?? process.env.GROK_API_KEY ?? '';
+    }
     get GROK_API_KEY() {
-        return process.env.GROK_API_KEY ?? '';
+        return this.GROQ_API_KEY;
     }
     get NOVITA_API_KEY() {
         return process.env.NOVITA_API_KEY ?? '';
@@ -226,6 +250,9 @@ class FlatEnvConfig {
     get SKIP_LLM_API_KEY_VERIFICATION() {
         return string_to_bool(process.env.SKIP_LLM_API_KEY_VERIFICATION, false);
     }
+    get DEFAULT_LLM() {
+        return process.env.DEFAULT_LLM ?? '';
+    }
     get IN_DOCKER() {
         const value = process.env.IN_DOCKER;
         return value === undefined ? null : string_to_bool(value);
@@ -233,6 +260,9 @@ class FlatEnvConfig {
     get IS_IN_EVALS() {
         return string_to_bool(process.env.IS_IN_EVALS, false);
     }
+    get BROWSER_USE_VERSION_CHECK() {
+        return string_to_bool(process.env.BROWSER_USE_VERSION_CHECK, true);
+    }
     get WIN_FONT_DIR() {
         return process.env.WIN_FONT_DIR ?? 'C:\\Windows\\Fonts';
     }
@@ -251,9 +281,25 @@ class FlatEnvConfig {
     get BROWSER_USE_LLM_MODEL() {
         return process.env.BROWSER_USE_LLM_MODEL ?? null;
     }
+    get BROWSER_USE_PROXY_URL() {
+        return process.env.BROWSER_USE_PROXY_URL ?? null;
+    }
+    get BROWSER_USE_NO_PROXY() {
+        return process.env.BROWSER_USE_NO_PROXY ?? null;
+    }
+    get BROWSER_USE_PROXY_USERNAME() {
+        return process.env.BROWSER_USE_PROXY_USERNAME ?? null;
+    }
+    get BROWSER_USE_PROXY_PASSWORD() {
+        return process.env.BROWSER_USE_PROXY_PASSWORD ?? null;
+    }
+    get BROWSER_USE_DISABLE_EXTENSIONS() {
+        const value = process.env.BROWSER_USE_DISABLE_EXTENSIONS;
+        return value === undefined ? null : string_to_bool(value);
+    }
 }
 const create_default_config = () => {
-    logger.info('Creating fresh default config.json');
+    logger.debug('Creating fresh default config.json');
     const profile_id = randomUUID();
     const llm_id = randomUUID();
     const agent_id = randomUUID();
@@ -274,8 +320,8 @@ const create_default_config = () => {
                 id: llm_id,
                 default: true,
                 created_at: new Date().toISOString(),
-                model: 'gpt-4o',
-                api_key: 'your-openai-api-key-here',
+                model: 'gpt-4.1-mini',
+                api_key: null,
                 temperature: null,
                 max_tokens: null,
             },
@@ -292,6 +338,36 @@ const create_default_config = () => {
         },
     };
 };
+const OPENAI_API_KEY_PLACEHOLDERS = new Set([
+    'your-openai-api-key-here',
+    'your-openai-api-key',
+]);
+const sanitize_llm_api_key = (apiKey) => {
+    if (typeof apiKey !== 'string') {
+        return null;
+    }
+    const trimmed = apiKey.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (OPENAI_API_KEY_PLACEHOLDERS.has(trimmed.toLowerCase())) {
+        return null;
+    }
+    return trimmed;
+};
+const sanitize_db_config = (config) => {
+    const sanitizedLlmEntries = Object.fromEntries(Object.entries(config.llm ?? {}).map(([id, entry]) => [
+        id,
+        {
+            ...entry,
+            api_key: sanitize_llm_api_key(entry.api_key),
+        },
+    ]));
+    return {
+        ...config,
+        llm: sanitizedLlmEntries,
+    };
+};
 const looks_like_new_format = (data) => data &&
     typeof data === 'object' &&
     ['browser_profile', 'llm', 'agent'].every((key) => typeof data[key] === 'object') &&
@@ -307,9 +383,9 @@ const load_and_migrate_config = (config_path) => {
     try {
         const raw = JSON.parse(fs.readFileSync(config_path, 'utf-8'));
         if (looks_like_new_format(raw)) {
-            return raw;
+            return sanitize_db_config(raw);
         }
-        logger.info(`Old config format detected at ${config_path}, creating fresh config`);
+        logger.debug(`Old config format detected at ${config_path}, creating fresh config`);
         const fresh = create_default_config();
         fs.writeFileSync(config_path, JSON.stringify(fresh, null, 2), 'utf-8');
         return fresh;
@@ -374,12 +450,38 @@ class ConfigCore {
                     .map((domain) => domain.trim())
                     .filter(Boolean);
         }
+        const proxy = {};
+        if (env.BROWSER_USE_PROXY_URL) {
+            proxy.server = env.BROWSER_USE_PROXY_URL;
+        }
+        if (env.BROWSER_USE_NO_PROXY) {
+            proxy.bypass = env.BROWSER_USE_NO_PROXY.split(',')
+                .map((domain) => domain.trim())
+                .filter(Boolean)
+                .join(',');
+        }
+        if (env.BROWSER_USE_PROXY_USERNAME) {
+            proxy.username = env.BROWSER_USE_PROXY_USERNAME;
+        }
+        if (env.BROWSER_USE_PROXY_PASSWORD) {
+            proxy.password = env.BROWSER_USE_PROXY_PASSWORD;
+        }
+        if (Object.keys(proxy).length > 0) {
+            config.browser_profile.proxy = proxy;
+        }
         if (env.OPENAI_API_KEY) {
             config.llm.api_key = env.OPENAI_API_KEY;
         }
+        if (env.DEFAULT_LLM) {
+            config.llm.model = env.DEFAULT_LLM;
+        }
         if (env.BROWSER_USE_LLM_MODEL) {
             config.llm.model = env.BROWSER_USE_LLM_MODEL;
         }
+        if (env.BROWSER_USE_DISABLE_EXTENSIONS !== null) {
+            config.browser_profile.enable_default_extensions =
+                !env.BROWSER_USE_DISABLE_EXTENSIONS;
+        }
         return config;
     }
     _ensure_dirs() {

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;