browser-use 0.0.1 → 0.0.2

package/dist/agent/views.js

@@ -0,0 +1,537 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ActionModel } from '../controller/registry/views.js';
+import { BrowserStateHistory } from '../browser/views.js';
+import { HistoryTreeProcessor } from '../dom/history-tree-processor/service.js';
+import { MessageManagerState } from './message-manager/views.js';
+// Re-export ActionModel for agent/service.ts
+export { ActionModel };
+const parseStructuredOutput = (schema, value) => {
+    if (!schema) {
+        return null;
+    }
+    if (schema.parse) {
+        return schema.parse(value);
+    }
+    if (schema.model_validate_json) {
+        return schema.model_validate_json(value);
+    }
+    return null;
+};
+export class ActionResult {
+    is_done;
+    success;
+    error;
+    attachments;
+    long_term_memory;
+    extracted_content;
+    include_extracted_content_only_once;
+    include_in_memory;
+    constructor(init = {}) {
+        this.is_done = init.is_done ?? false;
+        this.success = init.success ?? null;
+        this.error = init.error ?? null;
+        this.attachments = init.attachments ?? null;
+        this.long_term_memory = init.long_term_memory ?? null;
+        this.extracted_content = init.extracted_content ?? null;
+        this.include_extracted_content_only_once =
+            init.include_extracted_content_only_once ?? false;
+        this.include_in_memory = init.include_in_memory ?? false;
+        this.validate();
+    }
+    validate() {
+        if (this.success === true && this.is_done !== true) {
+            throw new Error('success=True can only be set when is_done=True. For regular actions that succeed, leave success as None. Use success=False only for actions that fail.');
+        }
+    }
+    toJSON() {
+        return {
+            is_done: this.is_done,
+            success: this.success,
+            error: this.error,
+            attachments: this.attachments,
+            long_term_memory: this.long_term_memory,
+            extracted_content: this.extracted_content,
+            include_extracted_content_only_once: this.include_extracted_content_only_once,
+            include_in_memory: this.include_in_memory,
+        };
+    }
+    model_dump() {
+        return this.toJSON();
+    }
+    model_dump_json() {
+        return JSON.stringify(this.toJSON());
+    }
+}
+export const defaultAgentSettings = () => ({
+    session_attachment_mode: 'copy',
+    use_vision: true,
+    vision_detail_level: 'auto',
+    use_vision_for_planner: false,
+    save_conversation_path: null,
+    save_conversation_path_encoding: 'utf-8',
+    max_failures: 3,
+    retry_delay: 10,
+    validate_output: false,
+    generate_gif: false,
+    override_system_message: null,
+    extend_system_message: null,
+    include_attributes: [
+        'title',
+        'type',
+        'name',
+        'role',
+        'tabindex',
+        'aria-label',
+        'placeholder',
+        'value',
+        'alt',
+        'aria-expanded',
+    ],
+    max_actions_per_step: 10,
+    use_thinking: true,
+    flash_mode: false,
+    max_history_items: null,
+    page_extraction_llm: null,
+    planner_llm: null,
+    planner_interval: 1,
+    is_planner_reasoning: false,
+    extend_planner_system_message: null,
+    calculate_cost: false,
+    include_tool_call_examples: false,
+    llm_timeout: 60,
+    step_timeout: 180,
+});
+export class AgentState {
+    agent_id;
+    n_steps;
+    consecutive_failures;
+    last_result;
+    last_plan;
+    last_model_output;
+    paused;
+    stopped;
+    message_manager_state;
+    file_system_state;
+    constructor(init) {
+        this.agent_id = init?.agent_id ?? '';
+        this.n_steps = init?.n_steps ?? 1;
+        this.consecutive_failures = init?.consecutive_failures ?? 0;
+        this.last_result = init?.last_result ?? null;
+        this.last_plan = init?.last_plan ?? null;
+        this.last_model_output = init?.last_model_output ?? null;
+        this.paused = init?.paused ?? false;
+        this.stopped = init?.stopped ?? false;
+        if (init?.message_manager_state instanceof MessageManagerState) {
+            this.message_manager_state = init.message_manager_state;
+        }
+        else if (init?.message_manager_state) {
+            this.message_manager_state = Object.assign(new MessageManagerState(), init.message_manager_state);
+        }
+        else {
+            this.message_manager_state = new MessageManagerState();
+        }
+        this.file_system_state = init?.file_system_state ?? null;
+    }
+    model_dump() {
+        return {
+            agent_id: this.agent_id,
+            n_steps: this.n_steps,
+            consecutive_failures: this.consecutive_failures,
+            last_result: this.last_result?.map((result) => result.model_dump()) ?? null,
+            last_plan: this.last_plan,
+            last_model_output: this.last_model_output?.model_dump() ?? null,
+            paused: this.paused,
+            stopped: this.stopped,
+            message_manager_state: JSON.parse(JSON.stringify(this.message_manager_state)),
+            file_system_state: this.file_system_state,
+        };
+    }
+    toJSON() {
+        return this.model_dump();
+    }
+}
+export class AgentStepInfo {
+    step_number;
+    max_steps;
+    constructor(step_number, max_steps) {
+        this.step_number = step_number;
+        this.max_steps = max_steps;
+    }
+    is_last_step() {
+        return this.step_number >= this.max_steps - 1;
+    }
+}
+export class StepMetadata {
+    step_start_time;
+    step_end_time;
+    step_number;
+    constructor(step_start_time, step_end_time, step_number) {
+        this.step_start_time = step_start_time;
+        this.step_end_time = step_end_time;
+        this.step_number = step_number;
+    }
+    get duration_seconds() {
+        return this.step_end_time - this.step_start_time;
+    }
+}
+export class AgentOutput {
+    thinking;
+    evaluation_previous_goal;
+    memory;
+    next_goal;
+    action;
+    constructor(init) {
+        this.thinking = init?.thinking ?? null;
+        this.evaluation_previous_goal = init?.evaluation_previous_goal ?? null;
+        this.memory = init?.memory ?? null;
+        this.next_goal = init?.next_goal ?? null;
+        this.action = (init?.action ?? []).map((entry) => entry instanceof ActionModel ? entry : new ActionModel(entry));
+    }
+    get current_state() {
+        return {
+            thinking: this.thinking,
+            evaluation_previous_goal: this.evaluation_previous_goal ?? '',
+            memory: this.memory ?? '',
+            next_goal: this.next_goal ?? '',
+        };
+    }
+    model_dump() {
+        return {
+            thinking: this.thinking,
+            evaluation_previous_goal: this.evaluation_previous_goal,
+            memory: this.memory,
+            next_goal: this.next_goal,
+            action: this.action.map((action) => action.model_dump?.() ?? action),
+        };
+    }
+    model_dump_json() {
+        return JSON.stringify(this.model_dump());
+    }
+    toJSON() {
+        return this.model_dump();
+    }
+    static fromJSON(data) {
+        if (!data) {
+            return new AgentOutput();
+        }
+        const actions = Array.isArray(data.action)
+            ? data.action.map((item) => new ActionModel(item))
+            : [];
+        return new AgentOutput({
+            thinking: data.thinking ?? null,
+            evaluation_previous_goal: data.evaluation_previous_goal ?? null,
+            memory: data.memory ?? null,
+            next_goal: data.next_goal ?? null,
+            action: actions,
+        });
+    }
+    static type_with_custom_actions(custom_actions) {
+        const CustomActionModel = custom_actions;
+        return class AgentOutputWithCustomActions extends AgentOutput {
+            constructor(init) {
+                super(init);
+                this.action = (init?.action ?? []).map((entry) => entry instanceof CustomActionModel
+                    ? entry
+                    : new CustomActionModel(entry?.model_dump?.() ?? entry));
+            }
+        };
+    }
+    static type_with_custom_actions_no_thinking(custom_actions) {
+        const BaseModel = AgentOutput.type_with_custom_actions(custom_actions);
+        return class AgentOutputWithoutThinking extends BaseModel {
+            constructor(init) {
+                super(init);
+                this.thinking = null;
+            }
+        };
+    }
+    static type_with_custom_actions_flash_mode(custom_actions) {
+        const BaseModel = AgentOutput.type_with_custom_actions(custom_actions);
+        return class AgentOutputFlashMode extends BaseModel {
+            constructor(init) {
+                super(init);
+                this.thinking = null;
+                this.evaluation_previous_goal = null;
+                this.next_goal = null;
+            }
+        };
+    }
+}
+export class AgentHistory {
+    model_output;
+    result;
+    state;
+    metadata;
+    constructor(model_output, result, state, metadata = null) {
+        this.model_output = model_output;
+        this.result = result;
+        this.state = state;
+        this.metadata = metadata;
+    }
+    static get_interacted_element(model_output, selector_map) {
+        const elements = [];
+        for (const action of model_output.action) {
+            const index = typeof action.get_index === 'function' ? action.get_index() : null;
+            if (index != null && selector_map[index]) {
+                const node = selector_map[index];
+                elements.push(HistoryTreeProcessor.convert_dom_element_to_history_element(node));
+            }
+            else {
+                elements.push(null);
+            }
+        }
+        return elements;
+    }
+    toJSON() {
+        return {
+            model_output: this.model_output?.toJSON() ?? null,
+            result: this.result.map((r) => r.toJSON()),
+            state: this.state.to_dict(),
+            metadata: this.metadata
+                ? {
+                    step_start_time: this.metadata.step_start_time,
+                    step_end_time: this.metadata.step_end_time,
+                    step_number: this.metadata.step_number,
+                }
+                : null,
+        };
+    }
+}
+export class AgentHistoryList {
+    history;
+    usage;
+    _output_model_schema = null;
+    constructor(history = [], usage = null) {
+        this.history = history;
+        this.usage = usage ?? null;
+    }
+    total_duration_seconds() {
+        return this.history.reduce((sum, item) => sum + (item.metadata?.duration_seconds ?? 0), 0);
+    }
+    add_item(history_item) {
+        this.history.push(history_item);
+    }
+    last_action() {
+        if (!this.history.length) {
+            return null;
+        }
+        const last = this.history[this.history.length - 1];
+        if (!last.model_output || !last.model_output.action.length) {
+            return null;
+        }
+        const action = last.model_output.action[last.model_output.action.length - 1];
+        if (typeof action?.model_dump === 'function') {
+            return action.model_dump();
+        }
+        return action;
+    }
+    errors() {
+        return this.history.map((historyItem) => {
+            const error = historyItem.result.find((result) => result.error);
+            return error?.error ?? null;
+        });
+    }
+    final_result() {
+        if (!this.history.length) {
+            return null;
+        }
+        const last = this.history[this.history.length - 1];
+        const result = last.result[last.result.length - 1];
+        return result?.extracted_content ?? null;
+    }
+    is_done() {
+        if (!this.history.length) {
+            return false;
+        }
+        const last = this.history[this.history.length - 1];
+        const result = last.result[last.result.length - 1];
+        return result?.is_done === true;
+    }
+    is_successful() {
+        if (!this.history.length) {
+            return null;
+        }
+        const last = this.history[this.history.length - 1];
+        const result = last.result[last.result.length - 1];
+        if (result?.is_done) {
+            return result.success ?? null;
+        }
+        return null;
+    }
+    has_errors() {
+        return this.errors().some((error) => error != null);
+    }
+    urls() {
+        return this.history.map((item) => item.state.url ?? null);
+    }
+    screenshot_paths(n_last = null, return_none_if_not_screenshot = true) {
+        if (n_last === 0) {
+            return [];
+        }
+        const items = n_last == null ? this.history : this.history.slice(-n_last);
+        return items
+            .map((item) => item.state.screenshot_path ?? null)
+            .filter((pathValue) => return_none_if_not_screenshot || pathValue !== null);
+    }
+    screenshots(n_last = null, return_none_if_not_screenshot = true) {
+        if (n_last === 0) {
+            return [];
+        }
+        const items = n_last == null ? this.history : this.history.slice(-n_last);
+        const screenshots = [];
+        for (const item of items) {
+            const screenshot = item.state.get_screenshot();
+            if (screenshot) {
+                screenshots.push(screenshot);
+            }
+            else if (return_none_if_not_screenshot) {
+                screenshots.push(null);
+            }
+        }
+        return screenshots;
+    }
+    action_names() {
+        const names = [];
+        for (const action of this.model_actions()) {
+            const [name] = Object.keys(action);
+            if (name) {
+                names.push(name);
+            }
+        }
+        return names;
+    }
+    model_thoughts() {
+        return this.history
+            .filter((item) => item.model_output)
+            .map((item) => item.model_output.current_state);
+    }
+    model_outputs() {
+        return (this.history
+            .filter((item) => item.model_output)
+            .map((item) => item.model_output) ?? []);
+    }
+    model_actions() {
+        const outputs = [];
+        for (const item of this.history) {
+            if (!item.model_output) {
+                continue;
+            }
+            const interacted = item.state.interacted_element ?? [];
+            for (let index = 0; index < item.model_output.action.length; index += 1) {
+                const action = item.model_output.action[index];
+                const interactedElement = interacted[index] ?? null;
+                const payload = typeof action?.model_dump === 'function'
+                    ? action.model_dump()
+                    : action;
+                if (payload && typeof payload === 'object' && interactedElement) {
+                    payload.interacted_element =
+                        interactedElement;
+                }
+                else if (payload && typeof payload === 'object') {
+                    payload.interacted_element =
+                        interactedElement;
+                }
+                outputs.push(payload);
+            }
+        }
+        return outputs;
+    }
+    action_history() {
+        const history = [];
+        for (const item of this.history) {
+            const stepActions = [];
+            if (item.model_output) {
+                const interacted = item.state.interacted_element ?? [];
+                for (let index = 0; index < item.model_output.action.length; index += 1) {
+                    const action = item.model_output.action[index];
+                    const interactedElement = interacted[index] ?? null;
+                    const result = item.result[index];
+                    const payload = typeof action?.model_dump === 'function'
+                        ? action.model_dump()
+                        : action;
+                    const enriched = payload && typeof payload === 'object'
+                        ? { ...payload }
+                        : { action: payload };
+                    enriched.interacted_element = interactedElement;
+                    enriched.result = result?.long_term_memory ?? null;
+                    stepActions.push(enriched);
+                }
+            }
+            history.push(stepActions);
+        }
+        return history;
+    }
+    action_results() {
+        return this.history.flatMap((item) => item.result);
+    }
+    extracted_content() {
+        return this.history.flatMap((item) => item.result.map((result) => result.extracted_content).filter(Boolean));
+    }
+    model_actions_filtered(include = []) {
+        if (!include.length) {
+            return this.model_actions();
+        }
+        return this.model_actions().filter((action) => {
+            const [name] = Object.keys(action);
+            return include.includes(name);
+        });
+    }
+    number_of_steps() {
+        return this.history.length;
+    }
+    get structured_output() {
+        const final_result = this.final_result();
+        if (!final_result || !this._output_model_schema) {
+            return null;
+        }
+        return parseStructuredOutput(this._output_model_schema, final_result);
+    }
+    save_to_file(filepath) {
+        const dir = path.dirname(filepath);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(filepath, JSON.stringify(this.toJSON(), null, 2), 'utf-8');
+    }
+    static load_from_file(filepath, outputModel) {
+        const content = fs.readFileSync(filepath, 'utf-8');
+        const payload = JSON.parse(content);
+        const historyItems = (payload.history ?? []).map((entry) => {
+            const modelOutput = entry.model_output
+                ? outputModel.fromJSON(entry.model_output)
+                : null;
+            const result = (entry.result ?? []).map((item) => new ActionResult(item));
+            const state = new BrowserStateHistory(entry.state?.url ?? '', entry.state?.title ?? '', entry.state?.tabs ?? [], entry.state?.interacted_element ?? [], entry.state?.screenshot_path ?? null);
+            const metadata = entry.metadata
+                ? new StepMetadata(entry.metadata.step_start_time, entry.metadata.step_end_time, entry.metadata.step_number)
+                : null;
+            return new AgentHistory(modelOutput, result, state, metadata);
+        });
+        return new AgentHistoryList(historyItems);
+    }
+    toJSON() {
+        return {
+            history: this.history.map((item) => item.toJSON()),
+            usage: this.usage,
+        };
+    }
+    model_dump() {
+        return this.toJSON();
+    }
+}
+export class AgentError extends Error {
+    static VALIDATION_ERROR = 'Invalid model output format. Please follow the correct schema.';
+    static RATE_LIMIT_ERROR = 'Rate limit reached. Waiting before retry.';
+    static NO_VALID_ACTION = 'No valid action found';
+    static format_error(error, include_trace = false) {
+        if (error?.name === 'ValidationError') {
+            return `${AgentError.VALIDATION_ERROR}\nDetails: ${error.message}`;
+        }
+        if (error.name === 'RateLimitError') {
+            return AgentError.RATE_LIMIT_ERROR;
+        }
+        if (include_trace && error?.stack) {
+            return `${error.message}\nStacktrace:\n${error.stack}`;
+        }
+        return error.message;
+    }
+}

