browser-use 0.2.0 → 0.3.0

package/dist/cli.d.ts

@@ -1,17 +1,21 @@
 #!/usr/bin/env node
+import { BrowserProfile } from './browser/profile.js';
 import type { BaseChatModel } from './llm/base.js';
-type CliModelProvider = 'openai' | 'anthropic' | 'google' | 'deepseek' | 'groq' | 'openrouter' | 'azure' | 'aws-anthropic' | 'aws' | 'ollama';
+type CliModelProvider = 'openai' | 'anthropic' | 'google' | 'deepseek' | 'groq' | 'openrouter' | 'azure' | 'mistral' | 'cerebras' | 'vercel' | 'oci' | 'aws-anthropic' | 'aws' | 'ollama' | 'browser-use';
 export interface ParsedCliArgs {
     help: boolean;
     version: boolean;
     debug: boolean;
-    allow_insecure: boolean;
     headless: boolean | null;
     window_width: number | null;
     window_height: number | null;
     user_data_dir: string | null;
     profile_directory: string | null;
     allowed_domains: string[] | null;
+    proxy_url: string | null;
+    no_proxy: string | null;
+    proxy_username: string | null;
+    proxy_password: string | null;
     cdp_url: string | null;
     model: string | null;
     provider: CliModelProvider | null;
@@ -33,6 +37,7 @@ export declare const shouldStartInteractiveMode: (task: string | null, options?:
     outputIsTTY?: boolean;
 }) => boolean;
 export declare const getLlmFromCliArgs: (args: ParsedCliArgs) => BaseChatModel;
+export declare const buildBrowserProfileFromCliArgs: (args: ParsedCliArgs) => BrowserProfile | null;
 export declare const getCliUsage: () => string;
 export declare function main(argv?: string[]): Promise<void>;
 export {};

package/dist/cli.js

@@ -16,8 +16,12 @@ import { ChatGroq } from './llm/groq/chat.js';
 import { ChatOpenRouter } from './llm/openrouter/chat.js';
 import { ChatAzure } from './llm/azure/chat.js';
 import { ChatOllama } from './llm/ollama/chat.js';
+import { ChatMistral } from './llm/mistral/chat.js';
+import { ChatCerebras } from './llm/cerebras/chat.js';
+import { ChatVercel } from './llm/vercel/chat.js';
 import { ChatAnthropicBedrock } from './llm/aws/chat-anthropic.js';
 import { ChatBedrockConverse } from './llm/aws/chat-bedrock.js';
+import { ChatBrowserUse } from './llm/browser-use/chat.js';
 import { MCPServer } from './mcp/server.js';
 import { get_browser_use_version } from './utils.js';
 import { setupLogging } from './logging-config.js';
