browser-use 0.0.1 → 0.1.0

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

@@ -0,0 +1,55 @@
+import { type ZodTypeAny } from 'zod';
+import type { Page } from '../../browser/types.js';
+export type ActionHandler = (...args: any[]) => Promise<unknown> | unknown;
+type BrowserSession = unknown;
+type BaseChatModel = unknown;
+type FileSystem = unknown;
+export declare class RegisteredAction {
+    readonly name: string;
+    readonly description: string;
+    readonly handler: ActionHandler;
+    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);
+    promptDescription(): string;
+}
+export declare class ActionModel {
+    constructor(initialData?: Record<string, any>);
+    private data;
+    toJSON(): Record<string, any>;
+    model_dump(options?: {
+        exclude_none?: boolean;
+    }): any;
+    model_dump_json(options?: {
+        exclude_none?: boolean;
+    }): string;
+    get_index(): number | null;
+    set_index(index: number): void;
+}
+export declare class ActionRegistry {
+    private actions;
+    register(action: RegisteredAction): void;
+    get(name: string): RegisteredAction | null;
+    getAll(): RegisteredAction[];
+    get actionsMap(): Map<string, RegisteredAction>;
+    get actionEntries(): RegisteredAction[];
+    private _matchDomains;
+    private _matchPageFilter;
+    getAvailableActions(page?: Page | null, includeActions?: string[] | null): RegisteredAction[];
+    get_prompt_description(page?: Page | null): string;
+}
+export declare class SpecialActionParameters {
+    context: any | null;
+    browser_session: BrowserSession | null;
+    browser: BrowserSession | null;
+    browser_context: BrowserSession | null;
+    page: Page | null;
+    page_extraction_llm: BaseChatModel | null;
+    file_system: FileSystem | null;
+    available_file_paths: string[] | null;
+    signal: AbortSignal | null;
+    has_sensitive_data: boolean;
+    static get_browser_requiring_params(): Set<string>;
+}
+export {};

