browser-use 0.2.0 → 0.3.0

package/dist/code-use/service.js

@@ -0,0 +1,104 @@
+import { CodeAgentHistory, CodeAgentHistoryList, CodeAgentState, CodeAgentStepMetadata, NotebookSession, } from './views.js';
+import { create_namespace } from './namespace.js';
+const AsyncFunction = Object.getPrototypeOf(async function () {
+    return undefined;
+}).constructor;
+const default_executor = async (source, namespace) => {
+    const injectableNames = Object.keys(namespace).filter((name) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name));
+    const prelude = injectableNames
+        .map((name) => `const ${name} = namespace[${JSON.stringify(name)}];`)
+        .join('\n');
+    const runner = new AsyncFunction('namespace', `${prelude}\n${source}\nreturn undefined;`);
+    return runner(namespace);
+};
+export class CodeAgent {
+    task;
+    browser_session;
+    session;
+    namespace;
+    complete_history = [];
+    executor;
+    constructor(options) {
+        this.task = options.task;
+        this.browser_session = options.browser_session;
+        this.namespace = create_namespace(options.browser_session, options.namespace ? { namespace: options.namespace } : {});
+        this.session = new NotebookSession({ namespace: this.namespace });
+        this.executor = options.executor ?? default_executor;
+    }
+    add_cell(source) {
+        return this.session.add_cell(source);
+    }
+    async execute_cell(source) {
+        const cell = this.add_cell(source);
+        const startedAt = Date.now() / 1000;
+        cell.status = 'running';
+        cell.execution_count = this.session.increment_execution_count();
+        let resultItem;
+        try {
+            const output = await this.executor(cell.source, this.namespace);
+            cell.status = 'success';
+            cell.output =
+                output == null
+                    ? null
+                    : typeof output === 'string'
+                        ? output
+                        : JSON.stringify(output);
+            cell.error = null;
+            resultItem = {
+                extracted_content: cell.output,
+                error: null,
+                is_done: Boolean(this.namespace._task_done),
+                success: typeof this.namespace._task_success === 'boolean'
+                    ? this.namespace._task_success
+                    : null,
+            };
+        }
+        catch (error) {
+            cell.status = 'error';
+            cell.output = null;
+            cell.error = String(error?.message ?? error);
+            resultItem = {
+                extracted_content: null,
+                error: cell.error,
+                is_done: false,
+                success: false,
+            };
+        }
+        const page = await this.browser_session.get_current_page();
+        const state = new CodeAgentState({
+            url: typeof page?.url === 'function' ? page.url() : null,
+            title: typeof page?.title === 'function' ? await page.title() : null,
+        });
+        const metadata = new CodeAgentStepMetadata({
+            step_start_time: startedAt,
+            step_end_time: Date.now() / 1000,
+        });
+        const modelOutput = {
+            model_output: cell.source,
+            full_response: cell.source,
+        };
+        const historyItem = new CodeAgentHistory({
+            model_output: modelOutput,
+            result: [resultItem],
+            state,
+            metadata,
+        });
+        this.complete_history.push(historyItem);
+        this.session._complete_history = [...this.complete_history];
+        return cell;
+    }
+    async run(max_steps = 100) {
+        const pending = this.session.cells.filter((cell) => cell.status === 'pending');
+        const toRun = pending.slice(0, Math.max(max_steps, 0));
+        for (const cell of toRun) {
+            await this.execute_cell(cell.source);
+        }
+        return this.history;
+    }
+    get history() {
+        return new CodeAgentHistoryList(this.complete_history, null);
+    }
+    async close() {
+        // Keep lifecycle explicit; caller controls browser shutdown.
+    }
+}

package/dist/code-use/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const truncate_message_content: (content: string, max_length?: number) => string;
+export declare const detect_token_limit_issue: (completion: string, completion_tokens: number | null, max_tokens: number | null, stop_reason: string | null) => [boolean, string | null];
+export declare const extract_url_from_task: (task: string) => string | null;
+export declare const extract_code_blocks: (text: string) => Record<string, string>;

package/dist/code-use/utils.js

