browser-use 0.2.0 → 0.4.0

package/dist/llm/schema.js

@@ -1,6 +1,25 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+export const zodSchemaToJsonSchema = (schema, options = {}) => {
+    try {
+        const toJSONSchema = z?.toJSONSchema;
+        if (typeof toJSONSchema === 'function') {
+            const converted = toJSONSchema(schema);
+            if (converted && typeof converted === 'object') {
+                return converted;
+            }
+        }
+    }
+    catch {
+        // Fall back to zod-to-json-schema below.
+    }
+    return zodToJsonSchema(schema, options);
+};
 export class SchemaOptimizer {
-    static createOptimizedJsonSchema(schema) {
+    static createOptimizedJsonSchema(schema, options = {}) {
         const defsLookup = schema.$defs ?? {};
+        const removeMinItems = options.removeMinItems ?? false;
+        const removeDefaults = options.removeDefaults ?? false;
         const optimize = (obj, inProperties = false) => {
             if (Array.isArray(obj)) {
                 return obj.map((item) => optimize(item, inProperties));
@@ -9,10 +28,18 @@ export class SchemaOptimizer {
                 let flattenedRef = null;
                 const optimized = {};
                 for (const [key, value] of Object.entries(obj)) {
-                    if (key === '$defs' || key === 'additionalProperties')
+                    if (key === '$defs')
+                        continue;
+                    // Some OpenAI-compatible providers reject this JSON Schema keyword.
+                    if (key === 'propertyNames')
                         continue;
                     if (key === 'title' && !inProperties)
                         continue;
+                    if (removeMinItems && (key === 'minItems' || key === 'min_items')) {
+                        continue;
+                    }
+                    if (removeDefaults && key === 'default')
+                        continue;
                     if (key === '$ref' && typeof value === 'string') {
                         const refName = value.split('/').pop();
                         if (defsLookup[refName]) {
@@ -20,6 +47,19 @@ export class SchemaOptimizer {
                         }
                         continue;
                     }
+                    if (key === 'additionalProperties') {
+                        if (value && typeof value === 'object' && !Array.isArray(value)) {
+                            const optimizedAdditional = optimize(value, inProperties);
+                            optimized[key] =
+                                Object.keys(optimizedAdditional).length === 0
+                                    ? true
+                                    : optimizedAdditional;
+                        }
+                        else {
+                            optimized[key] = value;
+                        }
+                        continue;
+                    }
                     if (key === 'properties') {
                         optimized[key] = optimize(value, true);
                         continue;
@@ -33,8 +73,12 @@ export class SchemaOptimizer {
                 const result = flattenedRef
                     ? { ...flattenedRef, ...optimized }
                     : optimized;
+                const hasExplicitProperties = result.properties &&
+                    typeof result.properties === 'object' &&
+                    !Array.isArray(result.properties);
                 if (result.type === 'object' &&
-                    result.additionalProperties === undefined) {
+                    result.additionalProperties === undefined &&
+                    hasExplicitProperties) {
                     result.additionalProperties = false;
                 }
                 return result;
@@ -48,16 +92,77 @@ export class SchemaOptimizer {
                 return;
             }
             if (obj && typeof obj === 'object') {
-                if (obj.type === 'object' && obj.additionalProperties === undefined) {
+                const hasExplicitProperties = obj.properties &&
+                    typeof obj.properties === 'object' &&
+                    !Array.isArray(obj.properties);
+                if (obj.type === 'object' &&
+                    obj.additionalProperties === undefined &&
+                    hasExplicitProperties) {
                     obj.additionalProperties = false;
                 }
                 Object.values(obj).forEach(ensureAdditionalProperties);
             }
         };
+        const stripStructuredDoneSuccess = (obj) => {
+            if (Array.isArray(obj)) {
+                obj.forEach(stripStructuredDoneSuccess);
+                return;
+            }
+            if (!obj || typeof obj !== 'object') {
+                return;
+            }
+            const properties = obj.properties;
+            if (obj.type === 'object' &&
+                properties &&
+                typeof properties === 'object' &&
+                !Array.isArray(properties)) {
+                const dataSchema = properties.data;
+                const successSchema = properties.success;
+                const looksLikeStructuredDone = dataSchema &&
+                    successSchema &&
+                    successSchema.type === 'boolean' &&
+                    successSchema.description ===
+                        'True if user_request completed successfully';
+                if (looksLikeStructuredDone) {
+                    delete properties.success;
+                    if (Array.isArray(obj.required)) {
+                        obj.required = obj.required.filter((name) => name !== 'success');
+                    }
+                }
+            }
+            Object.values(obj).forEach(stripStructuredDoneSuccess);
+        };
+        const stripExtractOutputSchema = (obj, parentKey = null) => {
+            if (Array.isArray(obj)) {
+                obj.forEach((item) => stripExtractOutputSchema(item, parentKey));
+                return;
+            }
+            if (!obj || typeof obj !== 'object') {
+                return;
+            }
+            const isExtractActionSchema = parentKey === 'extract_structured_data' || parentKey === 'extract';
+            if (isExtractActionSchema && obj.type === 'object') {
+                const props = obj.properties;
+                if (props && typeof props === 'object' && !Array.isArray(props)) {
+                    delete props.output_schema;
+                }
+                if (Array.isArray(obj.required)) {
+                    obj.required = obj.required.filter((name) => name !== 'output_schema');
+                }
+            }
+            for (const [key, value] of Object.entries(obj)) {
+                stripExtractOutputSchema(value, key);
+            }
+        };
         ensureAdditionalProperties(optimizedSchema);
+        stripStructuredDoneSuccess(optimizedSchema);
+        stripExtractOutputSchema(optimizedSchema);
         SchemaOptimizer.makeStrictCompatible(optimizedSchema);
         return optimizedSchema;
     }
+    static createGeminiOptimizedSchema(schema) {
+        return SchemaOptimizer.createOptimizedJsonSchema(schema);
+    }
     static makeStrictCompatible(schema) {
         if (Array.isArray(schema)) {
             schema.forEach(SchemaOptimizer.makeStrictCompatible);

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

@@ -0,0 +1,50 @@
+import type { BaseChatModel, ChatInvokeOptions } from '../base.js';
+import type { Message } from '../messages.js';
+import { ChatInvokeCompletion } from '../views.js';
+export interface ChatVercelOptions {
+    model?: string;
+    apiKey?: string;
+    baseURL?: string;
+    timeout?: number | null;
+    temperature?: number | null;
+    maxTokens?: number | null;
+    topP?: number | null;
+    seed?: number | null;
+    maxRetries?: number;
+    defaultHeaders?: Record<string, string> | null;
+    defaultQuery?: Record<string, string | undefined> | null;
+    fetchImplementation?: typeof fetch;
+    fetchOptions?: RequestInit | null;
+    reasoningModels?: string[] | null;
+    providerOptions?: Record<string, unknown> | null;
+    extraBody?: Record<string, unknown> | null;
+    removeMinItemsFromSchema?: boolean;
+    removeDefaultsFromSchema?: boolean;
+}
+export declare class ChatVercel implements BaseChatModel {
+    model: string;
+    provider: string;
+    private client;
+    private temperature;
+    private maxTokens;
+    private topP;
+    private seed;
+    private reasoningModels;
+    private providerOptions;
+    private extraBody;
+    private removeMinItemsFromSchema;
+    private removeDefaultsFromSchema;
+    constructor(options?: string | ChatVercelOptions);
+    get name(): string;
+    get model_name(): string;
+    private getUsage;
+    private getExtraBodyPayload;
+    private cloneMessages;
+    private appendJsonInstructionToMessages;
+    private parseStructuredJson;
+    private parseOutput;
+    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/vercel/chat.js

@@ -0,0 +1,276 @@
+import OpenAI from 'openai';
+import { ModelProviderError, ModelRateLimitError } from '../exceptions.js';
+import { SchemaOptimizer, zodSchemaToJsonSchema } from '../schema.js';
+import { ChatInvokeCompletion } from '../views.js';
+import { VercelMessageSerializer } from './serializer.js';
+const DEFAULT_REASONING_MODELS = [
+    'o1',
+    'o3',
+    'o4',
+    'gpt-oss',
+    'deepseek-r1',
+    'qwen3-next-80b-a3b-thinking',
+];
+export class ChatVercel {
+    model;
+    provider = 'vercel';
+    client;
+    temperature;
+    maxTokens;
+    topP;
+    seed;
+    reasoningModels;
+    providerOptions;
+    extraBody;
+    removeMinItemsFromSchema;
+    removeDefaultsFromSchema;
+    constructor(options = {}) {
+        const normalizedOptions = typeof options === 'string' ? { model: options } : options;
+        const { model = 'openai/gpt-4o', apiKey = process.env.VERCEL_API_KEY, baseURL = process.env.VERCEL_BASE_URL ||
+            'https://ai-gateway.vercel.sh/v1', timeout = null, temperature = null, maxTokens = null, topP = null, seed = null, maxRetries = 5, defaultHeaders = null, defaultQuery = null, fetchImplementation, fetchOptions = null, reasoningModels = [...DEFAULT_REASONING_MODELS], providerOptions = null, extraBody = null, removeMinItemsFromSchema = false, removeDefaultsFromSchema = false, } = normalizedOptions;
+        this.model = model;
+        this.temperature = temperature;
+        this.maxTokens = maxTokens;
+        this.topP = topP;
+        this.seed = seed;
+        this.reasoningModels = reasoningModels ? [...reasoningModels] : null;
+        this.providerOptions = providerOptions;
+        this.extraBody = extraBody;
+        this.removeMinItemsFromSchema = removeMinItemsFromSchema;
+        this.removeDefaultsFromSchema = removeDefaultsFromSchema;
+        this.client = new OpenAI({
+            apiKey,
+            baseURL,
+            timeout: timeout ?? undefined,
+            maxRetries,
+            defaultHeaders: defaultHeaders ?? undefined,
+            defaultQuery: defaultQuery ?? undefined,
+            fetch: fetchImplementation,
+            fetchOptions: (fetchOptions ?? undefined),
+        });
+    }
+    get name() {
+        return this.model;
+    }
+    get model_name() {
+        return this.model;
+    }
+    getUsage(response) {
+        if (!response.usage) {
+            return null;
+        }
+        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: response.usage.completion_tokens,
+            total_tokens: response.usage.total_tokens,
+        };
+    }
+    getExtraBodyPayload() {
+        const payload = {
+            ...(this.extraBody ?? {}),
+        };
+        if (this.providerOptions) {
+            payload.providerOptions = this.providerOptions;
+        }
+        return Object.keys(payload).length > 0 ? payload : undefined;
+    }
+    cloneMessages(messages) {
+        return messages.map((message) => ({
+            ...message,
+            content: Array.isArray(message?.content)
+                ? message.content.map((part) => ({ ...part }))
+                : message?.content,
+        }));
+    }
+    appendJsonInstructionToMessages(messages, schema) {
+        const cloned = this.cloneMessages(messages);
+        const instruction = '\n\nIMPORTANT: You must respond with ONLY a valid JSON object ' +
+            '(no markdown, no code blocks, no explanations) that exactly matches this schema:\n' +
+            `${JSON.stringify(schema, null, 2)}`;
+        if (cloned.length > 0 && cloned[0]?.role === 'system') {
+            if (typeof cloned[0].content === 'string') {
+                cloned[0].content = `${cloned[0].content}${instruction}`;
+            }
+            else if (Array.isArray(cloned[0].content)) {
+                cloned[0].content = [
+                    ...cloned[0].content,
+                    { type: 'text', text: instruction },
+                ];
+            }
+            else {
+                cloned[0].content = instruction;
+            }
+            return cloned;
+        }
+        for (let i = cloned.length - 1; i >= 0; i -= 1) {
+            if (cloned[i]?.role === 'user') {
+                if (typeof cloned[i].content === 'string') {
+                    cloned[i].content = `${cloned[i].content}${instruction}`;
+                }
+                else if (Array.isArray(cloned[i].content)) {
+                    cloned[i].content = [
+                        ...cloned[i].content,
+                        { type: 'text', text: instruction },
+                    ];
+                }
+                else {
+                    cloned[i].content = instruction;
+                }
+                return cloned;
+            }
+        }
+        cloned.unshift({
+            role: 'system',
+            content: instruction,
+        });
+        return cloned;
+    }
+    parseStructuredJson(text) {
+        let jsonText = String(text ?? '').trim();
+        if (jsonText.startsWith('```json') && jsonText.endsWith('```')) {
+            jsonText = jsonText.slice(7, -3).trim();
+        }
+        else if (jsonText.startsWith('```') && jsonText.endsWith('```')) {
+            jsonText = jsonText.slice(3, -3).trim();
+        }
+        return JSON.parse(jsonText);
+    }
+    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);
+    }
+    async ainvoke(messages, output_format, options = {}) {
+        const serializer = new VercelMessageSerializer();
+        const vercelMessages = serializer.serialize(messages);
+        const modelParams = {};
+        if (this.temperature !== null) {
+            modelParams.temperature = this.temperature;
+        }
+        if (this.maxTokens !== null) {
+            modelParams.max_tokens = this.maxTokens;
+        }
+        if (this.topP !== null) {
+            modelParams.top_p = this.topP;
+        }
+        if (this.seed !== null) {
+            modelParams.seed = this.seed;
+        }
+        const zodSchemaCandidate = (() => {
+            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;
+        })();
+        const extraBodyPayload = this.getExtraBodyPayload();
+        const isGoogleModel = this.model.startsWith('google/');
+        const isAnthropicModel = this.model.startsWith('anthropic/');
+        const isReasoningModel = (this.reasoningModels ?? []).some((pattern) => String(this.model).toLowerCase().includes(String(pattern).toLowerCase()));
+        if (output_format &&
+            zodSchemaCandidate &&
+            (isGoogleModel || isAnthropicModel || isReasoningModel)) {
+            try {
+                const rawJsonSchema = zodSchemaToJsonSchema(zodSchemaCandidate, {
+                    name: 'agent_output',
+                    target: 'jsonSchema7',
+                });
+                const optimizedJsonSchema = SchemaOptimizer.createGeminiOptimizedSchema(rawJsonSchema);
+                const requestMessages = this.appendJsonInstructionToMessages(vercelMessages, optimizedJsonSchema);
+                const request = {
+                    model: this.model,
+                    messages: requestMessages,
+                    ...modelParams,
+                };
+                if (extraBodyPayload) {
+                    request.extra_body = extraBodyPayload;
+                }
+                const response = await this.client.chat.completions.create(request, options.signal ? { signal: options.signal } : undefined);
+                const content = response.choices[0].message.content || '';
+                const usage = this.getUsage(response);
+                const stopReason = response.choices[0].finish_reason ?? null;
+                const completion = this.parseOutput(output_format, this.parseStructuredJson(content));
+                return new ChatInvokeCompletion(completion, usage, null, null, stopReason);
+            }
+            catch (error) {
+                throw new ModelProviderError(`Failed to parse JSON response: ${error?.message ?? String(error)}`, 500, this.model);
+            }
+        }
+        let responseFormat = undefined;
+        if (zodSchemaCandidate) {
+            try {
+                const rawJsonSchema = zodSchemaToJsonSchema(zodSchemaCandidate, {
+                    name: 'agent_output',
+                    target: 'jsonSchema7',
+                });
+                const optimizedJsonSchema = SchemaOptimizer.createOptimizedJsonSchema(rawJsonSchema, {
+                    removeMinItems: this.removeMinItemsFromSchema,
+                    removeDefaults: this.removeDefaultsFromSchema,
+                });
+                responseFormat = {
+                    type: 'json_schema',
+                    json_schema: {
+                        name: 'agent_output',
+                        schema: optimizedJsonSchema,
+                        strict: true,
+                    },
+                };
+            }
+            catch {
+                responseFormat = undefined;
+            }
+        }
+        const request = {
+            model: this.model,
+            messages: vercelMessages,
+            response_format: responseFormat,
+            ...modelParams,
+        };
+        if (extraBodyPayload) {
+            request.extra_body = extraBodyPayload;
+        }
+        try {
+            const response = await this.client.chat.completions.create(request, options.signal ? { signal: options.signal } : undefined);
+            const content = response.choices[0].message.content || '';
+            const usage = this.getUsage(response);
+            const stopReason = response.choices[0].finish_reason ?? null;
+            let completion = content;
+            if (output_format) {
+                if (zodSchemaCandidate) {
+                    completion = this.parseOutput(output_format, JSON.parse(content));
+                }
+                else {
+                    completion = this.parseOutput(output_format, content);
+                }
+            }
+            return new ChatInvokeCompletion(completion, usage, null, null, stopReason);
+        }
+        catch (error) {
+            if (error?.status === 429) {
+                throw new ModelRateLimitError(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/vercel/index.d.ts

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

package/dist/llm/vercel/index.js

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

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

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

package/dist/llm/vercel/serializer.js

@@ -0,0 +1,7 @@
+import { OpenAIMessageSerializer } from '../openai/serializer.js';
+export class VercelMessageSerializer {
+    serialize(messages) {
+        const serializer = new OpenAIMessageSerializer();
+        return serializer.serialize(messages);
+    }
+}

package/dist/llm/views.d.ts

@@ -11,5 +11,6 @@ export declare class ChatInvokeCompletion<T = string> {
     usage: ChatInvokeUsage | null;
     thinking: string | null;
     redacted_thinking: string | null;
-    constructor(completion: T, usage?: ChatInvokeUsage | null, thinking?: string | null, redacted_thinking?: string | null);
+    stop_reason: string | null;
+    constructor(completion: T, usage?: ChatInvokeUsage | null, thinking?: string | null, redacted_thinking?: string | null, stop_reason?: string | null);
 }

package/dist/llm/views.js

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

package/dist/logging-config.d.ts

@@ -4,6 +4,8 @@ interface SetupLoggingOptions {
     stream?: Writable;
     logLevel?: LogLevel;
     forceSetup?: boolean;
+    debugLogFile?: string | null;
+    infoLogFile?: string | null;
 }
 export declare class Logger {
     private readonly name;