browser-use 0.3.0 → 0.5.0

package/README.md

@@ -95,13 +95,13 @@ npx browser-use --mcp
 
 ```
 ┌─────────────────────────────────────────────────────┐
-│                    Browser-Use                       │
+│                    Browser-Use                      │
 ├─────────────────────────────────────────────────────┤
-│  Agent ← MessageManager ← LLM Providers            │
-│    ↓                                                 │
+│  Agent ← MessageManager ← LLM Providers             │
+│    ↓                                                │
 │  Controller → Action Registry → BrowserSession      │
-│                                      ↓               │
-│                                  DomService          │
+│                                      ↓              │
+│                                  DomService         │
 └─────────────────────────────────────────────────────┘
 ```
 
@@ -396,23 +396,23 @@ const agent = new Agent({
 
 ```bash
 # Install dependencies
-npm install
+pnpm install
 
 # Build
-npm run build
+pnpm build
 
 # Run tests
-npm test
+pnpm test
 
 # Lint & format
-npm run lint
-npm run prettier
+pnpm lint
+pnpm prettier
 
 # Type checking
-npm run typecheck
+pnpm typecheck
 
 # Run an example
-npx tsx examples/simple-search.ts
+pnpm exec tsx examples/simple-search.ts
 ```
 
 ## Requirements

package/dist/actor/page.d.ts

@@ -7,7 +7,7 @@ export declare class Page {
     private _mouse;
     constructor(browser_session: BrowserSession);
     get mouse(): Mouse;
-    _currentPage(): Promise<import("playwright-core").Page>;
+    _currentPage(): Promise<import("playwright").Page>;
     get_url(): Promise<string>;
     get_title(): Promise<string>;
     goto(url: string, options?: {

package/dist/agent/service.d.ts

@@ -332,6 +332,10 @@ export declare class Agent<Context = ControllerContext, AgentStructuredOutput =
     private _replace_shortened_urls_in_value;
     private _parseCompletionPayload;
     private _isModelActionMissing;
+    private _getOutputActionNames;
+    private _toStrictActionParamSchema;
+    private _buildActionOutputSchema;
+    private _buildLlmOutputFormat;
     private _get_model_output_with_retry;
     private _try_switch_to_fallback_llm;
     private _log_fallback_switch;

package/dist/agent/service.js

@@ -3633,13 +3633,83 @@ export class Agent {
             return Object.keys(candidate).length === 0;
         });
     }
+    _getOutputActionNames(doneOnly) {
+        const registryActions = this.controller.registry.get_all_actions();
+        const modelForStep = doneOnly
+            ? this.DoneActionModel
+            : this.ActionModel;
+        const modelAvailableNames = modelForStep?.available_actions;
+        if (Array.isArray(modelAvailableNames) && modelAvailableNames.length > 0) {
+            const deduped = Array.from(new Set(modelAvailableNames.filter((name) => typeof name === 'string' &&
+                name.trim().length > 0 &&
+                registryActions.has(name))));
+            if (deduped.length > 0) {
+                return deduped;
+            }
+        }
+        if (doneOnly && registryActions.has('done')) {
+            return ['done'];
+        }
+        return Array.from(registryActions.keys());
+    }
+    _toStrictActionParamSchema(schema) {
+        if (schema instanceof z.ZodObject) {
+            return schema.strict();
+        }
+        return schema;
+    }
+    _buildActionOutputSchema(doneOnly) {
+        const registryActions = this.controller.registry.get_all_actions();
+        const actionSchemas = this._getOutputActionNames(doneOnly)
+            .map((actionName) => {
+            const actionInfo = registryActions.get(actionName);
+            if (!actionInfo) {
+                return null;
+            }
+            const paramSchema = this._toStrictActionParamSchema(actionInfo.paramSchema);
+            return z.object({ [actionName]: paramSchema }).strict();
+        })
+            .filter((schema) => schema != null);
+        if (actionSchemas.length === 0) {
+            const doneAction = registryActions.get('done');
+            if (doneAction) {
+                const doneParams = this._toStrictActionParamSchema(doneAction.paramSchema);
+                return z.object({ done: doneParams }).strict();
+            }
+            return z.object({ done: z.object({}).strict() }).strict();
+        }
+        if (actionSchemas.length === 1) {
+            return actionSchemas[0];
+        }
+        const [firstActionSchema, secondActionSchema, ...remainingActionSchemas] = actionSchemas;
+        return z.union([
+            firstActionSchema,
+            secondActionSchema,
+            ...remainingActionSchemas,
+        ]);
+    }
+    _buildLlmOutputFormat(doneOnly) {
+        const schema = z.object({
+            thinking: z.string().optional().nullable(),
+            evaluation_previous_goal: z.string().optional().nullable(),
+            memory: z.string().optional().nullable(),
+            next_goal: z.string().optional().nullable(),
+            current_plan_item: z.number().int().optional().nullable(),
+            plan_update: z.array(z.string()).optional().nullable(),
+            action: z
+                .array(this._buildActionOutputSchema(doneOnly))
+                .optional()
+                .nullable(),
+        });
+        const outputFormat = schema;
+        outputFormat.schema = schema;
+        return outputFormat;
+    }
     async _get_model_output_with_retry(messages, signal = null) {
         const urlReplacements = this._process_messages_and_replace_long_urls_shorter_ones(messages);
         const invokeAndParse = async (inputMessages) => {
             this._throwIfAborted(signal);
-            const outputFormat = this._enforceDoneOnlyForCurrentStep
-                ? DoneOnlyLLMOutputFormat
-                : AgentLLMOutputFormat;
+            const outputFormat = this._buildLlmOutputFormat(this._enforceDoneOnlyForCurrentStep);
             const completion = await this.llm.ainvoke(inputMessages, outputFormat, {
                 signal: signal ?? undefined,
                 session_id: this.session_id,

package/dist/browser/profile.d.ts

@@ -173,9 +173,9 @@ export declare class BrowserProfile {
     get traces_dir(): Nullable<string>;
     get user_data_dir(): Nullable<string>;
     get viewport_expansion(): number;
-    get viewport(): Nullable<import("playwright-core").ViewportSize>;
+    get viewport(): Nullable<import("playwright").ViewportSize>;
     get wait_for_network_idle_page_load_time(): number;
-    get window_size(): Nullable<import("playwright-core").ViewportSize>;
+    get window_size(): Nullable<import("playwright").ViewportSize>;
     private applyLegacyWindowSize;
     private warnStorageStateUserDataDirConflict;
     private warnUserDataDirNonDefault;

package/dist/browser/profile.js

@@ -360,10 +360,17 @@ const DEFAULT_BROWSER_PROFILE_OPTIONS = {
     profile_directory: 'Default',
     cookies_file: null,
 };
+const splitArgOnce = (arg) => {
+    const separatorIndex = arg.indexOf('=');
+    if (separatorIndex === -1) {
+        return [arg, ''];
+    }
+    return [arg.slice(0, separatorIndex), arg.slice(separatorIndex + 1)];
+};
 const argsAsDict = (args) => {
     const result = {};
     for (const arg of args) {
-        const [keyPart, valuePart = ''] = arg.split('=', 1);
+        const [keyPart, valuePart = ''] = splitArgOnce(arg);
         const key = keyPart.trim().replace(/^-+/, '');
         result[key] = valuePart.trim();
     }
@@ -376,9 +383,22 @@ const cloneDefaultOptions = () => JSON.parse(JSON.stringify(DEFAULT_BROWSER_PROF
 const normalizeDomainEntry = (entry) => String(entry ?? '')
     .trim()
     .toLowerCase();
+const isExactHostDomainEntry = (entry) => {
+    if (!entry) {
+        return false;
+    }
+    if (entry.includes('*') || entry.includes('://') || entry.includes('/')) {
+        return false;
+    }
+    // Keep set optimization for plain hostnames only. Entries with ports/pattern-like
+    // delimiters must stay as arrays to preserve wildcard/scheme matching semantics.
+    return !entry.includes(':');
+};
 const optimizeDomainList = (value) => {
     const cleaned = value.map(normalizeDomainEntry).filter(Boolean);
-    if (cleaned.length >= DOMAIN_OPTIMIZATION_THRESHOLD) {
+    const canOptimizeToSet = cleaned.length >= DOMAIN_OPTIMIZATION_THRESHOLD &&
+        cleaned.every(isExactHostDomainEntry);
+    if (canOptimizeToSet) {
         logger.warning(`Optimizing domain list with ${cleaned.length} entries to a Set for O(1) matching`);
         return new Set(cleaned);
     }
@@ -407,16 +427,12 @@ export class BrowserProfile {
             allowed_domains: Array.isArray(init.allowed_domains)
                 ? optimizeDomainList(init.allowed_domains)
                 : init.allowed_domains instanceof Set
-                    ? new Set(Array.from(init.allowed_domains)
-                        .map(normalizeDomainEntry)
-                        .filter(Boolean))
+                    ? optimizeDomainList(Array.from(init.allowed_domains))
                     : defaults.allowed_domains,
             prohibited_domains: Array.isArray(init.prohibited_domains)
                 ? optimizeDomainList(init.prohibited_domains)
                 : init.prohibited_domains instanceof Set
-                    ? new Set(Array.from(init.prohibited_domains)
-                        .map(normalizeDomainEntry)
-                        .filter(Boolean))
+                    ? optimizeDomainList(Array.from(init.prohibited_domains))
                     : defaults.prohibited_domains,
             window_position: init.window_position ?? defaults.window_position,
         };

package/dist/browser/session.d.ts

@@ -96,6 +96,8 @@ export declare class BrowserSession {
     get_or_create_cdp_session(page?: Page | null): Promise<any>;
     private _waitForStableNetwork;
     private _setActivePage;
+    private _syncCurrentTabFromPage;
+    private _syncTabsWithBrowserPages;
     private _captureClosedPopupMessage;
     private _getClosedPopupMessagesSnapshot;
     private _recordRecentEvent;
@@ -145,13 +147,13 @@ export declare class BrowserSession {
     private _shutdown_browser_session;
     close(): Promise<void>;
     get_browser_state_with_recovery(options?: BrowserStateOptions): Promise<BrowserStateSummary>;
-    get_current_page(): Promise<import("playwright-core").Page | null>;
+    get_current_page(): Promise<import("playwright").Page | null>;
     update_current_page(page: Page | null, title?: string | null, url?: string | null): void;
     private _buildTabs;
-    navigate_to(url: string, options?: BrowserNavigationOptions): Promise<import("playwright-core").Page | null>;
-    create_new_tab(url: string, options?: BrowserNavigationOptions): Promise<import("playwright-core").Page | null>;
+    navigate_to(url: string, options?: BrowserNavigationOptions): Promise<import("playwright").Page | null>;
+    create_new_tab(url: string, options?: BrowserNavigationOptions): Promise<import("playwright").Page | null>;
     private _resolveTabIndex;
-    switch_to_tab(identifier: number | string, options?: BrowserActionOptions): Promise<import("playwright-core").Page | null>;
+    switch_to_tab(identifier: number | string, options?: BrowserActionOptions): Promise<import("playwright").Page | null>;
     close_tab(identifier: number | string): Promise<void>;
     wait(seconds: number, options?: BrowserActionOptions): Promise<void>;
     send_keys(keys: string, options?: BrowserActionOptions): Promise<void>;
@@ -327,6 +329,7 @@ export declare class BrowserSession {
     private _is_new_tab_page;
     private _is_ip_address_host;
     private _get_domain_variants;
+    private _setEntryMatchesUrl;
     /**
      * Check if page is displaying a PDF
      */
@@ -530,6 +533,10 @@ export declare class BrowserSession {
      * Updates human_current_page to reflect which tab the user is viewing
      */
     private _onTabVisibilityChange;
+    /**
+     * Normalize pid values before issuing process operations.
+     */
+    private _normalizePid;
     /**
      * Kill all child processes spawned by this browser session
      */