package/dist/browser/browser.d.ts

@@ -0,0 +1,7 @@
+import { BrowserProfile } from './profile.js';
+import { BrowserSession } from './session.js';
+export type BrowserConfig = BrowserProfile;
+export type BrowserContextConfig = BrowserProfile;
+export declare const Browser: typeof BrowserSession;
+export { BrowserProfile };
+export { BrowserSession };

package/dist/browser/browser.js

@@ -0,0 +1,5 @@
+import { BrowserProfile } from './profile.js';
+import { BrowserSession } from './session.js';
+export const Browser = BrowserSession;
+export { BrowserProfile };
+export { BrowserSession };

package/dist/browser/context.d.ts

@@ -0,0 +1,8 @@
+import { BrowserProfile } from './profile.js';
+import { BrowserSession } from './session.js';
+export type Browser = BrowserSession;
+export type BrowserConfig = BrowserProfile;
+export type BrowserContext = BrowserSession;
+export type BrowserContextConfig = BrowserProfile;
+export { BrowserProfile };
+export { BrowserSession };

package/dist/browser/context.js

@@ -0,0 +1,4 @@
+import { BrowserProfile } from './profile.js';
+import { BrowserSession } from './session.js';
+export { BrowserProfile };
+export { BrowserSession };

package/dist/browser/dvd-screensaver.d.ts