@@ -0,0 +1,98 @@
+export const truncate_message_content = (content, max_length = 10000) => {
+    if (content.length <= max_length) {
+        return content;
+    }
+    return `${content.slice(0, max_length)}\n\n[... truncated ${content.length - max_length} characters for history]`;
+};
+export const detect_token_limit_issue = (completion, completion_tokens, max_tokens, stop_reason) => {
+    if (stop_reason === 'max_tokens') {
+        return [true, `Response terminated due to max_tokens (${stop_reason})`];
+    }
+    if (completion_tokens != null &&
+        max_tokens != null &&
+        max_tokens > 0 &&
+        completion_tokens / max_tokens >= 0.9) {
+        return [
+            true,
+            `Response used ${(completion_tokens / max_tokens) * 100}% of max_tokens (${completion_tokens}/${max_tokens})`,
+        ];
+    }
+    if (completion.length >= 6) {
+        const last6 = completion.slice(-6);
+        const repeated = completion.split(last6).length - 1;
+        if (repeated >= 40) {
+            return [
+                true,
+                `Repetitive output detected: last 6 chars "${last6}" appears ${repeated} times`,
+            ];
+        }
+    }
+    return [false, null];
+};
+export const extract_url_from_task = (task) => {
+    const withoutEmails = task.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, '');
+    const matches = [];
+    const patterns = [
+        /https?:\/\/[^\s<>"']+/g,
+        /(?:www\.)?[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*\.[a-zA-Z]{2,}(?:\/[^\s<>"']*)?/g,
+    ];
+    for (const pattern of patterns) {
+        const found = withoutEmails.match(pattern) ?? [];
+        for (const entry of found) {
+            const trimmed = entry.replace(/[.,;:!?()[\]]+$/g, '');
+            matches.push(trimmed.startsWith('http://') || trimmed.startsWith('https://')
+                ? trimmed
+                : `https://${trimmed}`);
+        }
+    }
+    const unique = [...new Set(matches)];
+    if (unique.length !== 1) {
+        return null;
+    }
+    return unique[0];
+};
+export const extract_code_blocks = (text) => {
+    const blocks = {};
+    const regex = /(`{3,})(\w+)(?:\s+(\w+))?\n([\s\S]*?)\1(?:\n|$)/g;
+    let match;
+    let pythonIndex = 0;
+    while ((match = regex.exec(text)) != null) {
+        const langRaw = match[2].toLowerCase();
+        const name = match[3] ?? null;
+        const content = match[4].replace(/\s+$/, '');
+        if (!content) {
+            continue;
+        }
+        const lang = langRaw === 'javascript' || langRaw === 'js'
+            ? 'js'
+            : langRaw === 'markdown' || langRaw === 'md'
+                ? 'markdown'
+                : langRaw === 'sh' || langRaw === 'shell'
+                    ? 'bash'
+                    : langRaw;
+        if (!['python', 'js', 'bash', 'markdown'].includes(lang)) {
+            continue;
+        }
+        if (name) {
+            blocks[name] = content;
+            continue;
+        }
+        if (lang === 'python') {
+            blocks[`python_${pythonIndex}`] = content;
+            pythonIndex += 1;
+            continue;
+        }
+        blocks[lang] = content;
+    }
+    if (pythonIndex > 0) {
+        blocks.python = blocks.python_0;
+    }
+    else {
+        const genericMatches = [...text.matchAll(/```\n([\s\S]*?)```/g)].map((entry) => entry[1].trim());
+        const generic = genericMatches.filter(Boolean).join('\n\n');
+        if (generic) {
+            blocks.python = generic;
+        }
+    }
+    return blocks;
+};

package/dist/code-use/views.d.ts

@@ -0,0 +1,108 @@
+import type { UsageSummary } from '../tokens/views.js';
+export type CellType = 'code' | 'markdown';
+export type ExecutionStatus = 'pending' | 'running' | 'success' | 'error';
+export interface CodeCellInit {
+    id?: string;
+    cell_type?: CellType;
+    source: string;
+    output?: string | null;
+    execution_count?: number | null;
+    status?: ExecutionStatus;
+    error?: string | null;
+    browser_state?: string | null;
+}
+export declare class CodeCell {
+    id: string;
+    cell_type: CellType;
+    source: string;
+    output: string | null;
+    execution_count: number | null;
+    status: ExecutionStatus;
+    error: string | null;
+    browser_state: string | null;
+    constructor(init: CodeCellInit);
+}
+export interface CodeAgentModelOutput {
+    model_output: string;
+    full_response: string;
+}
+export interface CodeAgentResult {
+    extracted_content?: string | null;
+    error?: string | null;
+    is_done: boolean;
+    success?: boolean | null;
+}
+export declare class CodeAgentState {
+    url: string | null;
+    title: string | null;
+    screenshot_path: string | null;
+    constructor(init: {
+        url?: string | null;
+        title?: string | null;
+        screenshot_path?: string | null;
+    });
+    get_screenshot(): string | null;
+}
+export declare class CodeAgentStepMetadata {
+    input_tokens: number | null;
+    output_tokens: number | null;
+    step_start_time: number;
+    step_end_time: number;
+    constructor(init: {
+        input_tokens?: number | null;
+        output_tokens?: number | null;
+        step_start_time: number;
+        step_end_time: number;
+    });
+    get duration_seconds(): number;
+}
+export declare class CodeAgentHistory {
+    model_output: CodeAgentModelOutput | null;
+    result: CodeAgentResult[];
+    state: CodeAgentState;
+    metadata: CodeAgentStepMetadata | null;
+    screenshot_path: string | null;
+    constructor(init: {
+        model_output?: CodeAgentModelOutput | null;
+        result?: CodeAgentResult[];
+        state: CodeAgentState;
+        metadata?: CodeAgentStepMetadata | null;
+        screenshot_path?: string | null;
+    });
+}
+export declare class CodeAgentHistoryList {
+    private readonly complete_history;
+    private readonly usage_summary;
+    constructor(complete_history: CodeAgentHistory[], usage_summary?: UsageSummary | null);
+    get history(): CodeAgentHistory[];
+    get usage(): UsageSummary | null;
+    final_result(): string | null;
+    is_done(): boolean;
+    is_successful(): boolean | null;
+    errors(): (string | null)[];
+    has_errors(): boolean;
+    urls(): (string | null)[];
+    action_results(): CodeAgentResult[];
+    extracted_content(): string[];
+    number_of_steps(): number;
+    total_duration_seconds(): number;
+}
+export declare class NotebookSession {
+    id: string;
+    cells: CodeCell[];
+    current_execution_count: number;
+    namespace: Record<string, unknown>;
+    _complete_history: CodeAgentHistory[];
+    _usage_summary: UsageSummary | null;
+    constructor(init?: {
+        id?: string;
+        cells?: CodeCell[];
+        current_execution_count?: number;
+        namespace?: Record<string, unknown>;
+    });
+    add_cell(source: string): CodeCell;
+    get_cell(cell_id: string): CodeCell | null;
+    get_latest_cell(): CodeCell;
+    increment_execution_count(): number;
+    get history(): CodeAgentHistoryList;
+}

package/dist/code-use/views.js

@@ -0,0 +1,165 @@
+import fs from 'node:fs';
+import { uuid7str } from '../utils.js';
+export class CodeCell {
+    id;
+    cell_type;
+    source;
+    output;
+    execution_count;
+    status;
+    error;
+    browser_state;
+    constructor(init) {
+        this.id = init.id ?? uuid7str();
+        this.cell_type = init.cell_type ?? 'code';
+        this.source = init.source;
+        this.output = init.output ?? null;
+        this.execution_count = init.execution_count ?? null;
+        this.status = init.status ?? 'pending';
+        this.error = init.error ?? null;
+        this.browser_state = init.browser_state ?? null;
+    }
+}
+export class CodeAgentState {
+    url;
+    title;
+    screenshot_path;
+    constructor(init) {
+        this.url = init.url ?? null;
+        this.title = init.title ?? null;
+        this.screenshot_path = init.screenshot_path ?? null;
+    }
+    get_screenshot() {
+        if (!this.screenshot_path || !fs.existsSync(this.screenshot_path)) {
+            return null;
+        }
+        return Buffer.from(fs.readFileSync(this.screenshot_path)).toString('base64');
+    }
+}
+export class CodeAgentStepMetadata {
+    input_tokens;
+    output_tokens;
+    step_start_time;
+    step_end_time;
+    constructor(init) {
+        this.input_tokens = init.input_tokens ?? null;
+        this.output_tokens = init.output_tokens ?? null;
+        this.step_start_time = init.step_start_time;
+        this.step_end_time = init.step_end_time;
+    }
+    get duration_seconds() {
+        return this.step_end_time - this.step_start_time;
+    }
+}
+export class CodeAgentHistory {
+    model_output;
+    result;
+    state;
+    metadata;
+    screenshot_path;
+    constructor(init) {
+        this.model_output = init.model_output ?? null;
+        this.result = init.result ?? [];
+        this.state = init.state;
+        this.metadata = init.metadata ?? null;
+        this.screenshot_path = init.screenshot_path ?? null;
+    }
+}
+export class CodeAgentHistoryList {
+    complete_history;
+    usage_summary;
+    constructor(complete_history, usage_summary = null) {
+        this.complete_history = complete_history;
+        this.usage_summary = usage_summary;
+    }
+    get history() {
+        return this.complete_history;
+    }
+    get usage() {
+        return this.usage_summary;
+    }
+    final_result() {
+        const last = this.complete_history[this.complete_history.length - 1];
+        if (!last?.result?.length) {
+            return null;
+        }
+        return last.result[last.result.length - 1].extracted_content ?? null;
+    }
+    is_done() {
+        const last = this.complete_history[this.complete_history.length - 1];
+        if (!last?.result?.length) {
+            return false;
+        }
+        return Boolean(last.result[last.result.length - 1].is_done);
+    }
+    is_successful() {
+        const last = this.complete_history[this.complete_history.length - 1];
+        if (!last?.result?.length) {
+            return null;
+        }
+        const final = last.result[last.result.length - 1];
+        return final.is_done ? (final.success ?? null) : null;
+    }
+    errors() {
+        return this.complete_history.map((entry) => {
+            const withError = entry.result.find((result) => Boolean(result.error));
+            return withError?.error ?? null;
+        });
+    }
+    has_errors() {
+        return this.errors().some((error) => Boolean(error));
+    }
+    urls() {
+        return this.complete_history.map((entry) => entry.state.url);
+    }
+    action_results() {
+        return this.complete_history.flatMap((entry) => entry.result);
+    }
+    extracted_content() {
+        return this.action_results()
+            .map((entry) => entry.extracted_content ?? null)
+            .filter((entry) => typeof entry === 'string');
+    }
+    number_of_steps() {
+        return this.complete_history.length;
+    }
+    total_duration_seconds() {
+        return this.complete_history.reduce((sum, entry) => {
+            return sum + (entry.metadata?.duration_seconds ?? 0);
+        }, 0);
+    }
+}
+export class NotebookSession {
+    id;
+    cells;
+    current_execution_count;
+    namespace;
+    _complete_history;
+    _usage_summary;
+    constructor(init = {}) {
+        this.id = init.id ?? uuid7str();
+        this.cells = init.cells ?? [];
+        this.current_execution_count = init.current_execution_count ?? 0;
+        this.namespace = init.namespace ?? {};
+        this._complete_history = [];
+        this._usage_summary = null;
+    }
+    add_cell(source) {
+        const cell = new CodeCell({ source });
+        this.cells.push(cell);
+        return cell;
+    }
+    get_cell(cell_id) {
+        return this.cells.find((cell) => cell.id === cell_id) ?? null;
+    }
+    get_latest_cell() {
+        return this.cells[this.cells.length - 1] ?? null;
+    }
+    increment_execution_count() {
+        this.current_execution_count += 1;
+        return this.current_execution_count;
+    }
+    get history() {
+        return new CodeAgentHistoryList(this._complete_history, this._usage_summary);
+    }
+}

package/dist/config.d.ts

@@ -6,6 +6,8 @@ declare class OldConfig {
     get BROWSER_USE_CLOUD_SYNC(): boolean;
     get BROWSER_USE_CLOUD_API_URL(): string;
     get BROWSER_USE_CLOUD_UI_URL(): string;
+    get BROWSER_USE_DEBUG_LOG_FILE(): string | null;
+    get BROWSER_USE_INFO_LOG_FILE(): string | null;
     get XDG_CACHE_HOME(): string;
     get XDG_CONFIG_HOME(): string;
     get BROWSER_USE_CONFIG_DIR(): string;
@@ -22,8 +24,10 @@ declare class OldConfig {
     get AZURE_OPENAI_ENDPOINT(): string;
     get AZURE_OPENAI_KEY(): string;
     get SKIP_LLM_API_KEY_VERIFICATION(): boolean;
+    get DEFAULT_LLM(): string;
     get IN_DOCKER(): boolean;
     get IS_IN_EVALS(): boolean;
+    get BROWSER_USE_VERSION_CHECK(): boolean;
     get WIN_FONT_DIR(): string;
     _ensure_dirs(base_dir?: string): void;
 }
@@ -33,6 +37,8 @@ declare class FlatEnvConfig {
     get BROWSER_USE_CLOUD_SYNC(): boolean | null;
     get BROWSER_USE_CLOUD_API_URL(): string;
     get BROWSER_USE_CLOUD_UI_URL(): string;
+    get BROWSER_USE_DEBUG_LOG_FILE(): string | null;
+    get BROWSER_USE_INFO_LOG_FILE(): string | null;
     get XDG_CACHE_HOME(): string;
     get XDG_CONFIG_HOME(): string;
     get BROWSER_USE_CONFIG_DIR(): string | null;
@@ -45,13 +51,20 @@ declare class FlatEnvConfig {
     get AZURE_OPENAI_ENDPOINT(): string;
     get AZURE_OPENAI_KEY(): string;
     get SKIP_LLM_API_KEY_VERIFICATION(): boolean;
+    get DEFAULT_LLM(): string;
     get IN_DOCKER(): boolean | null;
     get IS_IN_EVALS(): boolean;
+    get BROWSER_USE_VERSION_CHECK(): boolean;
     get WIN_FONT_DIR(): string;
     get BROWSER_USE_CONFIG_PATH(): string | null;
     get BROWSER_USE_HEADLESS(): boolean | null;
     get BROWSER_USE_ALLOWED_DOMAINS(): string | null;
     get BROWSER_USE_LLM_MODEL(): string | null;
+    get BROWSER_USE_PROXY_URL(): string | null;
+    get BROWSER_USE_NO_PROXY(): string | null;
+    get BROWSER_USE_PROXY_USERNAME(): string | null;
+    get BROWSER_USE_PROXY_PASSWORD(): string | null;
+    get BROWSER_USE_DISABLE_EXTENSIONS(): boolean | null;
 }
 interface DBStyleEntry {
     id: string;

package/dist/config.js

@@ -92,6 +92,12 @@ class OldConfig {
         }
         return url;
     }
+    get BROWSER_USE_DEBUG_LOG_FILE() {
+        return process.env.BROWSER_USE_DEBUG_LOG_FILE ?? null;
+    }
+    get BROWSER_USE_INFO_LOG_FILE() {
+        return process.env.BROWSER_USE_INFO_LOG_FILE ?? null;
+    }
     get XDG_CACHE_HOME() {
         return resolve_path(process.env.XDG_CACHE_HOME ?? '~/.cache');
     }
@@ -149,12 +155,18 @@ class OldConfig {
     get SKIP_LLM_API_KEY_VERIFICATION() {
         return string_to_bool(process.env.SKIP_LLM_API_KEY_VERIFICATION, false);
     }
+    get DEFAULT_LLM() {
+        return process.env.DEFAULT_LLM ?? '';
+    }
     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 BROWSER_USE_VERSION_CHECK() {
+        return string_to_bool(process.env.BROWSER_USE_VERSION_CHECK, true);
+    }
     get WIN_FONT_DIR() {
         return process.env.WIN_FONT_DIR ?? 'C:\\Windows\\Fonts';
     }
@@ -188,6 +200,12 @@ class FlatEnvConfig {
     get BROWSER_USE_CLOUD_UI_URL() {
         return process.env.BROWSER_USE_CLOUD_UI_URL ?? '';
     }
+    get BROWSER_USE_DEBUG_LOG_FILE() {
+        return process.env.BROWSER_USE_DEBUG_LOG_FILE ?? null;
+    }
+    get BROWSER_USE_INFO_LOG_FILE() {
+        return process.env.BROWSER_USE_INFO_LOG_FILE ?? null;
+    }
     get XDG_CACHE_HOME() {
         return resolve_path(process.env.XDG_CACHE_HOME ?? '~/.cache');
     }
@@ -226,6 +244,9 @@ class FlatEnvConfig {
     get SKIP_LLM_API_KEY_VERIFICATION() {
         return string_to_bool(process.env.SKIP_LLM_API_KEY_VERIFICATION, false);
     }
+    get DEFAULT_LLM() {
+        return process.env.DEFAULT_LLM ?? '';
+    }
     get IN_DOCKER() {
         const value = process.env.IN_DOCKER;
         return value === undefined ? null : string_to_bool(value);
@@ -233,6 +254,9 @@ class FlatEnvConfig {
     get IS_IN_EVALS() {
         return string_to_bool(process.env.IS_IN_EVALS, false);
     }
+    get BROWSER_USE_VERSION_CHECK() {
+        return string_to_bool(process.env.BROWSER_USE_VERSION_CHECK, true);
+    }
     get WIN_FONT_DIR() {
         return process.env.WIN_FONT_DIR ?? 'C:\\Windows\\Fonts';
     }
@@ -251,9 +275,25 @@ class FlatEnvConfig {
     get BROWSER_USE_LLM_MODEL() {
         return process.env.BROWSER_USE_LLM_MODEL ?? null;
     }
+    get BROWSER_USE_PROXY_URL() {
+        return process.env.BROWSER_USE_PROXY_URL ?? null;
+    }
+    get BROWSER_USE_NO_PROXY() {
+        return process.env.BROWSER_USE_NO_PROXY ?? null;
+    }
+    get BROWSER_USE_PROXY_USERNAME() {
+        return process.env.BROWSER_USE_PROXY_USERNAME ?? null;
+    }
+    get BROWSER_USE_PROXY_PASSWORD() {
+        return process.env.BROWSER_USE_PROXY_PASSWORD ?? null;
+    }
+    get BROWSER_USE_DISABLE_EXTENSIONS() {
+        const value = process.env.BROWSER_USE_DISABLE_EXTENSIONS;
+        return value === undefined ? null : string_to_bool(value);
+    }
 }
 const create_default_config = () => {
-    logger.info('Creating fresh default config.json');
+    logger.debug('Creating fresh default config.json');
     const profile_id = randomUUID();
     const llm_id = randomUUID();
     const agent_id = randomUUID();
@@ -274,7 +314,7 @@ const create_default_config = () => {
                 id: llm_id,
                 default: true,
                 created_at: new Date().toISOString(),
-                model: 'gpt-4o',
+                model: 'gpt-4.1-mini',
                 api_key: 'your-openai-api-key-here',
                 temperature: null,
                 max_tokens: null,
@@ -309,7 +349,7 @@ const load_and_migrate_config = (config_path) => {
         if (looks_like_new_format(raw)) {
             return raw;
         }
-        logger.info(`Old config format detected at ${config_path}, creating fresh config`);
+        logger.debug(`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;
@@ -374,12 +414,38 @@ class ConfigCore {
                     .map((domain) => domain.trim())
                     .filter(Boolean);
         }
+        const proxy = {};
+        if (env.BROWSER_USE_PROXY_URL) {
+            proxy.server = env.BROWSER_USE_PROXY_URL;
+        }
+        if (env.BROWSER_USE_NO_PROXY) {
+            proxy.bypass = env.BROWSER_USE_NO_PROXY.split(',')
+                .map((domain) => domain.trim())
+                .filter(Boolean)
+                .join(',');
+        }
+        if (env.BROWSER_USE_PROXY_USERNAME) {
+            proxy.username = env.BROWSER_USE_PROXY_USERNAME;
+        }
+        if (env.BROWSER_USE_PROXY_PASSWORD) {
+            proxy.password = env.BROWSER_USE_PROXY_PASSWORD;
+        }
+        if (Object.keys(proxy).length > 0) {
+            config.browser_profile.proxy = proxy;
+        }
         if (env.OPENAI_API_KEY) {
             config.llm.api_key = env.OPENAI_API_KEY;
         }
+        if (env.DEFAULT_LLM) {
+            config.llm.model = env.DEFAULT_LLM;
+        }
         if (env.BROWSER_USE_LLM_MODEL) {
             config.llm.model = env.BROWSER_USE_LLM_MODEL;
         }
+        if (env.BROWSER_USE_DISABLE_EXTENSIONS !== null) {
+            config.browser_profile.enable_default_extensions =
+                !env.BROWSER_USE_DISABLE_EXTENSIONS;
+        }
         return config;
     }
     _ensure_dirs() {