browser-use 0.5.0 → 0.6.1

package/dist/llm/oci-raw/serializer.js

@@ -0,0 +1,128 @@
+import { AssistantMessage, ContentPartImageParam, ContentPartRefusalParam, ContentPartTextParam, SystemMessage, UserMessage, } from '../messages.js';
+const textContent = (text) => ({
+    type: 'TEXT',
+    text,
+});
+const imageContent = (url) => ({
+    type: 'IMAGE',
+    imageUrl: {
+        url,
+    },
+});
+const contentPartsToOci = (content) => {
+    if (typeof content === 'string') {
+        return [textContent(content)];
+    }
+    if (!Array.isArray(content)) {
+        return [];
+    }
+    const parts = [];
+    for (const part of content) {
+        if (part instanceof ContentPartTextParam) {
+            parts.push(textContent(part.text));
+            continue;
+        }
+        if (part instanceof ContentPartImageParam) {
+            parts.push(imageContent(part.image_url.url));
+            continue;
+        }
+        if (part instanceof ContentPartRefusalParam) {
+            parts.push(textContent(`[Refusal] ${part.refusal}`));
+        }
+    }
+    return parts;
+};
+const serializeRole = (message) => {
+    if (message instanceof SystemMessage) {
+        return 'SYSTEM';
+    }
+    if (message instanceof AssistantMessage) {
+        return 'ASSISTANT';
+    }
+    return 'USER';
+};
+const serializeName = (message) => {
+    if (message instanceof UserMessage || message instanceof SystemMessage) {
+        return message.name ?? undefined;
+    }
+    return undefined;
+};
+export class OCIRawMessageSerializer {
+    static serializeMessages(messages) {
+        const serialized = [];
+        for (const message of messages) {
+            const content = message instanceof AssistantMessage
+                ? contentPartsToOci(message.content)
+                : contentPartsToOci(message.content);
+            if (content.length === 0) {
+                continue;
+            }
+            serialized.push({
+                role: serializeRole(message),
+                name: serializeName(message),
+                content,
+            });
+        }
+        return serialized;
+    }
+    static serializeMessagesForCohere(messages) {
+        const conversationParts = [];
+        for (const message of messages) {
+            let text = '';
+            if (message instanceof UserMessage || message instanceof SystemMessage) {
+                const content = message.content;
+                if (typeof content === 'string') {
+                    text = content;
+                }
+                else {
+                    text = content
+                        .map((part) => {
+                        if (part instanceof ContentPartTextParam) {
+                            return part.text;
+                        }
+                        if (part instanceof ContentPartImageParam) {
+                            return part.image_url.url.startsWith('data:image/')
+                                ? '[Image: base64_data]'
+                                : '[Image: external_url]';
+                        }
+                        return '';
+                    })
+                        .filter(Boolean)
+                        .join(' ');
+                }
+            }
+            else if (message instanceof AssistantMessage) {
+                if (typeof message.content === 'string') {
+                    text = message.content;
+                }
+                else if (Array.isArray(message.content)) {
+                    text = message.content
+                        .map((part) => {
+                        if (part instanceof ContentPartTextParam) {
+                            return part.text;
+                        }
+                        if (part instanceof ContentPartRefusalParam) {
+                            return `[Refusal] ${part.refusal}`;
+                        }
+                        return '';
+                    })
+                        .filter(Boolean)
+                        .join(' ');
+                }
+                else if (message.refusal) {
+                    text = `[Refusal] ${message.refusal}`;
+                }
+            }
+            if (!text) {
+                continue;
+            }
+            const prefix = message instanceof SystemMessage
+                ? 'System'
+                : message instanceof AssistantMessage
+                    ? 'Assistant'
+                    : 'User';
+            conversationParts.push(`${prefix}: ${text}`);
+        }
+        return conversationParts.join('\n\n');
+    }
+}

package/dist/mcp/server.d.ts

