browser-use 0.0.1 → 0.1.0

package/dist/config.js

@@ -0,0 +1,430 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { config as loadEnv } from 'dotenv';
+import { createLogger } from './logging-config.js';
+loadEnv();
+const logger = createLogger('browser_use.config');
+const expand_user = (value) => value.replace(/^~(?=$|\/|\\)/, os.homedir());
+const resolve_path = (value) => path.resolve(expand_user(value));
+const string_to_bool = (value, defaultValue = false) => {
+    if (value === undefined || value === null || value === '') {
+        return defaultValue;
+    }
+    return ['true', '1', 't', 'y', 'yes'].includes(value.toLowerCase());
+};
+let docker_cache = null;
+export const is_running_in_docker = () => {
+    if (docker_cache !== null) {
+        return docker_cache;
+    }
+    try {
+        if (fs.existsSync('/.dockerenv')) {
+            docker_cache = true;
+            return true;
+        }
+    }
+    catch {
+        /* no-op */
+    }
+    try {
+        const cgroup = fs.readFileSync('/proc/1/cgroup', 'utf-8').toLowerCase();
+        if (cgroup.includes('docker') || cgroup.includes('kubepods')) {
+            docker_cache = true;
+            return true;
+        }
+    }
+    catch {
+        /* no-op */
+    }
+    try {
+        const cmdline = fs.readFileSync('/proc/1/cmdline', 'utf-8').toLowerCase();
+        if (cmdline.includes('py') ||
+            cmdline.includes('uv') ||
+            cmdline.includes('app')) {
+            docker_cache = true;
+            return true;
+        }
+    }
+    catch {
+        /* no-op */
+    }
+    try {
+        const processes = fs
+            .readdirSync('/proc')
+            .filter((entry) => /^\d+$/.test(entry));
+        if (processes.length > 0 && processes.length < 10) {
+            docker_cache = true;
+            return true;
+        }
+    }
+    catch {
+        /* no-op */
+    }
+    docker_cache = false;
+    return false;
+};
+const ensure_dir = (target) => fs.mkdirSync(target, { recursive: true });
+class OldConfig {
+    _dirs_created = false;
+    get BROWSER_USE_LOGGING_LEVEL() {
+        return (process.env.BROWSER_USE_LOGGING_LEVEL ?? 'info').toLowerCase();
+    }
+    get ANONYMIZED_TELEMETRY() {
+        return string_to_bool(process.env.ANONYMIZED_TELEMETRY, true);
+    }
+    get BROWSER_USE_CLOUD_SYNC() {
+        const value = process.env.BROWSER_USE_CLOUD_SYNC;
+        return value ? string_to_bool(value) : this.ANONYMIZED_TELEMETRY;
+    }
+    get BROWSER_USE_CLOUD_API_URL() {
+        const url = process.env.BROWSER_USE_CLOUD_API_URL ?? 'https://api.browser-use.com';
+        if (!url.includes('://')) {
+            throw new Error('BROWSER_USE_CLOUD_API_URL must be a valid URL');
+        }
+        return url;
+    }
+    get BROWSER_USE_CLOUD_UI_URL() {
+        const url = process.env.BROWSER_USE_CLOUD_UI_URL ?? '';
+        if (url && !url.includes('://')) {
+            throw new Error('BROWSER_USE_CLOUD_UI_URL must be a valid URL if set');
+        }
+        return url;
+    }
+    get XDG_CACHE_HOME() {
+        return resolve_path(process.env.XDG_CACHE_HOME ?? '~/.cache');
+    }
+    get XDG_CONFIG_HOME() {
+        return resolve_path(process.env.XDG_CONFIG_HOME ?? '~/.config');
+    }
+    get BROWSER_USE_CONFIG_DIR() {
+        const configured = process.env.BROWSER_USE_CONFIG_DIR;
+        const dir = configured
+            ? resolve_path(configured)
+            : path.join(this.XDG_CONFIG_HOME, 'browseruse');
+        this._ensure_dirs(dir);
+        return dir;
+    }
+    get BROWSER_USE_CONFIG_FILE() {
+        return path.join(this.BROWSER_USE_CONFIG_DIR, 'config.json');
+    }
+    get BROWSER_USE_PROFILES_DIR() {
+        const dir = path.join(this.BROWSER_USE_CONFIG_DIR, 'profiles');
+        this._ensure_dirs(dir);
+        return dir;
+    }
+    get BROWSER_USE_DEFAULT_USER_DATA_DIR() {
+        return path.join(this.BROWSER_USE_PROFILES_DIR, 'default');
+    }
+    get BROWSER_USE_EXTENSIONS_DIR() {
+        const dir = path.join(this.BROWSER_USE_CONFIG_DIR, 'extensions');
+        this._ensure_dirs(dir);
+        return dir;
+    }
+    get OPENAI_API_KEY() {
+        return process.env.OPENAI_API_KEY ?? '';
+    }
+    get ANTHROPIC_API_KEY() {
+        return process.env.ANTHROPIC_API_KEY ?? '';
+    }
+    get GOOGLE_API_KEY() {
+        return process.env.GOOGLE_API_KEY ?? '';
+    }
+    get DEEPSEEK_API_KEY() {
+        return process.env.DEEPSEEK_API_KEY ?? '';
+    }
+    get GROK_API_KEY() {
+        return process.env.GROK_API_KEY ?? '';
+    }
+    get NOVITA_API_KEY() {
+        return process.env.NOVITA_API_KEY ?? '';
+    }
+    get AZURE_OPENAI_ENDPOINT() {
+        return process.env.AZURE_OPENAI_ENDPOINT ?? '';
+    }
+    get AZURE_OPENAI_KEY() {
+        return process.env.AZURE_OPENAI_KEY ?? '';
+    }
+    get SKIP_LLM_API_KEY_VERIFICATION() {
+        return string_to_bool(process.env.SKIP_LLM_API_KEY_VERIFICATION, false);
+    }
+    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 WIN_FONT_DIR() {
+        return process.env.WIN_FONT_DIR ?? 'C:\\Windows\\Fonts';
+    }
+    _ensure_dirs(base_dir) {
+        if (!this._dirs_created) {
+            const config_dir = base_dir ??
+                (process.env.BROWSER_USE_CONFIG_DIR
+                    ? resolve_path(process.env.BROWSER_USE_CONFIG_DIR)
+                    : path.join(this.XDG_CONFIG_HOME, 'browseruse'));
+            ensure_dir(config_dir);
+            ensure_dir(path.join(config_dir, 'profiles'));
+            ensure_dir(path.join(config_dir, 'extensions'));
+            this._dirs_created = true;
+        }
+    }
+}
+class FlatEnvConfig {
+    get BROWSER_USE_LOGGING_LEVEL() {
+        return process.env.BROWSER_USE_LOGGING_LEVEL ?? 'info';
+    }
+    get ANONYMIZED_TELEMETRY() {
+        return string_to_bool(process.env.ANONYMIZED_TELEMETRY, true);
+    }
+    get BROWSER_USE_CLOUD_SYNC() {
+        const value = process.env.BROWSER_USE_CLOUD_SYNC;
+        return value ? string_to_bool(value) : null;
+    }
+    get BROWSER_USE_CLOUD_API_URL() {
+        return (process.env.BROWSER_USE_CLOUD_API_URL ?? 'https://api.browser-use.com');
+    }
+    get BROWSER_USE_CLOUD_UI_URL() {
+        return process.env.BROWSER_USE_CLOUD_UI_URL ?? '';
+    }
+    get XDG_CACHE_HOME() {
+        return resolve_path(process.env.XDG_CACHE_HOME ?? '~/.cache');
+    }
+    get XDG_CONFIG_HOME() {
+        return resolve_path(process.env.XDG_CONFIG_HOME ?? '~/.config');
+    }
+    get BROWSER_USE_CONFIG_DIR() {
+        return process.env.BROWSER_USE_CONFIG_DIR
+            ? resolve_path(process.env.BROWSER_USE_CONFIG_DIR)
+            : null;
+    }
+    get OPENAI_API_KEY() {
+        return process.env.OPENAI_API_KEY ?? '';
+    }
+    get ANTHROPIC_API_KEY() {
+        return process.env.ANTHROPIC_API_KEY ?? '';
+    }
+    get GOOGLE_API_KEY() {
+        return process.env.GOOGLE_API_KEY ?? '';
+    }
+    get DEEPSEEK_API_KEY() {
+        return process.env.DEEPSEEK_API_KEY ?? '';
+    }
+    get GROK_API_KEY() {
+        return process.env.GROK_API_KEY ?? '';
+    }
+    get NOVITA_API_KEY() {
+        return process.env.NOVITA_API_KEY ?? '';
+    }
+    get AZURE_OPENAI_ENDPOINT() {
+        return process.env.AZURE_OPENAI_ENDPOINT ?? '';
+    }
+    get AZURE_OPENAI_KEY() {
+        return process.env.AZURE_OPENAI_KEY ?? '';
+    }
+    get SKIP_LLM_API_KEY_VERIFICATION() {
+        return string_to_bool(process.env.SKIP_LLM_API_KEY_VERIFICATION, false);
+    }
+    get IN_DOCKER() {
+        const value = process.env.IN_DOCKER;
+        return value === undefined ? null : string_to_bool(value);
+    }
+    get IS_IN_EVALS() {
+        return string_to_bool(process.env.IS_IN_EVALS, false);
+    }
+    get WIN_FONT_DIR() {
+        return process.env.WIN_FONT_DIR ?? 'C:\\Windows\\Fonts';
+    }
+    get BROWSER_USE_CONFIG_PATH() {
+        return process.env.BROWSER_USE_CONFIG_PATH
+            ? resolve_path(process.env.BROWSER_USE_CONFIG_PATH)
+            : null;
+    }
+    get BROWSER_USE_HEADLESS() {
+        const value = process.env.BROWSER_USE_HEADLESS;
+        return value === undefined ? null : string_to_bool(value);
+    }
+    get BROWSER_USE_ALLOWED_DOMAINS() {
+        return process.env.BROWSER_USE_ALLOWED_DOMAINS ?? null;
+    }
+    get BROWSER_USE_LLM_MODEL() {
+        return process.env.BROWSER_USE_LLM_MODEL ?? null;
+    }
+}
+const create_default_config = () => {
+    logger.info('Creating fresh default config.json');
+    const profile_id = randomUUID();
+    const llm_id = randomUUID();
+    const agent_id = randomUUID();
+    return {
+        browser_profile: {
+            [profile_id]: {
+                id: profile_id,
+                default: true,
+                created_at: new Date().toISOString(),
+                headless: false,
+                user_data_dir: null,
+                allowed_domains: null,
+                downloads_path: null,
+            },
+        },
+        llm: {
+            [llm_id]: {
+                id: llm_id,
+                default: true,
+                created_at: new Date().toISOString(),
+                model: 'gpt-4o',
+                api_key: 'your-openai-api-key-here',
+                temperature: null,
+                max_tokens: null,
+            },
+        },
+        agent: {
+            [agent_id]: {
+                id: agent_id,
+                default: true,
+                created_at: new Date().toISOString(),
+                max_steps: null,
+                use_vision: null,
+                system_prompt: null,
+            },
+        },
+    };
+};
+const looks_like_new_format = (data) => data &&
+    typeof data === 'object' &&
+    ['browser_profile', 'llm', 'agent'].every((key) => typeof data[key] === 'object') &&
+    Object.values(data.browser_profile || {}).every((entry) => typeof entry === 'object' && 'id' in entry);
+const load_and_migrate_config = (config_path) => {
+    if (!fs.existsSync(config_path)) {
+        const parent = path.dirname(config_path);
+        ensure_dir(parent);
+        const fresh = create_default_config();
+        fs.writeFileSync(config_path, JSON.stringify(fresh, null, 2), 'utf-8');
+        return fresh;
+    }
+    try {
+        const raw = JSON.parse(fs.readFileSync(config_path, 'utf-8'));
+        if (looks_like_new_format(raw)) {
+            return raw;
+        }
+        logger.info(`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;
+    }
+    catch (error) {
+        logger.error(`Failed to load config from ${config_path}: ${error.message}, creating fresh config`);
+        const fresh = create_default_config();
+        try {
+            fs.writeFileSync(config_path, JSON.stringify(fresh, null, 2), 'utf-8');
+        }
+        catch (write_error) {
+            logger.error(`Failed to write fresh config: ${write_error.message}`);
+        }
+        return fresh;
+    }
+};
+class ConfigCore {
+    _get_config_path() {
+        const env = new FlatEnvConfig();
+        if (env.BROWSER_USE_CONFIG_PATH) {
+            return env.BROWSER_USE_CONFIG_PATH;
+        }
+        if (env.BROWSER_USE_CONFIG_DIR) {
+            return path.join(env.BROWSER_USE_CONFIG_DIR, 'config.json');
+        }
+        return path.join(env.XDG_CONFIG_HOME, 'browseruse', 'config.json');
+    }
+    _get_db_config() {
+        return load_and_migrate_config(this._get_config_path());
+    }
+    _get_default_entry(records) {
+        for (const entry of Object.values(records)) {
+            if (entry.default) {
+                return { ...entry };
+            }
+        }
+        const [first] = Object.values(records);
+        return first ? { ...first } : {};
+    }
+    _get_default_profile() {
+        return this._get_default_entry(this._get_db_config().browser_profile);
+    }
+    _get_default_llm() {
+        return this._get_default_entry(this._get_db_config().llm);
+    }
+    _get_default_agent() {
+        return this._get_default_entry(this._get_db_config().agent);
+    }
+    _load_config() {
+        const config = {
+            browser_profile: this._get_default_profile(),
+            llm: this._get_default_llm(),
+            agent: this._get_default_agent(),
+        };
+        const env = new FlatEnvConfig();
+        if (env.BROWSER_USE_HEADLESS !== null) {
+            config.browser_profile.headless = env.BROWSER_USE_HEADLESS;
+        }
+        if (env.BROWSER_USE_ALLOWED_DOMAINS) {
+            config.browser_profile.allowed_domains =
+                env.BROWSER_USE_ALLOWED_DOMAINS.split(',')
+                    .map((domain) => domain.trim())
+                    .filter(Boolean);
+        }
+        if (env.OPENAI_API_KEY) {
+            config.llm.api_key = env.OPENAI_API_KEY;
+        }
+        if (env.BROWSER_USE_LLM_MODEL) {
+            config.llm.model = env.BROWSER_USE_LLM_MODEL;
+        }
+        return config;
+    }
+    _ensure_dirs() {
+        new OldConfig()._ensure_dirs();
+    }
+    load_config() {
+        return this._load_config();
+    }
+    get_default_profile() {
+        return this._get_default_profile();
+    }
+    get_default_llm() {
+        return this._get_default_llm();
+    }
+    get_default_agent() {
+        return this._get_default_agent();
+    }
+}
+const config_handler = {
+    get(target, prop, receiver) {
+        if (typeof prop !== 'string') {
+            return Reflect.get(target, prop, receiver);
+        }
+        const old = new OldConfig();
+        if (prop in old) {
+            const value = old[prop];
+            return typeof value === 'function'
+                ? value.bind(old)
+                : value;
+        }
+        const env = new FlatEnvConfig();
+        if (prop in env) {
+            const value = env[prop];
+            return typeof value === 'function'
+                ? value.bind(env)
+                : value;
+        }
+        const coreValue = target[prop];
+        if (typeof coreValue === 'function') {
+            return coreValue.bind(target);
+        }
+        return coreValue;
+    },
+};
+export const CONFIG = new Proxy(new ConfigCore(), config_handler);
+export const load_browser_use_config = () => CONFIG.load_config();
+export const get_default_profile = (config) => config.browser_profile ?? {};
+export const get_default_llm = (config) => config.llm ?? {};

package/dist/controller/index.d.ts

@@ -0,0 +1,3 @@
+export * from './service.js';
+export * from './views.js';
+export * from './registry/index.js';

package/dist/controller/index.js

@@ -0,0 +1,3 @@
+export * from './service.js';
+export * from './views.js';
+export * from './registry/index.js';

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

@@ -0,0 +1,2 @@
+export * from './service.js';
+export * from './views.js';

package/dist/controller/registry/index.js

@@ -0,0 +1,2 @@
+export * from './service.js';
+export * from './views.js';

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

@@ -0,0 +1,45 @@
+import { type ZodTypeAny } from 'zod';
+import type { Page } from '../../browser/types.js';
+import { FileSystem } from '../../filesystem/file-system.js';
+import { ActionModel, RegisteredAction } from './views.js';
+import type { BrowserSession } from '../../browser/session.js';
+type BaseChatModel = unknown;
+export interface SensitiveDataMap {
+    [key: string]: string | Record<string, string>;
+}
+export interface ExecuteActionContext<Context> {
+    context?: Context;
+    browser_session?: BrowserSession | null;
+    page_extraction_llm?: BaseChatModel | null;
+    file_system?: FileSystem | null;
+    available_file_paths?: string[] | null;
+    sensitive_data?: SensitiveDataMap | null;
+    signal?: AbortSignal | null;
+}
+export type RegistryActionHandler<Params = any, Context = unknown> = (params: Params, ctx: ExecuteActionContext<Context> & {
+    page?: Page | null;
+    has_sensitive_data?: boolean;
+}) => Promise<unknown> | unknown;
+export interface ActionOptions {
+    param_model?: ZodTypeAny;
+    domains?: string[] | null;
+    allowed_domains?: string[] | null;
+    page_filter?: ((page: Page) => boolean) | null;
+}
+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>;
+    get_action(action_name: string): RegisteredAction | null;
+    get_all_actions(): Map<string, RegisteredAction>;
+    execute_action: (...args: any[]) => any;
+    private replace_sensitive_data;
+    private log_sensitive_data_usage;
+    create_action_model(options?: {
+        include_actions?: string[] | null;
+        page?: Page | null;
+    }): typeof ActionModel;
+    get_prompt_description(page?: Page | null): string;
+}
+export {};

package/dist/controller/registry/service.js

@@ -0,0 +1,184 @@
+import { z } from 'zod';
+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 { ActionModel, ActionRegistry, RegisteredAction } from './views.js';
+const logger = createLogger('browser_use.controller.registry');
+const isAbortError = (error) => error instanceof Error && error.name === 'AbortError';
+const createAbortError = (reason) => {
+    if (isAbortError(reason)) {
+        return reason;
+    }
+    const message = reason instanceof Error ? reason.message : 'Operation aborted';
+    const error = new Error(message);
+    error.name = 'AbortError';
+    if (reason !== undefined) {
+        error.cause = reason;
+    }
+    return error;
+};
+const wrapActionExecutionError = (actionName, error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    const wrapped = new Error(`Error executing action ${actionName}: ${message}`);
+    if (error !== undefined) {
+        wrapped.cause = error;
+    }
+    return wrapped;
+};
+export class Registry {
+    registry = new ActionRegistry();
+    excludeActions;
+    constructor(exclude_actions = null) {
+        this.excludeActions = new Set(exclude_actions ?? []);
+    }
+    action(description, options = {}) {
+        const schema = options.param_model ?? z.object({}).strict();
+        const domains = options.allowed_domains ?? options.domains ?? null;
+        const pageFilter = options.page_filter ?? null;
+        return (handler) => {
+            if (this.excludeActions.has(handler.name)) {
+                return handler;
+            }
+            const action = new RegisteredAction(handler.name, description, handler, schema, domains, pageFilter);
+            this.registry.register(action);
+            return handler;
+        };
+    }
+    get_action(action_name) {
+        return this.registry.get(action_name);
+    }
+    get_all_actions() {
+        return this.registry.actionsMap;
+    }
+    execute_action = observe_debug({
+        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, } = {}) => {
+        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}`);
+        }
+        let validatedParams = parsed.data;
+        let currentUrl = null;
+        if (browser_session?.agent_current_page?.url) {
+            currentUrl = browser_session.agent_current_page.url();
+        }
+        else if (browser_session?.get_current_page) {
+            const currentPage = await browser_session.get_current_page();
+            currentUrl = currentPage?.url() ?? null;
+        }
+        if (sensitive_data) {
+            validatedParams = this.replace_sensitive_data(validatedParams, sensitive_data, currentUrl);
+        }
+        let page = null;
+        if (browser_session?.get_current_page) {
+            page = await browser_session.get_current_page();
+        }
+        const ctx = {
+            context,
+            browser_session,
+            browser: browser_session,
+            browser_context: browser_session,
+            page,
+            page_extraction_llm,
+            file_system,
+            available_file_paths,
+            signal,
+            has_sensitive_data: action_name === 'input_text' && Boolean(sensitive_data),
+        };
+        if (signal?.aborted) {
+            throw createAbortError(signal.reason);
+        }
+        try {
+            return await action.handler(validatedParams, ctx);
+        }
+        catch (error) {
+            if (signal?.aborted || isAbortError(error)) {
+                throw createAbortError(signal?.reason ?? error);
+            }
+            throw wrapActionExecutionError(action_name, error);
+        }
+    }));
+    replace_sensitive_data(params, sensitiveData, currentUrl) {
+        const secretPattern = /<secret>(.*?)<\/secret>/g;
+        const applicableSecrets = {};
+        for (const [domainOrKey, content] of Object.entries(sensitiveData)) {
+            if (content && typeof content === 'object' && !Array.isArray(content)) {
+                if (currentUrl &&
+                    !is_new_tab_page(currentUrl) &&
+                    match_url_with_domain_pattern(currentUrl, domainOrKey)) {
+                    Object.assign(applicableSecrets, content);
+                }
+            }
+            else if (typeof content === 'string') {
+                applicableSecrets[domainOrKey] = content;
+            }
+        }
+        const cloneValue = (value) => {
+            if (Array.isArray(value)) {
+                return value.map((item) => cloneValue(item));
+            }
+            if (value && typeof value === 'object') {
+                return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, cloneValue(v)]));
+            }
+            return value;
+        };
+        const processed = cloneValue(params);
+        const replaced = new Set();
+        const missing = new Set();
+        const traverse = (value) => {
+            if (typeof value === 'string') {
+                return value.replace(secretPattern, (_, placeholder) => {
+                    if (placeholder in applicableSecrets) {
+                        replaced.add(placeholder);
+                        return applicableSecrets[placeholder];
+                    }
+                    missing.add(placeholder);
+                    return `<secret>${placeholder}</secret>`;
+                });
+            }
+            if (Array.isArray(value)) {
+                return value.map(traverse);
+            }
+            if (value && typeof value === 'object') {
+                for (const [key, val] of Object.entries(value)) {
+                    value[key] = traverse(val);
+                }
+            }
+            return value;
+        };
+        traverse(processed);
+        this.log_sensitive_data_usage(replaced, currentUrl);
+        if (missing.size > 0) {
+            logger.warning(`Missing or empty keys in sensitive_data dictionary: ${Array.from(missing).join(', ')}`);
+        }
+        return processed;
+    }
+    log_sensitive_data_usage(placeholders, currentUrl) {
+        if (!placeholders.size) {
+            return;
+        }
+        const urlInfo = currentUrl && !is_new_tab_page(currentUrl) ? ` on ${currentUrl}` : '';
+        logger.info(`🔒 Using sensitive data placeholders: ${Array.from(placeholders).join(', ')}${urlInfo}`);
+    }
+    create_action_model(options = {}) {
+        const { include_actions = null, page = null } = options;
+        const availableActions = this.registry.getAvailableActions(page, include_actions);
+        class DynamicActionModel extends ActionModel {
+            static available_actions = availableActions.map((action) => action.name);
+        }
+        Object.defineProperty(DynamicActionModel, 'name', {
+            value: 'ActionModel',
+        });
+        return DynamicActionModel;
+    }
+    get_prompt_description(page) {
+        return this.registry.get_prompt_description(page ?? undefined);
+    }
+}