browser-use 0.0.1 → 0.1.0

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

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

package/dist/llm/ollama/serializer.js

@@ -0,0 +1,53 @@
+import { AssistantMessage, ContentPartImageParam, ContentPartTextParam, SystemMessage, UserMessage, } from '../messages.js';
+export class OllamaMessageSerializer {
+    serialize(messages) {
+        return messages.map((message) => this.serializeMessage(message));
+    }
+    serializeMessage(message) {
+        if (message instanceof UserMessage) {
+            const images = [];
+            let content = '';
+            if (Array.isArray(message.content)) {
+                message.content.forEach((part) => {
+                    if (part instanceof ContentPartTextParam) {
+                        content += part.text;
+                    }
+                    else if (part instanceof ContentPartImageParam) {
+                        // Ollama expects base64 string without header
+                        const data = part.image_url.url.split(',')[1];
+                        if (data)
+                            images.push(data);
+                    }
+                });
+            }
+            else {
+                content = message.content;
+            }
+            return {
+                role: 'user',
+                content: content,
+                images: images.length > 0 ? images : undefined,
+            };
+        }
+        if (message instanceof SystemMessage) {
+            return {
+                role: 'system',
+                content: message.text,
+            };
+        }
+        if (message instanceof AssistantMessage) {
+            const toolCalls = message.tool_calls?.map((toolCall) => ({
+                function: {
+                    name: toolCall.functionCall.name,
+                    arguments: JSON.parse(toolCall.functionCall.arguments),
+                },
+            }));
+            return {
+                role: 'assistant',
+                content: message.text,
+                tool_calls: toolCalls,
+            };
+        }
+        throw new Error(`Unknown message type: ${message.constructor.name}`);
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { BaseChatModel, ChatInvokeOptions } from '../base.js';
+import { ChatInvokeCompletion } from '../views.js';
+import type { Message } from '../messages.js';
+export interface ChatOpenAIOptions {
+    model?: string;
+    apiKey?: string;
+    organization?: string;
+    baseURL?: string;
+    temperature?: number | null;
+    frequencyPenalty?: number | null;
+    reasoningEffort?: 'low' | 'medium' | 'high';
+    maxCompletionTokens?: number | null;
+    maxRetries?: number;
+    seed?: number | null;
+    topP?: number | null;
+    addSchemaToSystemPrompt?: boolean;
+}
+export declare class ChatOpenAI implements BaseChatModel {
+    model: string;
+    provider: string;
+    private client;
+    private temperature;
+    private frequencyPenalty;
+    private reasoningEffort;
+    private maxCompletionTokens;
+    private seed;
+    private topP;
+    private addSchemaToSystemPrompt;
+    constructor(options?: ChatOpenAIOptions);
+    get name(): string;
+    get model_name(): string;
+    private isReasoningModel;
+    private getUsage;
+    ainvoke(messages: Message[], output_format?: undefined, options?: ChatInvokeOptions): Promise<ChatInvokeCompletion<string>>;
+    ainvoke<T>(messages: Message[], output_format: {
+        parse: (input: string) => T;
+    } | undefined, options?: ChatInvokeOptions): Promise<ChatInvokeCompletion<T>>;
+}

package/dist/llm/openai/chat.js

@@ -0,0 +1,174 @@
+import OpenAI from 'openai';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { ChatInvokeCompletion } from '../views.js';
+import { OpenAIMessageSerializer } from './serializer.js';
+import { ModelProviderError } from '../exceptions.js';
+// Reasoning models that support reasoning_effort parameter
+const ReasoningModels = [
+    'o4-mini',
+    'o3',
+    'o3-mini',
+    'o1',
+    'o1-pro',
+    'o3-pro',
+    'gpt-5',
+    'gpt-5-mini',
+    'gpt-5-nano',
+];
+export class ChatOpenAI {
+    model;
+    provider = 'openai';
+    client;
+    temperature;
+    frequencyPenalty;
+    reasoningEffort;
+    maxCompletionTokens;
+    seed;
+    topP;
+    addSchemaToSystemPrompt;
+    constructor(options = {}) {
+        const { model = 'gpt-4o', apiKey, organization, baseURL, temperature = 0.2, frequencyPenalty = 0.1, reasoningEffort = 'low', maxCompletionTokens = 8000, maxRetries = 10, seed = null, topP = null, addSchemaToSystemPrompt = false, } = options;
+        this.model = model;
+        this.temperature = temperature;
+        this.frequencyPenalty = frequencyPenalty;
+        this.reasoningEffort = reasoningEffort;
+        this.maxCompletionTokens = maxCompletionTokens;
+        this.seed = seed;
+        this.topP = topP;
+        this.addSchemaToSystemPrompt = addSchemaToSystemPrompt;
+        this.client = new OpenAI({
+            apiKey,
+            organization,
+            baseURL,
+            maxRetries,
+        });
+    }
+    get name() {
+        return this.model;
+    }
+    get model_name() {
+        return this.model;
+    }
+    isReasoningModel() {
+        return ReasoningModels.some((m) => this.model.toLowerCase().includes(m.toLowerCase()));
+    }
+    getUsage(response) {
+        if (!response.usage)
+            return null;
+        let completionTokens = response.usage.completion_tokens;
+        const details = response.usage.completion_tokens_details;
+        if (details?.reasoning_tokens) {
+            completionTokens += details.reasoning_tokens;
+        }
+        return {
+            prompt_tokens: response.usage.prompt_tokens,
+            prompt_cached_tokens: response.usage.prompt_tokens_details?.cached_tokens ?? null,
+            prompt_cache_creation_tokens: null,
+            prompt_image_tokens: null,
+            completion_tokens: completionTokens,
+            total_tokens: response.usage.total_tokens,
+        };
+    }
+    async ainvoke(messages, output_format, options = {}) {
+        const serializer = new OpenAIMessageSerializer();
+        const openaiMessages = serializer.serialize(messages);
+        // Build model parameters
+        const modelParams = {};
+        if (!this.isReasoningModel()) {
+            // Regular models support temperature and frequency_penalty
+            if (this.temperature !== null) {
+                modelParams.temperature = this.temperature;
+            }
+            if (this.frequencyPenalty !== null) {
+                modelParams.frequency_penalty = this.frequencyPenalty;
+            }
+        }
+        else {
+            // Reasoning models use reasoning_effort instead
+            modelParams.reasoning_effort = this.reasoningEffort;
+        }
+        if (this.maxCompletionTokens !== null) {
+            modelParams.max_completion_tokens = this.maxCompletionTokens;
+        }
+        if (this.seed !== null) {
+            modelParams.seed = this.seed;
+        }
+        if (this.topP !== null) {
+            modelParams.top_p = this.topP;
+        }
+        let responseFormat = undefined;
+        if (output_format && 'schema' in output_format && output_format.schema) {
+            // Assuming output_format is a Zod schema wrapper or similar that has a schema property
+            // But the interface says { parse: ... }
+            // In the plan, it was passed as a Zod schema directly.
+            // However, the BaseChatModel interface I saw earlier has:
+            // ainvoke<T>(messages: Message[], output_format: { parse: (input: string) => T } | undefined): Promise<ChatInvokeCompletion<T>>;
+            // So I need to handle how to extract the schema if I want to use structured outputs.
+            // If output_format is just a Zod schema, it has a parse method.
+            // Let's assume it's a Zod schema for now, as that's what the plan implies.
+            // We need to cast it to any or check if it's a Zod schema to get the schema for JSON schema generation.
+            // For now, I'll try to use zodToJsonSchema on it if possible.
+            try {
+                const jsonSchema = zodToJsonSchema(output_format, {
+                    name: 'Response',
+                    target: 'jsonSchema7',
+                });
+                // OpenAI expects a specific format for json_schema
+                responseFormat = {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'Response',
+                        schema: jsonSchema,
+                        strict: true,
+                    },
+                };
+            }
+            catch (e) {
+                // If it's not a Zod schema or fails, we might fallback or just not use response_format
+                console.warn('Failed to convert output_format to JSON schema', e);
+            }
+        }
+        try {
+            const response = await this.client.chat.completions.create({
+                model: this.model,
+                messages: openaiMessages,
+                response_format: responseFormat,
+                ...modelParams,
+            }, options.signal ? { signal: options.signal } : undefined);
+            const content = response.choices[0].message.content || '';
+            const usage = this.getUsage(response);
+            let completion = content;
+            if (output_format) {
+                try {
+                    // If it's structured output, we need to parse the JSON first
+                    if (responseFormat?.type === 'json_schema') {
+                        const parsedJson = JSON.parse(content);
+                        completion = output_format.parse(parsedJson);
+                    }
+                    else {
+                        // If it's not structured output but we have a parser (e.g. for simple types or manual parsing)
+                        // But usually for OpenAI we want structured output if a schema is provided.
+                        // If we didn't use json_schema, we might still try to parse if it looks like JSON?
+                        // For now, let's trust the output_format.parse
+                        completion = output_format.parse(content);
+                    }
+                }
+                catch (e) {
+                    console.error('Failed to parse completion', e);
+                    throw e;
+                }
+            }
+            return new ChatInvokeCompletion(completion, usage);
+        }
+        catch (error) {
+            // Handle OpenAI-specific errors
+            if (error?.status === 429) {
+                throw new ModelProviderError(error?.message ?? 'Rate limit exceeded', 429, this.model);
+            }
+            if (error?.status >= 500) {
+                throw new ModelProviderError(error?.message ?? 'Server error', error.status, this.model);
+            }
+            throw new ModelProviderError(error?.message ?? String(error), error?.status ?? 500, this.model);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './chat.js';
+export * from './serializer.js';
+export * from './like.js';

package/dist/llm/openai/index.js

@@ -0,0 +1,3 @@
+export * from './chat.js';
+export * from './serializer.js';
+export * from './like.js';

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

@@ -0,0 +1,17 @@
+import { ChatOpenAI } from './chat.js';
+/**
+ * A class to interact with any provider using the OpenAI API schema.
+ *
+ * This allows using any OpenAI-compatible API provider by specifying a custom model name.
+ *
+ * @example
+ * ```typescript
+ * const llm = new ChatOpenAILike('custom-model-name');
+ * ```
+ */
+export declare class ChatOpenAILike extends ChatOpenAI {
+    /**
+     * @param model - The name of the model to use (any OpenAI-compatible model)
+     */
+    constructor(model: string);
+}

package/dist/llm/openai/like.js

@@ -0,0 +1,19 @@
+import { ChatOpenAI } from './chat.js';
+/**
+ * A class to interact with any provider using the OpenAI API schema.
+ *
+ * This allows using any OpenAI-compatible API provider by specifying a custom model name.
+ *
+ * @example
+ * ```typescript
+ * const llm = new ChatOpenAILike('custom-model-name');
+ * ```
+ */
+export class ChatOpenAILike extends ChatOpenAI {
+    /**
+     * @param model - The name of the model to use (any OpenAI-compatible model)
+     */
+    constructor(model) {
+        super({ model });
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { ChatCompletionMessageParam } from 'openai/resources/index.mjs';
+import { type Message } from '../messages.js';
+export declare class OpenAIMessageSerializer {
+    serialize(messages: Message[]): ChatCompletionMessageParam[];
+    private serializeMessage;
+}

package/dist/llm/openai/serializer.js

@@ -0,0 +1,57 @@
+import { AssistantMessage, ContentPartImageParam, ContentPartTextParam, SystemMessage, UserMessage, } from '../messages.js';
+export class OpenAIMessageSerializer {
+    serialize(messages) {
+        return messages.map((message) => this.serializeMessage(message));
+    }
+    serializeMessage(message) {
+        if (message instanceof UserMessage) {
+            return {
+                role: 'user',
+                content: Array.isArray(message.content)
+                    ? message.content.map((part) => {
+                        if (part instanceof ContentPartTextParam) {
+                            return { type: 'text', text: part.text };
+                        }
+                        if (part instanceof ContentPartImageParam) {
+                            return {
+                                type: 'image_url',
+                                image_url: {
+                                    url: part.image_url.url,
+                                    detail: part.image_url.detail,
+                                },
+                            };
+                        }
+                        return { type: 'text', text: '' }; // Fallback
+                    })
+                    : message.content,
+                name: message.name || undefined,
+            };
+        }
+        if (message instanceof SystemMessage) {
+            return {
+                role: 'system',
+                content: Array.isArray(message.content)
+                    ? message.content.map((part) => part.text).join('\n')
+                    : message.content,
+                name: message.name || undefined,
+            };
+        }
+        if (message instanceof AssistantMessage) {
+            const toolCalls = message.tool_calls?.map((toolCall) => ({
+                id: toolCall.id,
+                type: 'function',
+                function: {
+                    name: toolCall.functionCall.name,
+                    arguments: toolCall.functionCall.arguments,
+                },
+            }));
+            return {
+                role: 'assistant',
+                content: typeof message.content === 'string' ? message.content : null, // OpenAI expects string or null for content in assistant message if tool_calls are present
+                tool_calls: toolCalls,
+                refusal: message.refusal || undefined,
+            };
+        }
+        throw new Error(`Unknown message type: ${message.constructor.name}`);
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { BaseChatModel, ChatInvokeOptions } from '../base.js';
+import { ChatInvokeCompletion } from '../views.js';
+import type { Message } from '../messages.js';
+export declare class ChatOpenRouter implements BaseChatModel {
+    model: string;
+    provider: string;
+    private client;
+    constructor(model?: string);
+    get name(): string;
+    get model_name(): string;
+    ainvoke(messages: Message[], output_format?: undefined, options?: ChatInvokeOptions): Promise<ChatInvokeCompletion<string>>;
+    ainvoke<T>(messages: Message[], output_format: {
+        parse: (input: string) => T;
+    } | undefined, options?: ChatInvokeOptions): Promise<ChatInvokeCompletion<T>>;
+}

package/dist/llm/openrouter/chat.js

@@ -0,0 +1,74 @@
+import OpenAI from 'openai';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { ChatInvokeCompletion } from '../views.js';
+import { OpenRouterMessageSerializer } from './serializer.js';
+export class ChatOpenRouter {
+    model;
+    provider = 'openrouter';
+    client;
+    constructor(model = 'openai/gpt-4o') {
+        this.model = model;
+        this.client = new OpenAI({
+            apiKey: process.env.OPENROUTER_API_KEY,
+            baseURL: 'https://openrouter.ai/api/v1',
+        });
+    }
+    get name() {
+        return this.model;
+    }
+    get model_name() {
+        return this.model;
+    }
+    async ainvoke(messages, output_format, options = {}) {
+        const serializer = new OpenRouterMessageSerializer();
+        const openRouterMessages = serializer.serialize(messages);
+        let responseFormat = undefined;
+        if (output_format && 'schema' in output_format && output_format.schema) {
+            // OpenRouter supports structured outputs for some models, but it depends on the underlying provider.
+            // We'll try to use json_schema if possible, or json_object.
+            try {
+                const jsonSchema = zodToJsonSchema(output_format, {
+                    name: 'Response',
+                    target: 'jsonSchema7',
+                });
+                responseFormat = {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'Response',
+                        schema: jsonSchema,
+                        strict: true,
+                    },
+                };
+            }
+            catch (e) {
+                console.warn('Failed to convert output_format to JSON schema for OpenRouter', e);
+            }
+        }
+        const response = await this.client.chat.completions.create({
+            model: this.model,
+            messages: openRouterMessages,
+            response_format: responseFormat,
+        }, options.signal ? { signal: options.signal } : undefined);
+        const content = response.choices[0].message.content || '';
+        let completion = content;
+        if (output_format) {
+            try {
+                if (responseFormat?.type === 'json_schema') {
+                    completion = output_format.parse(JSON.parse(content));
+                }
+                else {
+                    completion = output_format.parse(content);
+                }
+            }
+            catch (e) {
+                console.error('Failed to parse completion', e);
+                throw e;
+            }
+        }
+        return new ChatInvokeCompletion(completion, {
+            prompt_tokens: response.usage?.prompt_tokens ?? 0,
+            completion_tokens: response.usage?.completion_tokens ?? 0,
+            total_tokens: response.usage?.total_tokens ?? 0,
+        });
+    }
+}

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

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

package/dist/llm/openrouter/index.js

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

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

@@ -0,0 +1,3 @@
+import { OpenAIMessageSerializer } from '../openai/serializer.js';
+export declare class OpenRouterMessageSerializer extends OpenAIMessageSerializer {
+}

package/dist/llm/openrouter/serializer.js

@@ -0,0 +1,3 @@
+import { OpenAIMessageSerializer } from '../openai/serializer.js';
+export class OpenRouterMessageSerializer extends OpenAIMessageSerializer {
+}

package/dist/llm/schema.d.ts

@@ -0,0 +1,6 @@
+type JsonSchema = Record<string, unknown>;
+export declare class SchemaOptimizer {
+    static createOptimizedJsonSchema(schema: JsonSchema): JsonSchema;
+    static makeStrictCompatible(schema: any): void;
+}
+export {};

package/dist/llm/schema.js

@@ -0,0 +1,77 @@
+export class SchemaOptimizer {
+    static createOptimizedJsonSchema(schema) {
+        const defsLookup = schema.$defs ?? {};
+        const optimize = (obj, inProperties = false) => {
+            if (Array.isArray(obj)) {
+                return obj.map((item) => optimize(item, inProperties));
+            }
+            if (obj && typeof obj === 'object') {
+                let flattenedRef = null;
+                const optimized = {};
+                for (const [key, value] of Object.entries(obj)) {
+                    if (key === '$defs' || key === 'additionalProperties')
+                        continue;
+                    if (key === 'title' && !inProperties)
+                        continue;
+                    if (key === '$ref' && typeof value === 'string') {
+                        const refName = value.split('/').pop();
+                        if (defsLookup[refName]) {
+                            flattenedRef = optimize(defsLookup[refName], inProperties);
+                        }
+                        continue;
+                    }
+                    if (key === 'properties') {
+                        optimized[key] = optimize(value, true);
+                        continue;
+                    }
+                    if (typeof value === 'object' && value !== null) {
+                        optimized[key] = optimize(value, inProperties);
+                        continue;
+                    }
+                    optimized[key] = value;
+                }
+                const result = flattenedRef
+                    ? { ...flattenedRef, ...optimized }
+                    : optimized;
+                if (result.type === 'object' &&
+                    result.additionalProperties === undefined) {
+                    result.additionalProperties = false;
+                }
+                return result;
+            }
+            return obj;
+        };
+        const optimizedSchema = optimize(schema);
+        const ensureAdditionalProperties = (obj) => {
+            if (Array.isArray(obj)) {
+                obj.forEach(ensureAdditionalProperties);
+                return;
+            }
+            if (obj && typeof obj === 'object') {
+                if (obj.type === 'object' && obj.additionalProperties === undefined) {
+                    obj.additionalProperties = false;
+                }
+                Object.values(obj).forEach(ensureAdditionalProperties);
+            }
+        };
+        ensureAdditionalProperties(optimizedSchema);
+        SchemaOptimizer.makeStrictCompatible(optimizedSchema);
+        return optimizedSchema;
+    }
+    static makeStrictCompatible(schema) {
+        if (Array.isArray(schema)) {
+            schema.forEach(SchemaOptimizer.makeStrictCompatible);
+            return;
+        }
+        if (schema && typeof schema === 'object') {
+            for (const [key, value] of Object.entries(schema)) {
+                if (key !== 'required' && value && typeof value === 'object') {
+                    SchemaOptimizer.makeStrictCompatible(value);
+                }
+            }
+            if (schema.type === 'object' && schema.properties) {
+                schema.required = Object.keys(schema.properties);
+            }
+        }
+    }
+}

package/dist/llm/views.d.ts

@@ -0,0 +1,15 @@
+export interface ChatInvokeUsage {
+    prompt_tokens: number;
+    prompt_cached_tokens?: number | null;
+    prompt_cache_creation_tokens?: number | null;
+    prompt_image_tokens?: number | null;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export declare class ChatInvokeCompletion<T = string> {
+    completion: T;
+    usage: ChatInvokeUsage | null;
+    thinking: string | null;
+    redacted_thinking: string | null;
+    constructor(completion: T, usage?: ChatInvokeUsage | null, thinking?: string | null, redacted_thinking?: string | null);
+}

package/dist/llm/views.js

@@ -0,0 +1,12 @@
+export class ChatInvokeCompletion {
+    completion;
+    usage;
+    thinking;
+    redacted_thinking;
+    constructor(completion, usage = null, thinking = null, redacted_thinking = null) {
+        this.completion = completion;
+        this.usage = usage;
+        this.thinking = thinking;
+        this.redacted_thinking = redacted_thinking;
+    }
+}

package/dist/logging-config.d.ts

@@ -0,0 +1,25 @@
+import { Writable } from 'node:stream';
+export type LogLevel = 'debug' | 'info' | 'result' | 'warning' | 'error';
+interface SetupLoggingOptions {
+    stream?: Writable;
+    logLevel?: LogLevel;
+    forceSetup?: boolean;
+}
+export declare class Logger {
+    private readonly name;
+    constructor(name: string);
+    private shouldLog;
+    get level(): LogLevel;
+    private emit;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    result(message: string, ...args: unknown[]): void;
+    warning(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    child(suffix: string): Logger;
+}
+export declare const createLogger: (name: string) => Logger;
+export declare const setupLogging: (options?: SetupLoggingOptions) => Logger;
+export declare const logger: Logger;
+export {};