package/dist/controller/registry/views.js

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+import { match_url_with_domain_pattern } from '../../utils.js';
+const getPageUrl = (page) => {
+    if (!page) {
+        return '';
+    }
+    const candidate = page.url;
+    if (typeof candidate === 'function') {
+        try {
+            return candidate.call(page);
+        }
+        catch {
+            return '';
+        }
+    }
+    return candidate ?? '';
+};
+export class RegisteredAction {
+    name;
+    description;
+    handler;
+    paramSchema;
+    domains;
+    pageFilter;
+    constructor(name, description, handler, paramSchema, domains = null, pageFilter = null) {
+        this.name = name;
+        this.description = description;
+        this.handler = handler;
+        this.paramSchema = paramSchema;
+        this.domains = domains;
+        this.pageFilter = pageFilter;
+    }
+    promptDescription() {
+        const skipKeys = new Set(['title']);
+        let description = `${this.description}: \n`;
+        description += `{${this.name}: `;
+        const schemaShape = (this.paramSchema instanceof z.ZodObject && this.paramSchema.shape) ||
+            ('shape' in this.paramSchema ? this.paramSchema.shape : null);
+        if (schemaShape) {
+            const props = Object.fromEntries(Object.entries(schemaShape).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];
+            }));
+            description += JSON.stringify(props);
+        }
+        else {
+            description += '{}';
+        }
+        description += '}';
+        return description;
+    }
+}
+export class ActionModel {
+    constructor(initialData = {}) {
+        this.data = initialData;
+    }
+    data;
+    toJSON() {
+        return this.data;
+    }
+    model_dump(options) {
+        const clone = JSON.parse(JSON.stringify(this.data));
+        if (options?.exclude_none) {
+            for (const [key, value] of Object.entries(clone)) {
+                if (value === null || value === undefined) {
+                    delete clone[key];
+                }
+            }
+        }
+        return clone;
+    }
+    model_dump_json(options) {
+        return JSON.stringify(this.model_dump(options));
+    }
+    get_index() {
+        for (const value of Object.values(this.data)) {
+            if (value && typeof value === 'object' && 'index' in value) {
+                return value.index ?? null;
+            }
+        }
+        return null;
+    }
+    set_index(index) {
+        const [actionName] = Object.keys(this.data);
+        if (!actionName) {
+            return;
+        }
+        const params = this.data[actionName];
+        if (params && typeof params === 'object' && 'index' in params) {
+            params.index = index;
+        }
+    }
+}
+export class ActionRegistry {
+    actions = new Map();
+    register(action) {
+        this.actions.set(action.name, action);
+    }
+    get(name) {
+        return this.actions.get(name) ?? null;
+    }
+    getAll() {
+        return Array.from(this.actions.values());
+    }
+    get actionsMap() {
+        return new Map(this.actions);
+    }
+    get actionEntries() {
+        return Array.from(this.actions.values());
+    }
+    _matchDomains(domains, pageUrl) {
+        if (!domains || domains.length === 0) {
+            return true;
+        }
+        if (!pageUrl) {
+            return false;
+        }
+        return domains.some((pattern) => {
+            try {
+                return match_url_with_domain_pattern(pageUrl, pattern);
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    _matchPageFilter(pageFilter, page) {
+        if (!pageFilter) {
+            return true;
+        }
+        try {
+            return pageFilter(page);
+        }
+        catch {
+            return false;
+        }
+    }
+    getAvailableActions(page, includeActions) {
+        const include = includeActions ? new Set(includeActions) : null;
+        return this.actionEntries.filter((action) => {
+            if (include && !include.has(action.name)) {
+                return false;
+            }
+            if (!page) {
+                return !action.pageFilter && !action.domains;
+            }
+            const pageUrl = getPageUrl(page);
+            const domainAllowed = this._matchDomains(action.domains, pageUrl);
+            const pageAllowed = this._matchPageFilter(action.pageFilter, page);
+            return domainAllowed && pageAllowed;
+        });
+    }
+    get_prompt_description(page) {
+        return this.getAvailableActions(page)
+            .map((action) => action.promptDescription())
+            .join('\n');
+    }
+}
+export class SpecialActionParameters {
+    context = null;
+    browser_session = null;
+    browser = null;
+    browser_context = null;
+    page = null;
+    page_extraction_llm = null;
+    file_system = null;
+    available_file_paths = null;
+    signal = null;
+    has_sensitive_data = false;
+    static get_browser_requiring_params() {
+        return new Set(['browser_session', 'browser', 'browser_context', 'page']);
+    }
+}

package/dist/controller/service.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { ActionResult } from '../agent/views.js';
+import { FileSystem } from '../filesystem/file-system.js';
+import { Registry } from './registry/service.js';
+type BrowserSession = any;
+type BaseChatModel = {
+    ainvoke: (messages: any[], output_format?: undefined, options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        completion: string;
+    }>;
+};
+export interface ControllerOptions<Context = unknown> {
+    exclude_actions?: string[];
+    output_model?: z.ZodTypeAny | null;
+    display_files_in_done_text?: boolean;
+    context?: Context;
+}
+export interface ActParams<Context = unknown> {
+    browser_session: BrowserSession;
+    page_extraction_llm?: BaseChatModel | null;
+    sensitive_data?: Record<string, string | Record<string, string>> | null;
+    available_file_paths?: string[] | null;
+    file_system?: FileSystem | null;
+    context?: Context | null;
+    signal?: AbortSignal | null;
+}
+export declare class Controller<Context = unknown> {
+    registry: Registry<Context>;
+    private displayFilesInDoneText;
+    private logger;
+    constructor(options?: ControllerOptions<Context>);
+    private registerDefaultActions;
+    private registerNavigationActions;
+    private registerElementActions;
+    private registerTabActions;
+    private registerContentActions;
+    private registerScrollActions;
+    private registerFileSystemActions;
+    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>;
+    act(action: Record<string, unknown>, { browser_session, page_extraction_llm, sensitive_data, available_file_paths, file_system, context, signal, }: ActParams<Context>): Promise<ActionResult>;
+}
+export {};