@@ -0,0 +1,101 @@
+/**
+ * DVD Screensaver Loading Animation
+ *
+ * Displays a fun DVD logo bouncing animation while waiting for browser operations.
+ * Inspired by the classic DVD screensaver.
+ */
+/**
+ * DVD Screensaver Animation Controller
+ */
+export declare class DVDScreensaver {
+    private isRunning;
+    private intervalId;
+    private width;
+    private height;
+    private x;
+    private y;
+    private dx;
+    private dy;
+    private logoWidth;
+    private logoHeight;
+    private colors;
+    private currentColorIndex;
+    private cornerHits;
+    private frameCount;
+    private message;
+    constructor(message?: string);
+    /**
+     * Start the animation
+     */
+    start(fps?: number): void;
+    /**
+     * Stop the animation
+     */
+    stop(): void;
+    /**
+     * Update logo position
+     */
+    private update;
+    /**
+     * Change logo color
+     */
+    private changeColor;
+    /**
+     * Render the current frame
+     */
+    private render;
+    /**
+     * Get character for logo at specific position
+     */
+    private getLogoChar;
+    /**
+     * Clear screen
+     */
+    private clear;
+}
+/**
+ * Show DVD screensaver loading animation
+ * Returns a function to stop the animation
+ *
+ * @param message - Message to display
+ * @param fps - Frames per second (default: 10)
+ * @returns Function to stop the animation
+ *
+ * @example
+ * const stopAnimation = showDVDScreensaver('Loading browser...');
+ * await someAsyncOperation();
+ * stopAnimation();
+ */
+export declare function showDVDScreensaver(message?: string, fps?: number): () => void;
+/**
+ * Run an async operation with DVD screensaver animation
+ *
+ * @param operation - Async operation to run
+ * @param message - Message to display
+ * @returns Result of the operation
+ *
+ * @example
+ * const result = await withDVDScreensaver(
+ *   async () => await longRunningOperation(),
+ *   'Processing...'
+ * );
+ */
+export declare function withDVDScreensaver<T>(operation: () => Promise<T>, message?: string): Promise<T>;
+/**
+ * Simple spinner animation (alternative to DVD screensaver)
+ */
+export declare class SpinnerAnimation {
+    private isRunning;
+    private intervalId;
+    private frames;
+    private currentFrame;
+    private message;
+    constructor(message?: string);
+    start(fps?: number): void;
+    stop(): void;
+    private render;
+}
+/**
+ * Show simple spinner animation
+ */
+export declare function showSpinner(message?: string, fps?: number): () => void;