@@ -75,6 +75,7 @@ export declare class MCPServer {
     private cleanupExpiredSessions;
     private startSessionCleanupLoop;
     private stopSessionCleanupLoop;
+    private formatToolResult;
     private setupHandlers;
     private ensureController;
     private ensureBrowserSession;

package/dist/mcp/server.js

@@ -363,6 +363,64 @@ export class MCPServer {
         clearInterval(this.sessionCleanupInterval);
         this.sessionCleanupInterval = null;
     }
+    formatToolResult(toolName, result) {
+        if (toolName === 'browser_get_state' &&
+            result &&
+            typeof result === 'object' &&
+            !Array.isArray(result)) {
+            const payload = {
+                ...result,
+            };
+            const screenshot = typeof payload.screenshot === 'string' && payload.screenshot.trim()
+                ? payload.screenshot
+                : null;
+            delete payload.screenshot;
+            const pageInfo = payload.page_info &&
+                typeof payload.page_info === 'object' &&
+                !Array.isArray(payload.page_info)
+                ? payload.page_info
+                : null;
+            const viewportWidth = typeof pageInfo?.viewport_width === 'number'
+                ? pageInfo.viewport_width
+                : null;
+            const viewportHeight = typeof pageInfo?.viewport_height === 'number'
+                ? pageInfo.viewport_height
+                : null;
+            if (screenshot &&
+                viewportWidth !== null &&
+                viewportHeight !== null &&
+                payload.screenshot_dimensions == null) {
+                payload.screenshot_dimensions = {
+                    width: viewportWidth,
+                    height: viewportHeight,
+                };
+            }
+            const content = [
+                {
+                    type: 'text',
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ];
+            if (screenshot) {
+                content.push({
+                    type: 'image',
+                    data: screenshot,
+                    mimeType: 'image/png',
+                });
+            }
+            return { content };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: typeof result === 'string'
+                        ? result
+                        : JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
     setupHandlers() {
         // List available tools
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -386,16 +444,7 @@ export class MCPServer {
                 logger.debug(`Executing tool: ${request.params.name}`);
                 this.toolExecutionCount++;
                 const result = await tool.handler(request.params.arguments || {});
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: typeof result === 'string'
-                                ? result
-                                : JSON.stringify(result, null, 2),
-                        },
-                    ],
-                };
+                return this.formatToolResult(request.params.name, result);
             }
             catch (error) {
                 this.errorCount++;
@@ -676,7 +725,7 @@ export class MCPServer {
         this.registerTool('retry_with_browser_use_agent', 'Retry a complex task with the browser-use autonomous agent', z.object({
             task: z.string(),
             max_steps: z.number().int().optional().default(100),
-            model: z.string().optional().default('gpt-4o'),
+            model: z.string().optional(),
             allowed_domains: z.array(z.string()).optional().default([]),
             use_vision: z.boolean().optional().default(true),
         }), async (args) => {
@@ -684,7 +733,7 @@ export class MCPServer {
             if (!task) {
                 throw new Error('task is required');
             }
-            const model = String(args?.model ?? 'gpt-4o').trim();
+            const requestedModel = typeof args?.model === 'string' ? args.model.trim() : '';
             const maxSteps = Number(args?.max_steps ?? 100);
             const useVision = Boolean(args?.use_vision ?? true);
             const allowedDomains = Array.isArray(args?.allowed_domains)
@@ -696,7 +745,7 @@ export class MCPServer {
             const configuredModel = typeof llmConfig.model === 'string' && llmConfig.model.trim()
                 ? llmConfig.model.trim()
                 : 'gpt-4o';
-            const llmModel = model || configuredModel;
+            const llmModel = requestedModel || configuredModel;
             let llm;
             try {
                 llm = this.createLlmFromModelName(llmModel, llmConfig);

package/dist/observability.js

@@ -1,7 +1,7 @@
 import { createRequire } from 'node:module';
 import { config as loadEnv } from 'dotenv';
 import { createLogger } from './logging-config.js';
-loadEnv();
+loadEnv({ quiet: true });
 const require = createRequire(import.meta.url);
 const logger = createLogger('browser_use.observability');
 let lmnrObserve = null;

package/dist/skill-cli/direct.d.ts

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { CloudBrowserClient } from '../browser/cloud/cloud.js';
+export interface DirectModeState {
+    mode?: 'local' | 'remote';
+    cdp_url?: string | null;
+    session_id?: string | null;
+    browser_pid?: number | null;
+    user_data_dir?: string | null;
+    owns_user_data_dir?: boolean | null;
+    active_url?: string | null;
+}
+export declare const DIRECT_STATE_FILE: string;
+interface StreamLike {
+    write(chunk: string): void;
+}
+interface DirectSessionLike {
+    tabs?: Array<{
+        target_id?: string | null;
+        url?: string | null;
+    }>;
+    active_tab?: {
+        target_id?: string | null;
+        url?: string | null;
+    } | null;
+    event_bus?: {
+        stop?: () => Promise<void> | void;
+    } | null;
+    browser_context?: {
+        cookies?: (urls?: string[]) => Promise<any[]>;
+        addCookies?: (cookies: any[]) => Promise<unknown>;
+        clearCookies?: () => Promise<unknown>;
+    } | null;
+    detach_all_watchdogs?: () => void;
+    start: () => Promise<unknown>;
+    navigate_to?: (url: string) => Promise<unknown>;
+    get_current_page?: () => Promise<any>;
+    get_browser_state_with_recovery?: (options?: {
+        include_screenshot?: boolean;
+    }) => Promise<{
+        llm_representation: () => string;
+        url?: string;
+        title?: string;
+        tabs?: unknown[];
+    }>;
+    get_page_info?: () => Promise<any>;
+    get_dom_element_by_index?: (index: number) => Promise<any>;
+    get_locate_element?: (node: any) => Promise<any>;
+    _click_element_node?: (node: any) => Promise<unknown>;
+    click_coordinates?: (x: number, y: number, options?: {
+        button?: 'left' | 'middle' | 'right';
+    }) => Promise<unknown>;
+    send_keys?: (text: string) => Promise<unknown>;
+    _input_text_element_node?: (node: any, text: string, options?: {
+        clear?: boolean;
+    }) => Promise<unknown>;
+    take_screenshot?: (full_page?: boolean) => Promise<string | null>;
+    scroll?: (direction: 'up' | 'down' | 'left' | 'right', amount: number) => Promise<unknown>;
+    go_back?: () => Promise<unknown>;
+    go_forward?: () => Promise<unknown>;
+    get_page_html?: () => Promise<string>;
+    execute_javascript?: (script: string) => Promise<unknown>;
+    switch_to_tab?: (identifier: number | string) => Promise<unknown>;
+    close_tab?: (identifier: number | string) => Promise<unknown>;
+    select_dropdown_option?: (node: any, value: string) => Promise<unknown>;
+    wait_for_element?: (selector: string, timeout: number) => Promise<unknown>;
+    get_cookies?: () => Promise<any[]>;
+}
+export interface DirectCliEnvironment {
+    state_file?: string;
+    stdout?: StreamLike;
+    stderr?: StreamLike;
+    session_factory?: (init: {
+        cdp_url?: string | null;
+    }) => DirectSessionLike;
+    cloud_client_factory?: () => Pick<CloudBrowserClient, 'create_browser' | 'stop_browser'>;
+    local_launcher?: (options: {
+        state: DirectModeState;
+    }) => Promise<{
+        cdp_url: string;
+        browser_pid?: number | null;
+        user_data_dir?: string | null;
+        owns_user_data_dir?: boolean | null;
+    }>;
+    kill_process?: (pid: number) => void | Promise<void>;
+}
+export declare const load_direct_state: (state_file?: string) => DirectModeState;
+export declare const save_direct_state: (state: DirectModeState, state_file?: string) => void;
+export declare const clear_direct_state: (state_file?: string) => void;
+export declare const defaultLocalLauncher: (options: {
+    state: DirectModeState;
+    timeout_ms?: number;
+}) => Promise<{
+    cdp_url: string;
+    browser_pid: number | null;
+    user_data_dir: string | null | undefined;
+    owns_user_data_dir: boolean;
+}>;
+export declare const run_direct_command: (argv: string[], options?: DirectCliEnvironment) => Promise<0 | 1>;
+export declare const main: (argv?: string[]) => Promise<0 | 1>;
+export {};