browser-use 0.3.0 → 0.4.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/session.d.ts

@@ -145,13 +145,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>;
@@ -530,6 +530,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
      */

package/dist/browser/session.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { isIP } from 'node:net';
-import { exec } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createLogger } from '../logging-config.js';
 import { match_url_with_domain_pattern, uuid7str } from '../utils.js';
@@ -30,7 +30,7 @@ import { RecordingWatchdog } from './watchdogs/recording-watchdog.js';
 import { ScreenshotWatchdog } from './watchdogs/screenshot-watchdog.js';
 import { SecurityWatchdog } from './watchdogs/security-watchdog.js';
 import { StorageStateWatchdog } from './watchdogs/storage-state-watchdog.js';
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 const createEmptyDomState = () => {
     const root = new DOMElementNode(true, null, 'html', '/html[1]', {}, []);
     return new DOMState(root, {});
@@ -1760,13 +1760,12 @@ export class BrowserSession {
                             text: opt.textContent?.trim() ?? '',
                             value: (opt.value ?? '').trim(),
                         }));
-                        const normalize = (value) => value.trim().toLowerCase();
                         const targetRaw = optionText.trim();
-                        const targetLower = normalize(optionText);
+                        const targetLower = optionText.trim().toLowerCase();
                         let matchedIndex = options.findIndex((opt) => opt.text === targetRaw || opt.value === targetRaw);
                         if (matchedIndex < 0) {
-                            matchedIndex = options.findIndex((opt) => normalize(opt.text) === targetLower ||
-                                normalize(opt.value) === targetLower);
+                            matchedIndex = options.findIndex((opt) => opt.text.trim().toLowerCase() === targetLower ||
+                                opt.value.trim().toLowerCase() === targetLower);
                         }
                         if (matchedIndex < 0) {
                             return { found: true, success: false, options };
@@ -1780,8 +1779,16 @@ export class BrowserSession {
                             : null;
                         const selectedText = selectedOption?.textContent?.trim() ?? '';
                         const selectedValue = (root.value ?? '').trim();
-                        const verified = normalize(selectedValue) === normalize(matched.value) ||
-                            normalize(selectedText) === normalize(matched.text);
+                        const selectedValueLower = selectedValue.trim().toLowerCase();
+                        const selectedTextLower = selectedText.trim().toLowerCase();
+                        const matchedValueLower = String(matched.value ?? '')
+                            .trim()
+                            .toLowerCase();
+                        const matchedTextLower = String(matched.text ?? '')
+                            .trim()
+                            .toLowerCase();
+                        const verified = selectedValueLower === matchedValueLower ||
+                            selectedTextLower === matchedTextLower;
                         return {
                             found: true,
                             success: verified,
@@ -1819,13 +1826,12 @@ export class BrowserSession {
                         text: node.textContent?.trim() ?? '',
                         value: node.textContent?.trim() ?? '',
                     }));
-                    const normalize = (value) => value.trim().toLowerCase();
                     const targetRaw = optionText.trim();
-                    const targetLower = normalize(optionText);
+                    const targetLower = optionText.trim().toLowerCase();
                     let matchedIndex = options.findIndex((opt) => opt.text === targetRaw || opt.value === targetRaw);
                     if (matchedIndex < 0) {
-                        matchedIndex = options.findIndex((opt) => normalize(opt.text) === targetLower ||
-                            normalize(opt.value) === targetLower);
+                        matchedIndex = options.findIndex((opt) => opt.text.trim().toLowerCase() === targetLower ||
+                            opt.value.trim().toLowerCase() === targetLower);
                     }
                     if (matchedIndex < 0) {
                         return { found: true, success: false, options };
@@ -4272,6 +4278,16 @@ export class BrowserSession {
     }
     // endregion
     // region - Process Management
+    /**
+     * Normalize pid values before issuing process operations.
+     */
+    _normalizePid(pid) {
+        if (!Number.isSafeInteger(pid) || pid <= 0) {
+            this.logger.debug(`Skipping process operation for invalid pid: ${String(pid)}`);
+            return null;
+        }
+        return pid;
+    }
     /**
      * Kill all child processes spawned by this browser session
      */
@@ -4280,17 +4296,17 @@ export class BrowserSession {
             return;
         }
         this.logger.debug(`Killing ${this._childProcesses.size} child processes`);
-        for (const pid of this._childProcesses) {
+        for (const trackedPid of this._childProcesses) {
+            const pid = this._normalizePid(trackedPid);
+            if (!pid) {
+                continue;
+            }
             try {
-                // Try to kill the process
                 process.kill(pid, 'SIGTERM');
                 this.logger.debug(`Sent SIGTERM to process ${pid}`);
-                // Wait briefly and check if still alive
                 await new Promise((resolve) => setTimeout(resolve, 500));
                 try {
-                    // Check if process still exists
                     process.kill(pid, 0);
-                    // If we get here, process is still alive, force kill
                     process.kill(pid, 'SIGKILL');
                     this.logger.debug(`Sent SIGKILL to process ${pid}`);
                 }
@@ -4299,7 +4315,6 @@ export class BrowserSession {
                 }
             }
             catch (error) {
-                // Process doesn't exist or we don't have permission
                 this.logger.debug(`Could not kill process ${pid}: ${error.message}`);
             }
         }
@@ -4309,39 +4324,39 @@ export class BrowserSession {
      * Terminate the browser process and all its children
      */
     async _terminateBrowserProcess() {
-        if (!this.browser_pid) {
+        const browserPid = this._normalizePid(this.browser_pid);
+        if (!browserPid) {
             return;
         }
         try {
-            this.logger.debug(`Terminating browser process ${this.browser_pid}`);
-            // Platform-specific process tree termination
+            this.logger.debug(`Terminating browser process ${browserPid}`);
             if (process.platform === 'win32') {
-                // Windows: use taskkill to kill process tree
-                await execAsync(`taskkill /PID ${this.browser_pid} /T /F`).catch(() => {
+                await execFileAsync('taskkill', [
+                    '/PID',
+                    String(browserPid),
+                    '/T',
+                    '/F',
+                ]).catch(() => {
                     // Ignore errors if process already dead
                 });
             }
             else {
-                // Unix-like: kill process group
                 try {
-                    // Try to kill the process group
-                    process.kill(-this.browser_pid, 'SIGTERM');
+                    process.kill(-browserPid, 'SIGTERM');
                     await new Promise((resolve) => setTimeout(resolve, 1000));
-                    // Check if still alive and force kill if needed
                     try {
-                        process.kill(-this.browser_pid, 0);
-                        process.kill(-this.browser_pid, 'SIGKILL');
+                        process.kill(-browserPid, 0);
+                        process.kill(-browserPid, 'SIGKILL');
                     }
                     catch {
                         // Process is dead
                     }
                 }
                 catch {
-                    // Fallback to killing just the process
                     try {
-                        process.kill(this.browser_pid, 'SIGTERM');
+                        process.kill(browserPid, 'SIGTERM');
                         await new Promise((resolve) => setTimeout(resolve, 1000));
-                        process.kill(this.browser_pid, 'SIGKILL');
+                        process.kill(browserPid, 'SIGKILL');
                     }
                     catch {
                         // Process doesn't exist
@@ -4358,26 +4373,37 @@ export class BrowserSession {
      * Cross-platform implementation using ps on Unix-like systems and WMIC on Windows
      */
     async _getChildProcesses(pid) {
+        const normalizedPid = this._normalizePid(pid);
+        if (!normalizedPid) {
+            return [];
+        }
         try {
             if (process.platform === 'win32') {
-                // Windows: use WMIC
-                const { stdout } = await execAsync(`wmic process where (ParentProcessId=${pid}) get ProcessId`);
-                const pids = stdout
-                    .split('\n')
-                    .slice(1) // Skip header
-                    .map((line) => parseInt(line.trim(), 10))
-                    .filter((p) => !isNaN(p));
-                return pids;
-            }
-            else {
-                // Unix-like: use ps
-                const { stdout } = await execAsync(`ps -o pid= --ppid ${pid}`);
+                const { stdout } = await execFileAsync('wmic', [
+                    'process',
+                    'where',
+                    `ParentProcessId=${normalizedPid}`,
+                    'get',
+                    'ProcessId',
+                ]);
                 const pids = stdout
                     .split('\n')
+                    .slice(1)
                     .map((line) => parseInt(line.trim(), 10))
-                    .filter((p) => !isNaN(p));
+                    .filter((p) => Number.isFinite(p));
                 return pids;
             }
+            const { stdout } = await execFileAsync('ps', [
+                '-o',
+                'pid=',
+                '--ppid',
+                String(normalizedPid),
+            ]);
+            const pids = stdout
+                .split('\n')
+                .map((line) => parseInt(line.trim(), 10))
+                .filter((p) => Number.isFinite(p));
+            return pids;
         }
         catch {
             return [];
@@ -4387,13 +4413,19 @@ export class BrowserSession {
      * Track a child process
      */
     _trackChildProcess(pid) {
-        this._childProcesses.add(pid);
+        const normalizedPid = this._normalizePid(pid);
+        if (normalizedPid) {
+            this._childProcesses.add(normalizedPid);
+        }
     }
     /**
      * Untrack a child process
      */
     _untrackChildProcess(pid) {
-        this._childProcesses.delete(pid);
+        const normalizedPid = this._normalizePid(pid);
+        if (normalizedPid) {
+            this._childProcesses.delete(normalizedPid);
+        }
     }
     // region: Loading Animations
     /**