@@ -32,7 +36,14 @@ const CLI_PROVIDER_ALIASES = {
     groq: 'groq',
     openrouter: 'openrouter',
     azure: 'azure',
+    mistral: 'mistral',
+    cerebras: 'cerebras',
+    vercel: 'vercel',
+    oci: 'oci',
     ollama: 'ollama',
+    'browser-use': 'browser-use',
+    browseruse: 'browser-use',
+    bu: 'browser-use',
     bedrock: 'aws',
     aws: 'aws',
     'aws-anthropic': 'aws-anthropic',
@@ -62,7 +73,7 @@ const parseProvider = (value) => {
     const normalized = value.trim().toLowerCase();
     const provider = CLI_PROVIDER_ALIASES[normalized];
     if (!provider) {
-        throw new Error(`Unsupported provider "${value}". Supported values: openai, anthropic, google, deepseek, groq, openrouter, azure, ollama, aws, aws-anthropic.`);
+        throw new Error(`Unsupported provider "${value}". Supported values: openai, anthropic, google, deepseek, groq, openrouter, azure, mistral, cerebras, vercel, oci, ollama, browser-use, aws, aws-anthropic.`);
     }
     return provider;
 };
@@ -102,13 +113,16 @@ export const parseCliArgs = (argv) => {
         help: false,
         version: false,
         debug: false,
-        allow_insecure: false,
         headless: null,
         window_width: null,
         window_height: null,
         user_data_dir: null,
         profile_directory: null,
         allowed_domains: null,
+        proxy_url: null,
+        no_proxy: null,
+        proxy_username: null,
+        proxy_password: null,
         cdp_url: null,
         model: null,
         provider: null,
@@ -134,10 +148,6 @@ export const parseCliArgs = (argv) => {
             parsed.debug = true;
             continue;
         }
-        if (arg === '--allow-insecure') {
-            parsed.allow_insecure = true;
-            continue;
-        }
         if (arg === '--headless') {
             parsed.headless = true;
             continue;
@@ -196,6 +206,30 @@ export const parseCliArgs = (argv) => {
             i = nextIndex;
             continue;
         }
+        if (arg === '--proxy-url' || arg.startsWith('--proxy-url=')) {
+            const { value, nextIndex } = takeOptionValue(arg, i, argv);
+            parsed.proxy_url = value.trim();
+            i = nextIndex;
+            continue;
+        }
+        if (arg === '--no-proxy' || arg.startsWith('--no-proxy=')) {
+            const { value, nextIndex } = takeOptionValue(arg, i, argv);
+            parsed.no_proxy = value;
+            i = nextIndex;
+            continue;
+        }
+        if (arg === '--proxy-username' || arg.startsWith('--proxy-username=')) {
+            const { value, nextIndex } = takeOptionValue(arg, i, argv);
+            parsed.proxy_username = value;
+            i = nextIndex;
+            continue;
+        }
+        if (arg === '--proxy-password' || arg.startsWith('--proxy-password=')) {
+            const { value, nextIndex } = takeOptionValue(arg, i, argv);
+            parsed.proxy_password = value;
+            i = nextIndex;
+            continue;
+        }
         if (arg === '--cdp-url' || arg.startsWith('--cdp-url=')) {
             const { value, nextIndex } = takeOptionValue(arg, i, argv);
             parsed.cdp_url = value;
@@ -298,9 +332,37 @@ const inferProviderFromModel = (model) => {
     if (lower.startsWith('azure:')) {
         return 'azure';
     }
+    if (lower.startsWith('mistral:')) {
+        return 'mistral';
+    }
+    if (lower.startsWith('cerebras:')) {
+        return 'cerebras';
+    }
+    if (lower.startsWith('vercel:')) {
+        return 'vercel';
+    }
+    if (lower.startsWith('oci:')) {
+        return 'oci';
+    }
+    if (lower.startsWith('mistral-') ||
+        lower.startsWith('codestral') ||
+        lower.startsWith('pixtral')) {
+        return 'mistral';
+    }
+    if (lower.startsWith('llama3.') ||
+        lower.startsWith('llama-4-') ||
+        lower.startsWith('gpt-oss-') ||
+        lower.startsWith('qwen-3-')) {
+        return 'cerebras';
+    }
     if (lower.startsWith('ollama:')) {
         return 'ollama';
     }
+    if (lower.startsWith('browser-use:') ||
+        lower.startsWith('bu-') ||
+        lower.startsWith('browser-use/')) {
+        return 'browser-use';
+    }
     if (lower.startsWith('bedrock:anthropic.')) {
         return 'aws-anthropic';
     }
@@ -328,9 +390,27 @@ const normalizeModelValue = (model, provider) => {
     if (provider === 'azure' && lower.startsWith('azure:')) {
         return model.slice('azure:'.length);
     }
+    if (provider === 'mistral' && lower.startsWith('mistral:')) {
+        return model.slice('mistral:'.length);
+    }
+    if (provider === 'cerebras' && lower.startsWith('cerebras:')) {
+        return model.slice('cerebras:'.length);
+    }
+    if (provider === 'vercel' && lower.startsWith('vercel:')) {
+        return model.slice('vercel:'.length);
+    }
+    if (provider === 'oci' && lower.startsWith('oci:')) {
+        return model.slice('oci:'.length);
+    }
     if (provider === 'ollama' && lower.startsWith('ollama:')) {
         return model.slice('ollama:'.length);
     }
+    if (provider === 'browser-use' && lower.startsWith('browser-use:')) {
+        return model.slice('browser-use:'.length);
+    }
+    if (provider === 'browser-use' && lower.startsWith('bu_')) {
+        return model.replace(/_/g, '-');
+    }
     if (provider === 'aws-anthropic' && lower.startsWith('bedrock:')) {
         return model.slice('bedrock:'.length);
     }
@@ -352,23 +432,33 @@ const providersAreCompatible = (explicitProvider, inferredProvider) => {
 const getDefaultModelForProvider = (provider) => {
     switch (provider) {
         case 'openai':
-            return 'gpt-4o';
+            return 'gpt-5-mini';
         case 'anthropic':
-            return 'claude-sonnet-4-20250514';
+            return 'claude-4-sonnet';
         case 'google':
-            return 'gemini-2.5-flash';
+            return 'gemini-2.5-pro';
         case 'deepseek':
             return 'deepseek-chat';
         case 'groq':
             return 'llama-3.1-70b-versatile';
         case 'openrouter':
-            return 'openai/gpt-4o';
+            return 'openai/gpt-5-mini';
         case 'azure':
             return 'gpt-4o';
+        case 'mistral':
+            return 'mistral-large-latest';
+        case 'cerebras':
+            return 'llama3.1-8b';
+        case 'vercel':
+            return 'openai/gpt-5-mini';
+        case 'oci':
+            return null;
         case 'aws-anthropic':
             return 'anthropic.claude-3-5-sonnet-20241022-v2:0';
         case 'ollama':
             return process.env.OLLAMA_MODEL || 'qwen2.5:latest';
+        case 'browser-use':
+            return 'bu-latest';
         case 'aws':
             return null;
         default:
@@ -403,10 +493,35 @@ const createLlmForProvider = (provider, model) => {
             requireEnv('AZURE_OPENAI_API_KEY');
             requireEnv('AZURE_OPENAI_ENDPOINT');
             return new ChatAzure(model);
+        case 'mistral':
+            return new ChatMistral({
+                model,
+                apiKey: requireEnv('MISTRAL_API_KEY'),
+                baseURL: process.env.MISTRAL_BASE_URL,
+            });
+        case 'cerebras':
+            return new ChatCerebras({
+                model,
+                apiKey: requireEnv('CEREBRAS_API_KEY'),
+                baseURL: process.env.CEREBRAS_BASE_URL,
+            });
+        case 'vercel':
+            return new ChatVercel({
+                model,
+                apiKey: requireEnv('VERCEL_API_KEY'),
+                baseURL: process.env.VERCEL_BASE_URL,
+            });
+        case 'oci':
+            throw new Error('OCI models require manual configuration in TypeScript runtime. Use a custom BaseChatModel integration for OCI credentials and endpoint setup.');
         case 'ollama': {
             const host = process.env.OLLAMA_HOST || 'http://localhost:11434';
             return new ChatOllama(model, host);
         }
+        case 'browser-use':
+            return new ChatBrowserUse({
+                model,
+                apiKey: requireEnv('BROWSER_USE_API_KEY'),
+            });
         case 'aws-anthropic':
             return new ChatAnthropicBedrock({
                 model,
@@ -428,7 +543,7 @@ export const getLlmFromCliArgs = (args) => {
         }
         const provider = args.provider ?? inferredProvider;
         if (!provider) {
-            throw new Error(`Cannot infer provider from model "${args.model}". Provide --provider or use a supported model prefix: gpt*/o*, claude*, gemini*, deepseek*, groq:, openrouter:, azure:, ollama:, bedrock:.`);
+            throw new Error(`Cannot infer provider from model "${args.model}". Provide --provider or use a supported model prefix: gpt*/o*, claude*, gemini*, deepseek*, groq:, openrouter:, azure:, mistral:, cerebras:, vercel:, oci:, ollama:, browser-use:, bu-*, bedrock:.`);
         }
         const normalizedModel = normalizeModelValue(args.model, provider);
         return createLlmForProvider(provider, normalizedModel);
@@ -442,18 +557,18 @@ export const getLlmFromCliArgs = (args) => {
     }
     if (process.env.OPENAI_API_KEY) {
         return new ChatOpenAI({
-            model: 'gpt-4o',
+            model: 'gpt-5-mini',
             apiKey: process.env.OPENAI_API_KEY,
         });
     }
     if (process.env.ANTHROPIC_API_KEY) {
         return new ChatAnthropic({
-            model: 'claude-sonnet-4-20250514',
+            model: 'claude-4-sonnet',
             apiKey: process.env.ANTHROPIC_API_KEY,
         });
     }
     if (process.env.GOOGLE_API_KEY) {
-        return new ChatGoogle('gemini-2.5-flash');
+        return new ChatGoogle('gemini-2.5-pro');
     }
     if (process.env.DEEPSEEK_API_KEY) {
         return new ChatDeepSeek('deepseek-chat');
@@ -462,11 +577,32 @@ export const getLlmFromCliArgs = (args) => {
         return new ChatGroq('llama-3.1-70b-versatile');
     }
     if (process.env.OPENROUTER_API_KEY) {
-        return new ChatOpenRouter('openai/gpt-4o');
+        return new ChatOpenRouter('openai/gpt-5-mini');
     }
     if (process.env.AZURE_OPENAI_API_KEY && process.env.AZURE_OPENAI_ENDPOINT) {
         return new ChatAzure('gpt-4o');
     }
+    if (process.env.MISTRAL_API_KEY) {
+        return new ChatMistral({
+            model: 'mistral-large-latest',
+            apiKey: process.env.MISTRAL_API_KEY,
+            baseURL: process.env.MISTRAL_BASE_URL,
+        });
+    }
+    if (process.env.CEREBRAS_API_KEY) {
+        return new ChatCerebras({
+            model: 'llama3.1-8b',
+            apiKey: process.env.CEREBRAS_API_KEY,
+            baseURL: process.env.CEREBRAS_BASE_URL,
+        });
+    }
+    if (process.env.VERCEL_API_KEY) {
+        return new ChatVercel({
+            model: 'openai/gpt-5-mini',
+            apiKey: process.env.VERCEL_API_KEY,
+            baseURL: process.env.VERCEL_BASE_URL,
+        });
+    }
     if (process.env.AWS_ACCESS_KEY_ID || process.env.AWS_PROFILE) {
         return new ChatAnthropicBedrock({
             model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
@@ -475,7 +611,11 @@ export const getLlmFromCliArgs = (args) => {
     }
     return new ChatOllama(process.env.OLLAMA_MODEL || 'qwen2.5:latest', process.env.OLLAMA_HOST || 'http://localhost:11434');
 };
-const buildBrowserProfileFromCliArgs = (args) => {
+const parseCommaSeparatedList = (value) => value
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+export const buildBrowserProfileFromCliArgs = (args) => {
     const profile = {};
     if (args.headless !== null) {
         profile.headless = args.headless;
@@ -495,12 +635,31 @@ const buildBrowserProfileFromCliArgs = (args) => {
     if (args.allowed_domains && args.allowed_domains.length > 0) {
         profile.allowed_domains = args.allowed_domains;
     }
+    if (args.proxy_url ||
+        args.no_proxy ||
+        args.proxy_username ||
+        args.proxy_password) {
+        const proxy = {};
+        if (args.proxy_url) {
+            proxy.server = args.proxy_url;
+        }
+        if (args.no_proxy) {
+            proxy.bypass = parseCommaSeparatedList(args.no_proxy).join(',');
+        }
+        if (args.proxy_username) {
+            proxy.username = args.proxy_username;
+        }
+        if (args.proxy_password) {
+            proxy.password = args.proxy_password;
+        }
+        profile.proxy = proxy;
+    }
     if (Object.keys(profile).length === 0) {
         return null;
     }
     return new BrowserProfile(profile);
 };
-const runAgentTask = async ({ task, llm, browserProfile, browserSession, sessionAttachmentMode, allowInsecureSensitiveData, }) => {
+const runAgentTask = async ({ task, llm, browserProfile, browserSession, sessionAttachmentMode, }) => {
     const agent = new Agent({
         task,
         llm,
@@ -509,9 +668,6 @@ const runAgentTask = async ({ task, llm, browserProfile, browserSession, session
         ...(sessionAttachmentMode
             ? { session_attachment_mode: sessionAttachmentMode }
             : {}),
-        ...(allowInsecureSensitiveData
-            ? { allow_insecure_sensitive_data: true }
-            : {}),
         source: 'cli',
     });
     await agent.run();
@@ -560,7 +716,6 @@ const runInteractiveMode = async (args, llm) => {
                     browserProfile,
                     browserSession,
                     sessionAttachmentMode: 'strict',
-                    allowInsecureSensitiveData: args.allow_insecure,
                 });
             }
             catch (error) {
@@ -595,16 +750,19 @@ Options:
   -h, --help                  Show this help message
   --version                   Print version and exit
   --mcp                       Run as MCP server
-  --provider <name>           Force provider (openai|anthropic|google|deepseek|groq|openrouter|azure|ollama|aws|aws-anthropic)
-  --model <model>             Set model (e.g., gpt-4o, claude-sonnet-4-20250514, gemini-2.5-flash)
+  --provider <name>           Force provider (openai|anthropic|google|deepseek|groq|openrouter|azure|mistral|cerebras|vercel|oci|ollama|browser-use|aws|aws-anthropic)
+  --model <model>             Set model (e.g., gpt-5-mini, claude-4-sonnet, gemini-2.5-pro)
   -p, --prompt <task>         Run a single task
   --headless                  Run browser in headless mode
   --allowed-domains <items>   Comma-separated allowlist (e.g., example.com,*.example.org)
-  --allow-insecure            Allow sensitive_data without domain restrictions (unsafe)
   --window-width <px>         Browser window width
   --window-height <px>        Browser window height
   --user-data-dir <path>      Chrome user data directory
   --profile-directory <name>  Chrome profile directory (Default, Profile 1, ...)
+  --proxy-url <url>           Proxy server URL (e.g., http://proxy.example.com:8080)
+  --no-proxy <items>          Comma-separated proxy bypass list
+  --proxy-username <value>    Proxy username
+  --proxy-password <value>    Proxy password
   --cdp-url <url>             Connect to an existing Chromium instance via CDP
   --debug                     Enable debug logging`;
 async function runMcpServer() {
@@ -684,7 +842,6 @@ export async function main(argv = process.argv.slice(2)) {
             llm,
             browserProfile,
             browserSession,
-            allowInsecureSensitiveData: args.allow_insecure,
         });
     }
     catch (error) {

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

@@ -0,0 +1,3 @@
+import type { BrowserStateSummary } from '../browser/views.js';
+import type { BrowserSession } from '../browser/session.js';
+export declare const format_browser_state_for_llm: (state: BrowserStateSummary, namespace: Record<string, unknown>, _browser_session: BrowserSession) => Promise<string>;

package/dist/code-use/formatting.js

@@ -0,0 +1,18 @@
+export const format_browser_state_for_llm = async (state, namespace, _browser_session) => {
+    const lines = [];
+    lines.push('## Browser State');
+    lines.push(`**URL:** ${state.url}`);
+    lines.push(`**Title:** ${state.title}`);
+    lines.push('');
+    const vars = Object.keys(namespace)
+        .filter((key) => !key.startsWith('_'))
+        .sort();
+    lines.push(`**Available:** ${vars.length > 0 ? vars.join(', ') : '(none)'}`);
+    lines.push('');
+    const dom = typeof state.llm_representation === 'function'
+        ? state.llm_representation()
+        : '';
+    lines.push('**DOM Structure:**');
+    lines.push(dom || 'Empty DOM tree (you might have to wait for page load)');
+    return lines.join('\n');
+};

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

@@ -0,0 +1,6 @@
+export * from './views.js';
+export * from './utils.js';
+export * from './namespace.js';
+export * from './service.js';
+export * from './formatting.js';
+export * from './notebook-export.js';

package/dist/code-use/index.js

@@ -0,0 +1,6 @@
+export * from './views.js';
+export * from './utils.js';
+export * from './namespace.js';
+export * from './service.js';
+export * from './formatting.js';
+export * from './notebook-export.js';

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

@@ -0,0 +1,5 @@
+import type { BrowserSession } from '../browser/session.js';
+export interface CreateNamespaceOptions {
+    namespace?: Record<string, unknown>;
+}
+export declare const create_namespace: (browser_session: BrowserSession, options?: CreateNamespaceOptions) => Record<string, unknown>;

package/dist/code-use/namespace.js

@@ -0,0 +1,81 @@
+const buildExpression = (source, args) => `(${source})(${args.map((arg) => JSON.stringify(arg)).join(',')})`;
+export const create_namespace = (browser_session, options = {}) => {
+    const namespace = options.namespace ?? {};
+    namespace.browser = browser_session;
+    namespace.navigate = async (url, init = {}) => {
+        await browser_session.navigate_to(url, init);
+    };
+    namespace.go_back = async () => {
+        await browser_session.go_back();
+    };
+    namespace.go_forward = async () => {
+        await browser_session.go_forward();
+    };
+    namespace.refresh = async () => {
+        await browser_session.refresh();
+    };
+    namespace.wait = async (seconds) => {
+        await browser_session.wait(seconds);
+    };
+    namespace.click = async (index) => {
+        const node = await browser_session.get_dom_element_by_index(index);
+        if (!node) {
+            throw new Error(`Element index ${index} not found`);
+        }
+        return browser_session._click_element_node(node);
+    };
+    namespace.input = async (index, text, clear = true) => {
+        const node = await browser_session.get_dom_element_by_index(index);
+        if (!node) {
+            throw new Error(`Element index ${index} not found`);
+        }
+        return browser_session._input_text_element_node(node, text, {
+            clear,
+        });
+    };
+    namespace.select_dropdown = async (index, text) => {
+        const node = await browser_session.get_dom_element_by_index(index);
+        if (!node) {
+            throw new Error(`Element index ${index} not found`);
+        }
+        return browser_session.select_dropdown_option(node, text);
+    };
+    namespace.upload_file = async (index, file_path) => {
+        const node = await browser_session.get_dom_element_by_index(index);
+        if (!node) {
+            throw new Error(`Element index ${index} not found`);
+        }
+        return browser_session.upload_file(node, file_path);
+    };
+    namespace.screenshot = async (full_page = false) => {
+        return browser_session.take_screenshot(full_page);
+    };
+    namespace.send_keys = async (keys) => {
+        await browser_session.send_keys(keys);
+    };
+    namespace.evaluate = async (code, ...args) => {
+        const page = await browser_session.get_current_page();
+        if (!page) {
+            throw new Error('No active page for evaluate');
+        }
+        if (typeof code === 'function') {
+            return page.evaluate(code, ...args);
+        }
+        if (args.length === 0) {
+            return page.evaluate(code);
+        }
+        return page.evaluate(buildExpression(code, args));
+    };
+    namespace.done = (result = null, success = true) => {
+        namespace._task_done = true;
+        namespace._task_success = success;
+        namespace._task_result =
+            typeof result === 'string'
+                ? result
+                : result == null
+                    ? null
+                    : JSON.stringify(result);
+        return result;
+    };
+    return namespace;
+};

package/dist/code-use/notebook-export.d.ts

@@ -0,0 +1,3 @@
+import type { CodeAgent } from './service.js';
+export declare const export_to_ipynb: (agent: CodeAgent, output_path: string) => string;
+export declare const session_to_python_script: (agent: CodeAgent) => string;

package/dist/code-use/notebook-export.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const export_to_ipynb = (agent, output_path) => {
+    const notebook = {
+        nbformat: 4,
+        nbformat_minor: 5,
+        metadata: {
+            kernelspec: {
+                display_name: 'Node.js',
+                language: 'javascript',
+                name: 'javascript',
+            },
+        },
+        cells: agent.session.cells.map((cell) => {
+            if (cell.cell_type === 'markdown') {
+                return {
+                    cell_type: 'markdown',
+                    metadata: {},
+                    source: cell.source.split('\n').map((entry) => `${entry}\n`),
+                };
+            }
+            return {
+                cell_type: 'code',
+                metadata: {},
+                source: cell.source.split('\n').map((entry) => `${entry}\n`),
+                execution_count: cell.execution_count,
+                outputs: cell.output
+                    ? [
+                        {
+                            output_type: 'stream',
+                            name: 'stdout',
+                            text: `${cell.output}\n`,
+                        },
+                    ]
+                    : [],
+            };
+        }),
+    };
+    const resolved = path.resolve(output_path);
+    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+    fs.writeFileSync(resolved, JSON.stringify(notebook, null, 2), 'utf-8');
+    return resolved;
+};
+export const session_to_python_script = (agent) => {
+    const lines = [];
+    lines.push('# Generated from browser-use code-use session');
+    lines.push('');
+    for (const cell of agent.session.cells) {
+        if (cell.cell_type !== 'code') {
+            continue;
+        }
+        lines.push(cell.source);
+        lines.push('');
+    }
+    return lines.join('\n');
+};

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

@@ -0,0 +1,24 @@
+import { CodeAgentHistory, CodeAgentHistoryList, NotebookSession } from './views.js';
+import type { BrowserSession } from '../browser/session.js';
+type ExecutorFn = (source: string, namespace: Record<string, unknown>) => Promise<unknown>;
+export interface CodeAgentOptions {
+    task: string;
+    browser_session: BrowserSession;
+    namespace?: Record<string, unknown>;
+    executor?: ExecutorFn;
+}
+export declare class CodeAgent {
+    task: string;
+    browser_session: BrowserSession;
+    session: NotebookSession;
+    namespace: Record<string, unknown>;
+    complete_history: CodeAgentHistory[];
+    private readonly executor;
+    constructor(options: CodeAgentOptions);
+    add_cell(source: string): import("./views.js").CodeCell;
+    execute_cell(source: string): Promise<import("./views.js").CodeCell>;
+    run(max_steps?: number): Promise<CodeAgentHistoryList>;
+    get history(): CodeAgentHistoryList;
+    close(): Promise<void>;
+}
+export {};