browser-use 0.6.1 → 0.7.0

package/dist/llm/codex/chat.js

@@ -0,0 +1,392 @@
+import OpenAI from 'openai';
+import { ModelProviderError, ModelRateLimitError } from '../exceptions.js';
+import { ResponsesAPIMessageSerializer, } from '../openai/responses-serializer.js';
+import { SchemaOptimizer, zodSchemaToJsonSchema } from '../schema.js';
+import { ChatInvokeCompletion } from '../views.js';
+import { CodexAuthError, DEFAULT_CODEX_BASE_URL, getCodexCloudflareHeaders, resolveCodexRuntimeCredentials, } from './auth.js';
+const DEFAULT_CODEX_INSTRUCTIONS = 'You are a helpful assistant.';
+const isCodexBackendURL = (baseURL) => {
+    try {
+        const parsed = new URL(baseURL);
+        return (parsed.hostname === 'chatgpt.com' &&
+            parsed.pathname.replace(/\/+$/, '') === '/backend-api/codex');
+    }
+    catch {
+        return false;
+    }
+};
+export class ChatCodex {
+    model;
+    provider = 'codex';
+    apiKey;
+    baseURL;
+    timeout;
+    maxRetries;
+    defaultHeaders;
+    defaultQuery;
+    fetchImplementation;
+    fetchOptions;
+    reasoningEffort;
+    maxCompletionTokens;
+    topP;
+    seed;
+    serviceTier;
+    include;
+    addSchemaToSystemPrompt;
+    dontForceStructuredOutput;
+    removeMinItemsFromSchema;
+    removeDefaultsFromSchema;
+    configDir;
+    authStorePath;
+    refreshSkewSeconds;
+    constructor(options = {}) {
+        const { model = process.env.BROWSER_USE_CODEX_MODEL ?? 'gpt-5.5', apiKey = process.env.BROWSER_USE_CODEX_ACCESS_TOKEN ?? null, baseURL = process.env.BROWSER_USE_CODEX_BASE_URL ??
+            DEFAULT_CODEX_BASE_URL, timeout = null, maxRetries = 2, defaultHeaders = null, defaultQuery = null, fetchImplementation, fetchOptions = null, reasoningEffort = 'low', maxCompletionTokens = 4096, topP = null, seed = null, serviceTier = null, include = null, addSchemaToSystemPrompt = false, dontForceStructuredOutput = false, removeMinItemsFromSchema = false, removeDefaultsFromSchema = false, configDir = null, authStorePath = null, refreshSkewSeconds, } = options;
+        this.model = model;
+        this.apiKey = apiKey?.trim() || null;
+        this.baseURL =
+            (baseURL ?? '').trim().replace(/\/+$/, '') || DEFAULT_CODEX_BASE_URL;
+        this.timeout = timeout;
+        this.maxRetries = maxRetries;
+        this.defaultHeaders = defaultHeaders;
+        this.defaultQuery = defaultQuery;
+        this.fetchImplementation = fetchImplementation;
+        this.fetchOptions = fetchOptions;
+        this.reasoningEffort = reasoningEffort;
+        this.maxCompletionTokens = maxCompletionTokens;
+        this.topP = topP;
+        this.seed = seed;
+        this.serviceTier = serviceTier;
+        this.include = include ? [...include] : null;
+        this.addSchemaToSystemPrompt = addSchemaToSystemPrompt;
+        this.dontForceStructuredOutput = dontForceStructuredOutput;
+        this.removeMinItemsFromSchema = removeMinItemsFromSchema;
+        this.removeDefaultsFromSchema = removeDefaultsFromSchema;
+        this.configDir = configDir;
+        this.authStorePath = authStorePath;
+        this.refreshSkewSeconds = refreshSkewSeconds;
+    }
+    get name() {
+        return this.model;
+    }
+    get model_name() {
+        return this.model;
+    }
+    async resolveClientConfig(forceRefresh = false) {
+        if (this.apiKey) {
+            return {
+                apiKey: this.apiKey,
+                baseURL: this.baseURL,
+            };
+        }
+        const credentials = await resolveCodexRuntimeCredentials({
+            configDir: this.configDir,
+            authStorePath: this.authStorePath,
+            baseURL: this.baseURL,
+            forceRefresh,
+            refreshSkewSeconds: this.refreshSkewSeconds,
+            fetchImplementation: this.fetchImplementation,
+        });
+        return {
+            apiKey: credentials.api_key,
+            baseURL: credentials.base_url,
+        };
+    }
+    createClient(config) {
+        const codexHeaders = isCodexBackendURL(config.baseURL)
+            ? getCodexCloudflareHeaders(config.apiKey)
+            : {};
+        return new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseURL,
+            timeout: this.timeout ?? undefined,
+            maxRetries: this.maxRetries,
+            defaultHeaders: {
+                ...codexHeaders,
+                ...(this.defaultHeaders ?? {}),
+            },
+            defaultQuery: this.defaultQuery ?? undefined,
+            fetch: this.fetchImplementation,
+            fetchOptions: (this.fetchOptions ?? undefined),
+        });
+    }
+    getResponsesUsage(response) {
+        if (!response?.usage) {
+            return null;
+        }
+        return {
+            prompt_tokens: response.usage.input_tokens ?? 0,
+            prompt_cached_tokens: response.usage.input_tokens_details?.cached_tokens ?? null,
+            prompt_cache_creation_tokens: null,
+            prompt_image_tokens: null,
+            completion_tokens: response.usage.output_tokens ?? 0,
+            total_tokens: response.usage.total_tokens ?? 0,
+        };
+    }
+    getResponseOutputText(response) {
+        if (typeof response?.output_text === 'string') {
+            return response.output_text;
+        }
+        const outputs = Array.isArray(response?.output) ? response.output : [];
+        for (const item of outputs) {
+            if (Array.isArray(item?.content)) {
+                for (const part of item.content) {
+                    if (typeof part?.text === 'string') {
+                        return part.text;
+                    }
+                    if (typeof part?.output_text === 'string') {
+                        return part.output_text;
+                    }
+                }
+            }
+        }
+        return '';
+    }
+    async collectResponse(responseOrStream) {
+        if (!responseOrStream ||
+            typeof responseOrStream[Symbol.asyncIterator] !== 'function') {
+            return responseOrStream;
+        }
+        let terminalResponse = null;
+        const outputItems = [];
+        const textDeltas = [];
+        for await (const event of responseOrStream) {
+            const eventType = event?.type;
+            if (eventType === 'response.output_text.delta' &&
+                typeof event?.delta === 'string') {
+                textDeltas.push(event.delta);
+            }
+            if (eventType === 'response.output_item.done' && event?.item) {
+                outputItems.push(event.item);
+            }
+            if (eventType === 'response.completed' ||
+                eventType === 'response.incomplete' ||
+                eventType === 'response.failed') {
+                terminalResponse = event.response ?? null;
+            }
+        }
+        const fallbackOutputText = textDeltas.join('');
+        if (!terminalResponse) {
+            return {
+                output_text: fallbackOutputText,
+                output: outputItems,
+                status: fallbackOutputText ? 'completed' : 'incomplete',
+            };
+        }
+        if (typeof terminalResponse.output_text !== 'string' &&
+            fallbackOutputText) {
+            terminalResponse.output_text = fallbackOutputText;
+        }
+        if ((!Array.isArray(terminalResponse.output) ||
+            terminalResponse.output.length === 0) &&
+            outputItems.length > 0) {
+            terminalResponse.output = outputItems;
+        }
+        return terminalResponse;
+    }
+    getInputText(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (!Array.isArray(content)) {
+            return '';
+        }
+        return content
+            .map((part) => {
+            if (part &&
+                typeof part === 'object' &&
+                'text' in part &&
+                typeof part.text === 'string') {
+                return part.text;
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    getModelParamsForResponses(baseURL) {
+        const codexBackend = isCodexBackendURL(baseURL);
+        const modelParams = {
+            store: false,
+            reasoning: codexBackend
+                ? { effort: this.reasoningEffort, summary: 'auto' }
+                : { effort: this.reasoningEffort },
+        };
+        if (this.maxCompletionTokens !== null && !codexBackend) {
+            modelParams.max_output_tokens = this.maxCompletionTokens;
+        }
+        if (this.topP !== null && !codexBackend) {
+            modelParams.top_p = this.topP;
+        }
+        if (this.seed !== null && !codexBackend) {
+            modelParams.seed = this.seed;
+        }
+        if (this.serviceTier !== null) {
+            modelParams.service_tier = this.serviceTier;
+        }
+        if (codexBackend) {
+            modelParams.stream = true;
+            modelParams.include = this.include ?? ['reasoning.encrypted_content'];
+            modelParams.tools = [];
+            modelParams.tool_choice = 'auto';
+            modelParams.parallel_tool_calls = true;
+        }
+        else if (this.include !== null) {
+            modelParams.include = this.include;
+        }
+        return modelParams;
+    }
+    buildCodexBackendInput(inputMessages) {
+        const instructionParts = [];
+        const input = [];
+        for (const message of inputMessages) {
+            if (message.role === 'system') {
+                const text = this.getInputText(message.content).trim();
+                if (text) {
+                    instructionParts.push(text);
+                }
+                continue;
+            }
+            input.push(message);
+        }
+        return {
+            input: input.length > 0 ? input : [{ role: 'user', content: '' }],
+            instructions: instructionParts.join('\n\n').trim() || DEFAULT_CODEX_INSTRUCTIONS,
+        };
+    }
+    getZodSchemaCandidate(output_format) {
+        const output = output_format;
+        if (output &&
+            typeof output === 'object' &&
+            typeof output.safeParse === 'function' &&
+            typeof output.parse === 'function') {
+            return output;
+        }
+        if (output &&
+            typeof output === 'object' &&
+            output.schema &&
+            typeof output.schema.safeParse === 'function' &&
+            typeof output.schema.parse === 'function') {
+            return output.schema;
+        }
+        return null;
+    }
+    buildRequest(messages, zodSchemaCandidate, baseURL) {
+        const serializer = new ResponsesAPIMessageSerializer();
+        const inputMessages = serializer.serialize(messages);
+        const codexBackend = isCodexBackendURL(baseURL);
+        const codexInput = codexBackend
+            ? this.buildCodexBackendInput(inputMessages)
+            : null;
+        const request = {
+            model: this.model,
+            input: codexInput?.input ?? inputMessages,
+            ...this.getModelParamsForResponses(baseURL),
+        };
+        if (codexInput) {
+            request.instructions = codexInput.instructions;
+        }
+        if (!zodSchemaCandidate) {
+            return request;
+        }
+        try {
+            const rawJsonSchema = zodSchemaToJsonSchema(zodSchemaCandidate, {
+                name: 'agent_output',
+                target: 'jsonSchema7',
+            });
+            const optimizedJsonSchema = SchemaOptimizer.createOptimizedJsonSchema(rawJsonSchema, {
+                removeMinItems: this.removeMinItemsFromSchema,
+                removeDefaults: this.removeDefaultsFromSchema,
+            });
+            if (this.addSchemaToSystemPrompt &&
+                (codexBackend ||
+                    (inputMessages.length > 0 && inputMessages[0]?.role === 'system'))) {
+                const schemaText = `\n<json_schema>\n${JSON.stringify(optimizedJsonSchema)}\n</json_schema>`;
+                if (codexBackend) {
+                    request.instructions = `${String(request.instructions ?? DEFAULT_CODEX_INSTRUCTIONS)}${schemaText}`;
+                }
+                else {
+                    const firstInput = inputMessages[0];
+                    const firstContent = firstInput?.content;
+                    let patchedContent = firstContent ?? '';
+                    if (typeof firstContent === 'string') {
+                        patchedContent = firstContent + schemaText;
+                    }
+                    else if (Array.isArray(firstContent)) {
+                        patchedContent = [
+                            ...firstContent,
+                            { type: 'input_text', text: schemaText },
+                        ];
+                    }
+                    inputMessages[0] = {
+                        ...inputMessages[0],
+                        content: patchedContent,
+                    };
+                    request.input = inputMessages;
+                }
+            }
+            if (!this.dontForceStructuredOutput) {
+                request.text = {
+                    format: {
+                        type: 'json_schema',
+                        name: 'agent_output',
+                        strict: true,
+                        schema: optimizedJsonSchema,
+                    },
+                };
+            }
+        }
+        catch {
+            // Skip structured output forcing when schema conversion fails.
+        }
+        return request;
+    }
+    async ainvoke(messages, output_format, options = {}) {
+        return this.invokeResponses(messages, output_format, options, false);
+    }
+    async invokeResponses(messages, output_format, options, forceRefresh) {
+        const zodSchemaCandidate = this.getZodSchemaCandidate(output_format);
+        try {
+            const clientConfig = await this.resolveClientConfig(forceRefresh);
+            const request = this.buildRequest(messages, zodSchemaCandidate, clientConfig.baseURL);
+            const client = this.createClient(clientConfig);
+            const responseOrStream = await client.responses.create(request, options.signal ? { signal: options.signal } : undefined);
+            const response = await this.collectResponse(responseOrStream);
+            const content = this.getResponseOutputText(response);
+            const usage = this.getResponsesUsage(response);
+            const stopReason = response?.status ?? null;
+            let completion = content;
+            if (output_format) {
+                if (zodSchemaCandidate) {
+                    const parsedJson = JSON.parse(content);
+                    const output = output_format;
+                    if (output &&
+                        typeof output === 'object' &&
+                        output.schema &&
+                        typeof output.schema.parse === 'function') {
+                        completion = output.schema.parse(parsedJson);
+                    }
+                    else {
+                        completion = output.parse(parsedJson);
+                    }
+                }
+                else {
+                    completion = output_format.parse(content);
+                }
+            }
+            return new ChatInvokeCompletion(completion, usage, null, null, stopReason);
+        }
+        catch (error) {
+            if (!this.apiKey && !forceRefresh && error?.status === 401) {
+                return this.invokeResponses(messages, output_format, options, true);
+            }
+            if (error?.status === 429) {
+                throw new ModelRateLimitError(error?.message ?? 'Rate limit exceeded', 429, this.model);
+            }
+            if (error instanceof CodexAuthError) {
+                throw error;
+            }
+            throw new ModelProviderError(error?.message ?? String(error), error?.status ?? 500, this.model);
+        }
+    }
+}

package/dist/llm/codex/index.d.ts

@@ -0,0 +1,2 @@
+export * from './auth.js';
+export * from './chat.js';

package/dist/llm/codex/index.js

@@ -0,0 +1,2 @@
+export * from './auth.js';
+export * from './chat.js';

package/dist/llm/google/chat.js

@@ -3,6 +3,22 @@ import { ModelProviderError } from '../exceptions.js';
 import { ChatInvokeCompletion } from '../views.js';
 import { SchemaOptimizer, zodSchemaToJsonSchema } from '../schema.js';
 import { GoogleMessageSerializer } from './serializer.js';
+import { get_browser_use_version } from '../../utils.js';
+const buildGoogleHttpOptions = (httpOptions) => {
+    const resolvedHttpOptions = {
+        ...(httpOptions ?? {}),
+    };
+    const existingHeaders = resolvedHttpOptions.headers;
+    const headers = existingHeaders &&
+        typeof existingHeaders === 'object' &&
+        !Array.isArray(existingHeaders)
+        ? Object.fromEntries(Object.entries(existingHeaders).map(([key, value]) => [String(key), String(value)]))
+        : {};
+    headers['x-goog-api-client'] =
+        `browser-use/${get_browser_use_version() || 'unknown'}`;
+    resolvedHttpOptions.headers = headers;
+    return resolvedHttpOptions;
+};
 export class ChatGoogle {
     model;
     provider = 'google';
@@ -44,6 +60,7 @@ export class ChatGoogle {
                 credentials,
             };
         const resolvedVertexAi = vertexai ?? vertexAi;
+        const resolvedHttpOptions = buildGoogleHttpOptions(httpOptions);
         const clientOptions = {
             ...(apiKey != null ? { apiKey } : {}),
             ...(baseUrl ? { baseUrl } : {}),
@@ -51,7 +68,7 @@ export class ChatGoogle {
             ...(resolvedVertexAi != null ? { vertexai: resolvedVertexAi } : {}),
             ...(project ? { project } : {}),
             ...(location ? { location } : {}),
-            ...(httpOptions ? { httpOptions } : {}),
+            httpOptions: resolvedHttpOptions,
             ...(resolvedGoogleAuthOptions
                 ? { googleAuthOptions: resolvedGoogleAuthOptions }
                 : {}),

package/dist/logging-config.js

@@ -45,7 +45,26 @@ const writePayload = (stream, level, payload) => {
     }
 };
 const ensureFilePathReady = (filePath) => {
-    fs.mkdirSync(path.dirname(path.resolve(filePath)), { recursive: true });
+    const dirPath = path.dirname(path.resolve(filePath));
+    const existed = fs.existsSync(dirPath);
+    fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+    if (!existed && process.platform !== 'win32') {
+        fs.chmodSync(dirPath, 0o700);
+    }
+};
+const createPrivateLogStream = (filePath) => {
+    const resolved = path.resolve(filePath);
+    ensureFilePathReady(resolved);
+    const fd = fs.openSync(resolved, 'a', 0o600);
+    if (process.platform !== 'win32') {
+        fs.chmodSync(resolved, 0o600);
+    }
+    return fs.createWriteStream(resolved, {
+        fd,
+        flags: 'a',
+        encoding: 'utf-8',
+        autoClose: true,
+    });
 };
 const closeFileStreams = () => {
     if (debugLogStream) {
@@ -121,19 +140,11 @@ export const setupLogging = (options = {}) => {
     consoleStream = options.stream || process.stderr;
     const debugLogFile = options.debugLogFile ?? process.env.BROWSER_USE_DEBUG_LOG_FILE ?? null;
     if (debugLogFile && debugLogFile.trim().length > 0) {
-        ensureFilePathReady(debugLogFile);
-        debugLogStream = fs.createWriteStream(path.resolve(debugLogFile), {
-            flags: 'a',
-            encoding: 'utf-8',
-        });
+        debugLogStream = createPrivateLogStream(debugLogFile);
     }
     const infoLogFile = options.infoLogFile ?? process.env.BROWSER_USE_INFO_LOG_FILE ?? null;
     if (infoLogFile && infoLogFile.trim().length > 0) {
-        ensureFilePathReady(infoLogFile);
-        infoLogStream = fs.createWriteStream(path.resolve(infoLogFile), {
-            flags: 'a',
-            encoding: 'utf-8',
-        });
+        infoLogStream = createPrivateLogStream(infoLogFile);
     }
     configured = true;
     return createLogger('browser_use');

package/dist/mcp/client.d.ts

@@ -25,6 +25,7 @@
 import { type Tool, type Prompt } from '@modelcontextprotocol/sdk/types.js';
 import type { Controller } from '../controller/service.js';
 import type { Tools } from '../tools/service.js';
+export { formatMcpCommandForLog, formatMcpToolArgsForLog, redactMcpLogMessage, } from './redaction.js';
 export interface MCPClientOptions {
     /** Maximum number of connection retry attempts (default: 3) */
     maxRetries?: number;

package/dist/mcp/client.js

@@ -31,7 +31,9 @@ import { ActionResult } from '../agent/views.js';
 import { productTelemetry } from '../telemetry/service.js';
 import { MCPClientTelemetryEvent } from '../telemetry/views.js';
 import { get_browser_use_version, retryAsync } from '../utils.js';
+import { formatMcpCommandForLog, formatMcpToolArgsForLog, redactMcpLogMessage, } from './redaction.js';
 const logger = createLogger('browser_use.mcp.client');
+export { formatMcpCommandForLog, formatMcpToolArgsForLog, redactMcpLogMessage, } from './redaction.js';
 export class MCPClient {
     client;
     command;
@@ -89,7 +91,7 @@ export class MCPClient {
         const startTime = Date.now() / 1000;
         let errorMsg = null;
         try {
-            logger.info(`🔌 Connecting to MCP server '${this.serverName}': ${this.command} ${this.args.join(' ')}`);
+            logger.info(`🔌 Connecting to MCP server '${this.serverName}': ${formatMcpCommandForLog(this.command, this.args)}`);
             // Use retry logic for connection
             await retryAsync(async () => {
                 // Create transport with environment variables
@@ -105,7 +107,7 @@ export class MCPClient {
                 delayMs: 1000,
                 backoffMultiplier: 2,
                 onRetry: (error, attempt, delay) => {
-                    logger.warning(`Connection attempt ${attempt} failed for '${this.serverName}': ${error.message}. Retrying in ${delay}ms...`);
+                    logger.warning(`Connection attempt ${attempt} failed for '${this.serverName}': ${redactMcpLogMessage(error)}. Retrying in ${delay}ms...`);
                 },
             });
             this._connected = true;
@@ -125,7 +127,7 @@ export class MCPClient {
             this._startHealthCheck();
         }
         catch (error) {
-            errorMsg = error instanceof Error ? error.message : String(error);
+            errorMsg = redactMcpLogMessage(error);
             this._connected = false;
             throw error;
         }
@@ -183,7 +185,7 @@ export class MCPClient {
             logger.info(`Disconnected from '${this.serverName}' (${stats.toolCallCount} tool calls, ${(stats.successRate * 100).toFixed(1)}% success rate)`);
         }
         catch (error) {
-            errorMsg = error instanceof Error ? error.message : String(error);
+            errorMsg = redactMcpLogMessage(error);
             logger.error(`Error disconnecting from MCP server: ${errorMsg}`);
         }
         finally {
@@ -220,7 +222,7 @@ export class MCPClient {
         const startTime = Date.now() / 1000;
         let errorMsg = null;
         try {
-            logger.debug(`🔧 Calling MCP tool '${name}' with params: ${JSON.stringify(args)}`);
+            logger.debug(`🔧 Calling MCP tool '${name}' with params: ${formatMcpToolArgsForLog(args)}`);
             this._toolCallCount++;
             const result = await this.client.request(CallToolRequestSchema, {
                 name,
@@ -230,7 +232,7 @@ export class MCPClient {
         }
         catch (error) {
             this._errorCount++;
-            errorMsg = error instanceof Error ? error.message : String(error);
+            errorMsg = redactMcpLogMessage(error);
             logger.error(`MCP tool '${name}' failed: ${errorMsg}`);
             throw error;
         }
@@ -308,7 +310,7 @@ export class MCPClient {
                 });
             }
             catch (error) {
-                const errorMsg = error instanceof Error ? error.message : String(error);
+                const errorMsg = redactMcpLogMessage(error);
                 logger.error(`MCP tool '${tool.name}' failed: ${errorMsg}`);
                 return new ActionResult({
                     error: `MCP tool '${tool.name}' failed: ${errorMsg}`,
@@ -541,7 +543,7 @@ export class MCPClient {
             return result;
         }
         catch (error) {
-            logger.error(`Failed to get prompt '${name}': ${error}`);
+            logger.error(`Failed to get prompt '${name}': ${redactMcpLogMessage(error)}`);
             throw error;
         }
     }
@@ -557,7 +559,7 @@ export class MCPClient {
                 await this._performHealthCheck();
             }
             catch (error) {
-                logger.warning(`Health check failed for '${this.serverName}': ${error}`);
+                logger.warning(`Health check failed for '${this.serverName}': ${redactMcpLogMessage(error)}`);
                 if (this.autoReconnect) {
                     await this._attemptReconnect();
                 }
@@ -600,7 +602,7 @@ export class MCPClient {
             logger.info(`✅ Reconnected to '${this.serverName}'`);
         }
         catch (error) {
-            logger.error(`Failed to reconnect to '${this.serverName}': ${error}`);
+            logger.error(`Failed to reconnect to '${this.serverName}': ${redactMcpLogMessage(error)}`);
         }
     }
     /**

package/dist/mcp/redaction.d.ts

@@ -0,0 +1,3 @@
+export declare const formatMcpCommandForLog: (command: string, args: string[]) => string;
+export declare const redactMcpLogMessage: (value: unknown) => string;
+export declare const formatMcpToolArgsForLog: (args: unknown) => string;