browser-use 0.2.0 → 0.3.0

package/dist/llm/models.js

@@ -0,0 +1,317 @@
+import { ChatAnthropic } from './anthropic/chat.js';
+import { ChatBedrockConverse } from './aws/chat-bedrock.js';
+import { ChatAzure } from './azure/chat.js';
+import { ChatBrowserUse } from './browser-use/chat.js';
+import { ChatCerebras } from './cerebras/chat.js';
+import { ChatDeepSeek } from './deepseek/chat.js';
+import { ChatGoogle } from './google/chat.js';
+import { ChatGroq } from './groq/chat.js';
+import { ChatMistral } from './mistral/chat.js';
+import { ChatOllama } from './ollama/chat.js';
+import { ChatOpenAI } from './openai/chat.js';
+import { ChatOpenRouter } from './openrouter/chat.js';
+import { ChatVercel } from './vercel/chat.js';
+const AVAILABLE_PROVIDERS = [
+    'openai',
+    'anthropic',
+    'google',
+    'deepseek',
+    'groq',
+    'openrouter',
+    'azure',
+    'ollama',
+    'aws',
+    'browser-use',
+    'mistral',
+    'cerebras',
+    'vercel',
+];
+const MISTRAL_ALIAS_MAP = {
+    large: 'mistral-large-latest',
+    medium: 'mistral-medium-latest',
+    small: 'mistral-small-latest',
+    codestral: 'codestral-latest',
+    'pixtral-large': 'pixtral-large-latest',
+    pixtral_large: 'pixtral-large-latest',
+};
+const convertPythonModelPart = (modelPart) => {
+    if (modelPart.includes('gpt_4_1_mini')) {
+        return modelPart.replace('gpt_4_1_mini', 'gpt-4.1-mini');
+    }
+    if (modelPart.includes('gpt_4o_mini')) {
+        return modelPart.replace('gpt_4o_mini', 'gpt-4o-mini');
+    }
+    if (modelPart.includes('gpt_4o')) {
+        return modelPart.replace('gpt_4o', 'gpt-4o');
+    }
+    if (modelPart.includes('gemini_2_0')) {
+        return modelPart.replace('gemini_2_0', 'gemini-2.0').replace(/_/g, '-');
+    }
+    if (modelPart.includes('gemini_2_5')) {
+        return modelPart.replace('gemini_2_5', 'gemini-2.5').replace(/_/g, '-');
+    }
+    if (modelPart.includes('llama3_1')) {
+        return modelPart.replace('llama3_1', 'llama3.1').replace(/_/g, '-');
+    }
+    if (modelPart.includes('llama3_3')) {
+        return modelPart.replace('llama3_3', 'llama-3.3').replace(/_/g, '-');
+    }
+    if (modelPart.includes('llama_4_scout')) {
+        return modelPart
+            .replace('llama_4_scout', 'llama-4-scout')
+            .replace(/_/g, '-');
+    }
+    if (modelPart.includes('llama_4_maverick')) {
+        return modelPart
+            .replace('llama_4_maverick', 'llama-4-maverick')
+            .replace(/_/g, '-');
+    }
+    if (modelPart.includes('gpt_oss_120b')) {
+        return modelPart.replace('gpt_oss_120b', 'gpt-oss-120b');
+    }
+    if (modelPart.includes('qwen_3_32b')) {
+        return modelPart.replace('qwen_3_32b', 'qwen-3-32b');
+    }
+    if (modelPart.includes('qwen_3_235b_a22b_instruct_2507')) {
+        return modelPart.replace('qwen_3_235b_a22b_instruct_2507', 'qwen-3-235b-a22b-instruct-2507');
+    }
+    if (modelPart.includes('qwen_3_235b_a22b_instruct')) {
+        return modelPart.replace('qwen_3_235b_a22b_instruct', 'qwen-3-235b-a22b-instruct-2507');
+    }
+    if (modelPart.includes('qwen_3_235b_a22b_thinking_2507')) {
+        return modelPart.replace('qwen_3_235b_a22b_thinking_2507', 'qwen-3-235b-a22b-thinking-2507');
+    }
+    if (modelPart.includes('qwen_3_235b_a22b_thinking')) {
+        return modelPart.replace('qwen_3_235b_a22b_thinking', 'qwen-3-235b-a22b-thinking-2507');
+    }
+    if (modelPart.includes('qwen_3_coder_480b')) {
+        return modelPart.replace('qwen_3_coder_480b', 'qwen-3-coder-480b');
+    }
+    return modelPart.replace(/_/g, '-');
+};
+const normalizeMistralModel = (model) => {
+    const key = model.trim().toLowerCase();
+    return MISTRAL_ALIAS_MAP[key] ?? model;
+};
+const inferProviderFromModel = (model) => {
+    const lower = model.toLowerCase();
+    if (lower.startsWith('gpt') ||
+        lower.startsWith('o1') ||
+        lower.startsWith('o3') ||
+        lower.startsWith('o4') ||
+        lower.startsWith('gpt-5')) {
+        return 'openai';
+    }
+    if (lower.startsWith('claude')) {
+        return 'anthropic';
+    }
+    if (lower.startsWith('gemini')) {
+        return 'google';
+    }
+    if (lower.startsWith('deepseek')) {
+        return 'deepseek';
+    }
+    if (lower.startsWith('groq:')) {
+        return 'groq';
+    }
+    if (lower.startsWith('openrouter:')) {
+        return 'openrouter';
+    }
+    if (lower.startsWith('azure:')) {
+        return 'azure';
+    }
+    if (lower.startsWith('ollama:')) {
+        return 'ollama';
+    }
+    if (lower.startsWith('mistral:')) {
+        return 'mistral';
+    }
+    if (lower.startsWith('cerebras:')) {
+        return 'cerebras';
+    }
+    if (lower.startsWith('vercel:')) {
+        return 'vercel';
+    }
+    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('bedrock:')) {
+        return 'aws';
+    }
+    if (lower.startsWith('anthropic.')) {
+        return 'aws';
+    }
+    if (lower.startsWith('bu-') || lower.startsWith('browser-use/')) {
+        return 'browser-use';
+    }
+    if (lower.includes('/') &&
+        !lower.startsWith('http://') &&
+        !lower.startsWith('https://')) {
+        return 'openrouter';
+    }
+    return null;
+};
+const normalizeModelForProvider = (provider, model) => {
+    const lower = model.toLowerCase();
+    if (provider === 'groq' && lower.startsWith('groq:')) {
+        return model.slice('groq:'.length);
+    }
+    if (provider === 'openrouter' && lower.startsWith('openrouter:')) {
+        return model.slice('openrouter:'.length);
+    }
+    if (provider === 'azure' && lower.startsWith('azure:')) {
+        return model.slice('azure:'.length);
+    }
+    if (provider === 'ollama' && lower.startsWith('ollama:')) {
+        return model.slice('ollama:'.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 === 'aws' && lower.startsWith('bedrock:')) {
+        return model.slice('bedrock:'.length);
+    }
+    return model;
+};
+const buildProviderModel = (provider, model) => {
+    switch (provider) {
+        case 'openai':
+            return new ChatOpenAI({
+                model,
+                apiKey: process.env.OPENAI_API_KEY,
+            });
+        case 'anthropic':
+            return new ChatAnthropic({
+                model,
+                apiKey: process.env.ANTHROPIC_API_KEY,
+            });
+        case 'google':
+            return new ChatGoogle({
+                model,
+                apiKey: process.env.GOOGLE_API_KEY || '',
+            });
+        case 'deepseek':
+            return new ChatDeepSeek({
+                model,
+                apiKey: process.env.DEEPSEEK_API_KEY,
+            });
+        case 'groq':
+            return new ChatGroq({
+                model,
+                apiKey: process.env.GROQ_API_KEY,
+            });
+        case 'openrouter':
+            return new ChatOpenRouter({
+                model,
+                apiKey: process.env.OPENROUTER_API_KEY,
+            });
+        case 'azure':
+            return new ChatAzure({
+                model,
+                apiKey: process.env.AZURE_OPENAI_KEY ?? process.env.AZURE_OPENAI_API_KEY,
+                endpoint: process.env.AZURE_OPENAI_ENDPOINT,
+            });
+        case 'ollama':
+            return new ChatOllama({
+                model,
+                host: process.env.OLLAMA_HOST || 'http://localhost:11434',
+            });
+        case 'mistral':
+            return new ChatMistral({
+                model: normalizeMistralModel(model),
+                apiKey: process.env.MISTRAL_API_KEY,
+                baseURL: process.env.MISTRAL_BASE_URL,
+            });
+        case 'cerebras':
+            return new ChatCerebras({
+                model,
+                apiKey: process.env.CEREBRAS_API_KEY,
+                baseURL: process.env.CEREBRAS_BASE_URL,
+            });
+        case 'vercel':
+            return new ChatVercel({
+                model,
+                apiKey: process.env.VERCEL_API_KEY,
+                baseURL: process.env.VERCEL_BASE_URL,
+            });
+        case 'aws':
+            return new ChatBedrockConverse({
+                model,
+                region: process.env.AWS_REGION || 'us-east-1',
+            });
+        case 'browser-use':
+            return new ChatBrowserUse({
+                model,
+                apiKey: process.env.BROWSER_USE_API_KEY,
+            });
+        default:
+            throw new Error(`Unknown provider '${provider}'. Available providers: ${AVAILABLE_PROVIDERS.join(', ')}`);
+    }
+};
+export const getLlmByName = (modelName) => {
+    const normalizedName = modelName.trim();
+    if (!normalizedName) {
+        throw new Error('Model name cannot be empty');
+    }
+    if (normalizedName === 'bu_latest') {
+        return buildProviderModel('browser-use', 'bu-latest');
+    }
+    if (normalizedName === 'bu_1_0') {
+        return buildProviderModel('browser-use', 'bu-1-0');
+    }
+    if (normalizedName === 'bu_2_0') {
+        return buildProviderModel('browser-use', 'bu-2-0');
+    }
+    if (normalizedName === 'mistral_large') {
+        return buildProviderModel('mistral', 'mistral-large-latest');
+    }
+    if (normalizedName === 'mistral_medium') {
+        return buildProviderModel('mistral', 'mistral-medium-latest');
+    }
+    if (normalizedName === 'mistral_small') {
+        return buildProviderModel('mistral', 'mistral-small-latest');
+    }
+    if (normalizedName === 'codestral') {
+        return buildProviderModel('mistral', 'codestral-latest');
+    }
+    if (normalizedName === 'pixtral_large') {
+        return buildProviderModel('mistral', 'pixtral-large-latest');
+    }
+    const separator = normalizedName.indexOf('_');
+    if (separator > 0) {
+        const provider = normalizedName.slice(0, separator);
+        if (provider === 'oci') {
+            throw new Error('OCI models require manual configuration. Use ChatOCIRaw directly with your OCI credentials.');
+        }
+        const modelPart = normalizedName.slice(separator + 1);
+        if (provider === 'bu') {
+            return buildProviderModel('browser-use', `bu-${modelPart.replace(/_/g, '-')}`);
+        }
+        if (provider === 'browser-use') {
+            return buildProviderModel('browser-use', modelPart.replace(/_/g, '/'));
+        }
+        if (AVAILABLE_PROVIDERS.includes(provider)) {
+            return buildProviderModel(provider, convertPythonModelPart(modelPart));
+        }
+    }
+    const inferredProvider = inferProviderFromModel(normalizedName);
+    if (!inferredProvider) {
+        throw new Error(`Invalid model name format: '${normalizedName}'. Expected provider-prefixed name like 'openai_gpt_4o' or a recognizable model prefix.`);
+    }
+    const normalizedModel = normalizeModelForProvider(inferredProvider, normalizedName);
+    return buildProviderModel(inferredProvider, normalizedModel);
+};

package/dist/llm/ollama/chat.d.ts

@@ -1,13 +1,25 @@
+import { type Config as OllamaClientConfig, type Options as OllamaOptions } from 'ollama';
 import type { BaseChatModel, ChatInvokeOptions } from '../base.js';
 import { ChatInvokeCompletion } from '../views.js';
 import type { Message } from '../messages.js';
+export interface ChatOllamaOptions {
+    model?: string;
+    host?: string;
+    timeout?: number | null;
+    clientParams?: Partial<OllamaClientConfig> | null;
+    ollamaOptions?: Partial<OllamaOptions> | null;
+}
 export declare class ChatOllama implements BaseChatModel {
     model: string;
     provider: string;
     private client;
-    constructor(model?: string, host?: string);
+    private ollamaOptions;
+    constructor(modelOrOptions?: string | ChatOllamaOptions, host?: string);
     get name(): string;
     get model_name(): string;
+    private getZodSchemaCandidate;
+    private parseOutput;
+    private createTimeoutFetch;
     ainvoke(messages: Message[], output_format?: undefined, options?: ChatInvokeOptions): Promise<ChatInvokeCompletion<string>>;
     ainvoke<T>(messages: Message[], output_format: {
         parse: (input: string) => T;

package/dist/llm/ollama/chat.js

@@ -1,13 +1,33 @@
-import { Ollama } from 'ollama';
+import { Ollama, } from 'ollama';
+import { ModelProviderError } from '../exceptions.js';
 import { ChatInvokeCompletion } from '../views.js';
+import { zodSchemaToJsonSchema } from '../schema.js';
 import { OllamaMessageSerializer } from './serializer.js';
 export class ChatOllama {
     model;
     provider = 'ollama';
     client;
-    constructor(model = 'qwen2.5:latest', host = 'http://localhost:11434') {
+    ollamaOptions;
+    constructor(modelOrOptions = 'qwen2.5:latest', host = 'http://localhost:11434') {
+        const normalizedOptions = typeof modelOrOptions === 'string'
+            ? { model: modelOrOptions, host }
+            : modelOrOptions;
+        const { model = 'qwen2.5:latest', host: ollamaHost = 'http://localhost:11434', timeout = null, clientParams = null, ollamaOptions = null, } = normalizedOptions;
         this.model = model;
-        this.client = new Ollama({ host });
+        this.ollamaOptions = ollamaOptions;
+        const baseFetch = clientParams?.fetch;
+        let fetchWithTimeout = baseFetch;
+        if (timeout !== null && timeout !== undefined) {
+            const timeoutMs = Number(timeout);
+            if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
+                fetchWithTimeout = this.createTimeoutFetch(baseFetch, timeoutMs);
+            }
+        }
+        this.client = new Ollama({
+            host: ollamaHost,
+            ...(clientParams ?? {}),
+            ...(fetchWithTimeout ? { fetch: fetchWithTimeout } : {}),
+        });
     }
     get name() {
         return this.model;
@@ -15,18 +35,79 @@ export class ChatOllama {
     get model_name() {
         return this.model;
     }
+    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;
+    }
+    parseOutput(output_format, payload) {
+        const output = output_format;
+        if (output &&
+            typeof output === 'object' &&
+            output.schema &&
+            typeof output.schema.parse === 'function') {
+            return output.schema.parse(payload);
+        }
+        return output.parse(payload);
+    }
+    createTimeoutFetch(baseFetch, timeoutMs) {
+        return async (input, init) => {
+            const fetchImpl = baseFetch ?? fetch;
+            const timeoutController = new AbortController();
+            const timeoutHandle = setTimeout(() => timeoutController.abort(), timeoutMs);
+            const externalSignal = init?.signal;
+            const onAbort = () => timeoutController.abort();
+            try {
+                if (externalSignal) {
+                    if (externalSignal.aborted) {
+                        timeoutController.abort();
+                    }
+                    else {
+                        externalSignal.addEventListener('abort', onAbort, { once: true });
+                    }
+                }
+                return await fetchImpl(input, {
+                    ...init,
+                    signal: timeoutController.signal,
+                });
+            }
+            finally {
+                clearTimeout(timeoutHandle);
+                externalSignal?.removeEventListener('abort', onAbort);
+            }
+        };
+    }
     async ainvoke(messages, output_format, options = {}) {
         const serializer = new OllamaMessageSerializer();
         const ollamaMessages = serializer.serialize(messages);
+        const zodSchemaCandidate = this.getZodSchemaCandidate(output_format);
         let format = undefined;
-        if (output_format && 'schema' in output_format && output_format.schema) {
-            // Ollama supports 'json' format
+        if (zodSchemaCandidate) {
+            format = zodSchemaToJsonSchema(zodSchemaCandidate, {
+                name: 'Response',
+                target: 'jsonSchema7',
+            });
+        }
+        else if (output_format) {
             format = 'json';
         }
         const requestPromise = this.client.chat({
             model: this.model,
             messages: ollamaMessages,
             format: format,
+            options: this.ollamaOptions ?? undefined,
             stream: false,
         });
         const abortSignal = options.signal;
@@ -57,21 +138,31 @@ export class ChatOllama {
                 });
             })
             : await requestPromise;
-        const content = response.message.content;
-        let completion = content;
-        if (output_format) {
-            try {
-                completion = output_format.parse(JSON.parse(content));
-            }
-            catch (e) {
-                console.error('Failed to parse completion', e);
-                throw e;
+        try {
+            const content = response.message.content;
+            let completion = content;
+            if (output_format) {
+                if (zodSchemaCandidate) {
+                    completion = this.parseOutput(output_format, JSON.parse(content));
+                }
+                else {
+                    try {
+                        completion = this.parseOutput(output_format, JSON.parse(content));
+                    }
+                    catch {
+                        completion = this.parseOutput(output_format, content);
+                    }
+                }
             }
+            const stopReason = response.done_reason ?? null;
+            return new ChatInvokeCompletion(completion, {
+                prompt_tokens: response.prompt_eval_count ?? 0,
+                completion_tokens: response.eval_count ?? 0,
+                total_tokens: (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0),
+            }, null, null, stopReason);
+        }
+        catch (error) {
+            throw new ModelProviderError(error?.message ?? String(error), error?.status ?? 502, this.model);
         }
-        return new ChatInvokeCompletion(completion, {
-            prompt_tokens: response.prompt_eval_count ?? 0,
-            completion_tokens: response.eval_count ?? 0,
-            total_tokens: (response.prompt_eval_count ?? 0) + (response.eval_count ?? 0),
-        });
     }
 }

package/dist/llm/ollama/serializer.d.ts

@@ -2,5 +2,6 @@ import type { Message as OllamaMessage } from 'ollama';
 import { type Message } from '../messages.js';
 export declare class OllamaMessageSerializer {
     serialize(messages: Message[]): OllamaMessage[];
+    private extractTextContent;
     private serializeMessage;
 }

package/dist/llm/ollama/serializer.js

@@ -1,18 +1,36 @@
-import { AssistantMessage, ContentPartImageParam, ContentPartTextParam, SystemMessage, UserMessage, } from '../messages.js';
+import { AssistantMessage, ContentPartImageParam, ContentPartRefusalParam, ContentPartTextParam, SystemMessage, UserMessage, } from '../messages.js';
 export class OllamaMessageSerializer {
     serialize(messages) {
         return messages.map((message) => this.serializeMessage(message));
     }
+    extractTextContent(content) {
+        if (content === null || content === undefined) {
+            return '';
+        }
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (!Array.isArray(content)) {
+            return '';
+        }
+        const parts = [];
+        for (const part of content) {
+            if (part instanceof ContentPartTextParam) {
+                parts.push(part.text);
+            }
+            else if (part instanceof ContentPartRefusalParam) {
+                parts.push(`[Refusal] ${part.refusal}`);
+            }
+        }
+        return parts.join('\n');
+    }
     serializeMessage(message) {
         if (message instanceof UserMessage) {
             const images = [];
-            let content = '';
+            const content = this.extractTextContent(message.content);
             if (Array.isArray(message.content)) {
                 message.content.forEach((part) => {
-                    if (part instanceof ContentPartTextParam) {
-                        content += part.text;
-                    }
-                    else if (part instanceof ContentPartImageParam) {
+                    if (part instanceof ContentPartImageParam) {
                         // Ollama expects base64 string without header
                         const data = part.image_url.url.split(',')[1];
                         if (data)
@@ -20,9 +38,6 @@ export class OllamaMessageSerializer {
                     }
                 });
             }
-            else {
-                content = message.content;
-            }
             return {
                 role: 'user',
                 content: content,
@@ -32,19 +47,26 @@ export class OllamaMessageSerializer {
         if (message instanceof SystemMessage) {
             return {
                 role: 'system',
-                content: message.text,
+                content: this.extractTextContent(message.content),
             };
         }
         if (message instanceof AssistantMessage) {
             const toolCalls = message.tool_calls?.map((toolCall) => ({
                 function: {
                     name: toolCall.functionCall.name,
-                    arguments: JSON.parse(toolCall.functionCall.arguments),
+                    arguments: (() => {
+                        try {
+                            return JSON.parse(toolCall.functionCall.arguments);
+                        }
+                        catch {
+                            return { arguments: toolCall.functionCall.arguments };
+                        }
+                    })(),
                 },
             }));
             return {
                 role: 'assistant',
-                content: message.text,
+                content: this.extractTextContent(message.content),
                 tool_calls: toolCalls,
             };
         }

package/dist/llm/openai/chat.d.ts

@@ -5,15 +5,26 @@ export interface ChatOpenAIOptions {
     model?: string;
     apiKey?: string;
     organization?: string;
+    project?: string;
     baseURL?: string;
+    timeout?: number | null;
     temperature?: number | null;
     frequencyPenalty?: number | null;
     reasoningEffort?: 'low' | 'medium' | 'high';
+    serviceTier?: 'auto' | 'default' | 'flex' | 'priority' | 'scale' | null;
     maxCompletionTokens?: number | null;
     maxRetries?: number;
+    defaultHeaders?: Record<string, string> | null;
+    defaultQuery?: Record<string, string | undefined> | null;
+    fetchImplementation?: typeof fetch;
+    fetchOptions?: RequestInit | null;
     seed?: number | null;
     topP?: number | null;
     addSchemaToSystemPrompt?: boolean;
+    dontForceStructuredOutput?: boolean;
+    removeMinItemsFromSchema?: boolean;
+    removeDefaultsFromSchema?: boolean;
+    reasoningModels?: string[] | null;
 }
 export declare class ChatOpenAI implements BaseChatModel {
     model: string;
@@ -22,10 +33,15 @@ export declare class ChatOpenAI implements BaseChatModel {
     private temperature;
     private frequencyPenalty;
     private reasoningEffort;
+    private serviceTier;
     private maxCompletionTokens;
     private seed;
     private topP;
     private addSchemaToSystemPrompt;
+    private dontForceStructuredOutput;
+    private removeMinItemsFromSchema;
+    private removeDefaultsFromSchema;
+    private reasoningModels;
     constructor(options?: ChatOpenAIOptions);
     get name(): string;
     get model_name(): string;