browser-use 0.2.0 → 0.3.0

package/dist/llm/deepseek/chat.js

@@ -1,15 +1,30 @@
 import OpenAI from 'openai';
+import { ModelProviderError, ModelRateLimitError } from '../exceptions.js';
+import { SchemaOptimizer, zodSchemaToJsonSchema } from '../schema.js';
 import { ChatInvokeCompletion } from '../views.js';
 import { DeepSeekMessageSerializer } from './serializer.js';
 export class ChatDeepSeek {
     model;
     provider = 'deepseek';
     client;
-    constructor(model = 'deepseek-chat') {
+    temperature;
+    maxTokens;
+    topP;
+    seed;
+    constructor(options = {}) {
+        const normalizedOptions = typeof options === 'string' ? { model: options } : options;
+        const { model = 'deepseek-chat', apiKey = process.env.DEEPSEEK_API_KEY, baseURL = 'https://api.deepseek.com/v1', timeout = null, clientParams = null, temperature = null, maxTokens = null, topP = null, seed = null, maxRetries = 10, } = normalizedOptions;
         this.model = model;
+        this.temperature = temperature;
+        this.maxTokens = maxTokens;
+        this.topP = topP;
+        this.seed = seed;
         this.client = new OpenAI({
-            apiKey: process.env.DEEPSEEK_API_KEY,
-            baseURL: 'https://api.deepseek.com',
+            apiKey,
+            baseURL,
+            ...(timeout !== null ? { timeout } : {}),
+            maxRetries,
+            ...(clientParams ?? {}),
         });
     }
     get name() {
@@ -18,34 +33,132 @@ export class ChatDeepSeek {
     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,
+        };
+    }
     async ainvoke(messages, output_format, options = {}) {
         const serializer = new DeepSeekMessageSerializer();
         const deepseekMessages = serializer.serialize(messages);
-        let responseFormat = undefined;
-        if (output_format && 'schema' in output_format && output_format.schema) {
-            // DeepSeek supports json_object
-            responseFormat = { type: 'json_object' };
+        const modelParams = {};
+        if (this.temperature !== null) {
+            modelParams.temperature = this.temperature;
+        }
+        if (this.maxTokens !== null) {
+            modelParams.max_tokens = this.maxTokens;
         }
-        const response = await this.client.chat.completions.create({
-            model: this.model,
-            messages: deepseekMessages,
-            response_format: responseFormat,
-        }, options.signal ? { signal: options.signal } : undefined);
-        const content = response.choices[0].message.content || '';
-        let completion = content;
-        if (output_format) {
-            try {
-                completion = output_format.parse(JSON.parse(content));
+        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;
             }
-            catch (e) {
-                console.error('Failed to parse completion', e);
-                throw e;
+            return null;
+        })();
+        try {
+            if (output_format && zodSchemaCandidate) {
+                const rawSchema = zodSchemaToJsonSchema(zodSchemaCandidate, {
+                    name: 'response',
+                    target: 'jsonSchema7',
+                });
+                const optimizedSchema = SchemaOptimizer.createOptimizedJsonSchema(rawSchema);
+                delete optimizedSchema.title;
+                const response = await this.client.chat.completions.create({
+                    model: this.model,
+                    messages: deepseekMessages,
+                    tools: [
+                        {
+                            type: 'function',
+                            function: {
+                                name: 'response',
+                                description: 'Return a JSON object of type response',
+                                parameters: optimizedSchema,
+                            },
+                        },
+                    ],
+                    tool_choice: {
+                        type: 'function',
+                        function: { name: 'response' },
+                    },
+                    ...modelParams,
+                }, options.signal ? { signal: options.signal } : undefined);
+                const usage = this.getUsage(response);
+                const stopReason = response.choices[0].finish_reason ?? null;
+                const toolCalls = response.choices[0].message.tool_calls;
+                if (!toolCalls?.length) {
+                    throw new ModelProviderError('Expected tool_calls in response but got none', 502, this.model);
+                }
+                const rawArguments = toolCalls[0]?.function?.arguments;
+                const parsedArguments = typeof rawArguments === 'string'
+                    ? JSON.parse(rawArguments)
+                    : rawArguments;
+                const output = output_format;
+                const completion = output &&
+                    typeof output === 'object' &&
+                    output.schema &&
+                    typeof output.schema.parse === 'function'
+                    ? output.schema.parse(parsedArguments)
+                    : output.parse(parsedArguments);
+                return new ChatInvokeCompletion(completion, usage, null, null, stopReason);
             }
+            const responseFormat = output_format ? { type: 'json_object' } : undefined;
+            const response = await this.client.chat.completions.create({
+                model: this.model,
+                messages: deepseekMessages,
+                response_format: responseFormat,
+                ...modelParams,
+            }, 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) {
+                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_format.parse(parsedJson);
+                }
+            }
+            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);
         }
-        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/google/chat.d.ts

@@ -1,18 +1,62 @@
 import type { BaseChatModel, ChatInvokeOptions } from '../base.js';
 import { ChatInvokeCompletion } from '../views.js';
-import { type Message } from '../messages.js';
+import type { Message } from '../messages.js';
+export interface ChatGoogleOptions {
+    model?: string;
+    apiKey?: string;
+    apiVersion?: string;
+    baseUrl?: string;
+    vertexai?: boolean;
+    vertexAi?: boolean;
+    project?: string;
+    location?: string;
+    httpOptions?: Record<string, unknown>;
+    googleAuthOptions?: Record<string, unknown>;
+    credentials?: Record<string, unknown>;
+    temperature?: number | null;
+    topP?: number | null;
+    seed?: number | null;
+    thinkingBudget?: number | null;
+    thinkingLevel?: 'minimal' | 'low' | 'medium' | 'high' | null;
+    maxOutputTokens?: number | null;
+    config?: Record<string, unknown> | null;
+    includeSystemInUser?: boolean;
+    supportsStructuredOutput?: boolean;
+    maxRetries?: number;
+    retryableStatusCodes?: number[];
+    retryBaseDelay?: number;
+    retryMaxDelay?: number;
+}
 export declare class ChatGoogle implements BaseChatModel {
     model: string;
     provider: string;
     private client;
-    constructor(model?: string);
+    private temperature;
+    private topP;
+    private seed;
+    private thinkingBudget;
+    private thinkingLevel;
+    private maxOutputTokens;
+    private config;
+    private includeSystemInUser;
+    private supportsStructuredOutput;
+    private maxRetries;
+    private retryableStatusCodes;
+    private retryBaseDelay;
+    private retryMaxDelay;
+    constructor(options?: string | ChatGoogleOptions);
     get name(): string;
     get model_name(): string;
+    private getUsage;
     /**
      * Clean up JSON schema for Google's format
      * Google API has specific requirements for responseSchema
      */
     private _cleanSchemaForGoogle;
+    private _parseStructuredJson;
+    private _extractStatusCode;
+    private _toModelProviderError;
+    private _sleep;
     ainvoke(messages: Message[], output_format?: undefined, options?: ChatInvokeOptions): Promise<ChatInvokeCompletion<string>>;
     ainvoke<T>(messages: Message[], output_format: {
         parse: (input: string) => T;

package/dist/llm/google/chat.js

@@ -1,21 +1,62 @@
 import { GoogleGenAI } from '@google/genai';
-import { zodToJsonSchema } from 'zod-to-json-schema';
+import { ModelProviderError } from '../exceptions.js';
 import { ChatInvokeCompletion } from '../views.js';
-import { SystemMessage } from '../messages.js';
+import { SchemaOptimizer, zodSchemaToJsonSchema } from '../schema.js';
 import { GoogleMessageSerializer } from './serializer.js';
 export class ChatGoogle {
     model;
     provider = 'google';
     client;
-    constructor(model = 'gemini-2.5-flash') {
+    temperature;
+    topP;
+    seed;
+    thinkingBudget;
+    thinkingLevel;
+    maxOutputTokens;
+    config;
+    includeSystemInUser;
+    supportsStructuredOutput;
+    maxRetries;
+    retryableStatusCodes;
+    retryBaseDelay;
+    retryMaxDelay;
+    constructor(options = {}) {
+        const normalizedOptions = typeof options === 'string' ? { model: options } : options;
+        const { model = 'gemini-2.5-flash', apiKey = process.env.GOOGLE_API_KEY, apiVersion = process.env.GOOGLE_API_VERSION, baseUrl = process.env.GOOGLE_API_BASE_URL, vertexai, vertexAi, project, location, httpOptions, googleAuthOptions, credentials, temperature = 0.5, topP = null, seed = null, thinkingBudget = null, thinkingLevel = null, maxOutputTokens = 8096, config = null, includeSystemInUser = false, supportsStructuredOutput = true, maxRetries = 5, retryableStatusCodes = [429, 500, 502, 503, 504], retryBaseDelay = 1.0, retryMaxDelay = 60.0, } = normalizedOptions;
         this.model = model;
-        const apiVersion = process.env.GOOGLE_API_VERSION || 'v1';
-        const baseUrl = process.env.GOOGLE_API_BASE_URL;
-        this.client = new GoogleGenAI({
-            apiKey: process.env.GOOGLE_API_KEY || '',
+        this.temperature = temperature;
+        this.topP = topP;
+        this.seed = seed;
+        this.thinkingBudget = thinkingBudget;
+        this.thinkingLevel = thinkingLevel;
+        this.maxOutputTokens = maxOutputTokens;
+        this.config = config ? { ...config } : null;
+        this.includeSystemInUser = includeSystemInUser;
+        this.supportsStructuredOutput = supportsStructuredOutput;
+        this.maxRetries = Math.max(1, maxRetries);
+        this.retryableStatusCodes = [...retryableStatusCodes];
+        this.retryBaseDelay = retryBaseDelay;
+        this.retryMaxDelay = retryMaxDelay;
+        const resolvedGoogleAuthOptions = credentials == null
+            ? googleAuthOptions
+            : {
+                ...(googleAuthOptions ?? {}),
+                credentials,
+            };
+        const resolvedVertexAi = vertexai ?? vertexAi;
+        const clientOptions = {
+            ...(apiKey != null ? { apiKey } : {}),
             ...(baseUrl ? { baseUrl } : {}),
             ...(apiVersion ? { apiVersion } : {}),
-        });
+            ...(resolvedVertexAi != null ? { vertexai: resolvedVertexAi } : {}),
+            ...(project ? { project } : {}),
+            ...(location ? { location } : {}),
+            ...(httpOptions ? { httpOptions } : {}),
+            ...(resolvedGoogleAuthOptions
+                ? { googleAuthOptions: resolvedGoogleAuthOptions }
+                : {}),
+        };
+        this.client = new GoogleGenAI(clientOptions);
     }
     get name() {
         return this.model;
@@ -23,6 +64,33 @@ export class ChatGoogle {
     get model_name() {
         return this.model;
     }
+    getUsage(result) {
+        const usage = result?.usageMetadata;
+        if (!usage) {
+            return null;
+        }
+        let imageTokens = 0;
+        const promptTokenDetails = Array.isArray(usage.promptTokensDetails)
+            ? usage.promptTokensDetails
+            : [];
+        for (const detail of promptTokenDetails) {
+            if (String(detail?.modality ?? '').toUpperCase() === 'IMAGE') {
+                imageTokens += Number(detail?.tokenCount ?? 0) || 0;
+            }
+        }
+        const completionTokens = (Number(usage.candidatesTokenCount ?? 0) || 0) +
+            (Number(usage.thoughtsTokenCount ?? 0) || 0);
+        return {
+            prompt_tokens: Number(usage.promptTokenCount ?? 0) || 0,
+            prompt_cached_tokens: usage.cachedContentTokenCount == null
+                ? null
+                : Number(usage.cachedContentTokenCount),
+            prompt_cache_creation_tokens: null,
+            prompt_image_tokens: imageTokens,
+            completion_tokens: completionTokens,
+            total_tokens: Number(usage.totalTokenCount ?? 0) || 0,
+        };
+    }
     /**
      * Clean up JSON schema for Google's format
      * Google API has specific requirements for responseSchema
@@ -43,6 +111,10 @@ export class ChatGoogle {
             if (key === 'properties' && typeof value === 'object') {
                 cleaned.properties = {};
                 for (const [propKey, propValue] of Object.entries(value)) {
+                    // Align python: hide programmatic extraction schema field from LLM JSON schema.
+                    if (propKey === 'output_schema') {
+                        continue;
+                    }
                     cleaned.properties[propKey] = this._cleanSchemaForGoogle(propValue);
                 }
             }
@@ -56,42 +128,175 @@ export class ChatGoogle {
                 cleaned[key] = value;
             }
         }
+        const schemaType = String(cleaned.type ?? '').toUpperCase();
+        if (schemaType === 'OBJECT' &&
+            cleaned.properties &&
+            typeof cleaned.properties === 'object' &&
+            !Array.isArray(cleaned.properties) &&
+            Object.keys(cleaned.properties).length === 0) {
+            cleaned.properties = {
+                _placeholder: { type: 'string' },
+            };
+        }
+        if (Array.isArray(cleaned.required) &&
+            cleaned.properties &&
+            typeof cleaned.properties === 'object' &&
+            !Array.isArray(cleaned.properties)) {
+            const validKeys = new Set(Object.keys(cleaned.properties));
+            cleaned.required = cleaned.required.filter((name) => typeof name === 'string' && validKeys.has(name));
+        }
         return cleaned;
     }
+    _parseStructuredJson(text) {
+        let jsonText = String(text ?? '').trim();
+        const fencedMatch = jsonText.match(/```(?:json)?\s*([\s\S]*?)```/i);
+        if (fencedMatch && fencedMatch[1]) {
+            jsonText = fencedMatch[1].trim();
+        }
+        const firstBrace = jsonText.indexOf('{');
+        const lastBrace = jsonText.lastIndexOf('}');
+        if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace) {
+            throw new Error(`Expected JSON response but got plain text: "${jsonText.slice(0, 50)}..."`);
+        }
+        return JSON.parse(jsonText.slice(firstBrace, lastBrace + 1));
+    }
+    _extractStatusCode(error) {
+        const directStatus = Number(error?.status ??
+            error?.statusCode ??
+            error?.response?.status ??
+            error?.response?.statusCode);
+        if (Number.isFinite(directStatus)) {
+            return directStatus;
+        }
+        const message = String(error?.message ?? error ?? '').toLowerCase();
+        if (/(rate limit|resource exhausted|quota exceeded|too many requests|429)/.test(message)) {
+            return 429;
+        }
+        if (/(service unavailable|internal server error|bad gateway|503|502|500)/.test(message)) {
+            return 503;
+        }
+        if (/(forbidden|403)/.test(message)) {
+            return 403;
+        }
+        if (/(timeout|timed out|cancelled|canceled)/.test(message)) {
+            return 504;
+        }
+        return null;
+    }
+    _toModelProviderError(error) {
+        if (error instanceof ModelProviderError) {
+            return error;
+        }
+        return new ModelProviderError(error?.message ?? String(error), this._extractStatusCode(error) ?? 502, this.model);
+    }
+    async _sleep(ms) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
     async ainvoke(messages, output_format, options = {}) {
         const serializer = new GoogleMessageSerializer();
-        const contents = serializer.serialize(messages);
-        const systemMessage = messages.find((msg) => msg instanceof SystemMessage);
-        const systemInstruction = systemMessage ? systemMessage.text : undefined;
-        let tools = undefined;
-        let toolConfig = undefined;
-        // For Google, we need to be more explicit about JSON output
-        // The generationConfig with responseSchema helps enforce JSON structure
-        const generationConfig = {
-            responseMimeType: 'application/json',
-        };
+        const { contents, systemInstruction } = serializer.serializeWithSystem(messages, this.includeSystemInUser);
+        const generationConfig = this.config ? { ...this.config } : {};
+        if (this.temperature !== null) {
+            generationConfig.temperature = this.temperature;
+        }
+        if (this.topP !== null) {
+            generationConfig.topP = this.topP;
+        }
+        if (this.seed !== null) {
+            generationConfig.seed = this.seed;
+        }
+        const isGemini3Pro = this.model.includes('gemini-3-pro');
+        const isGemini3Flash = this.model.includes('gemini-3-flash');
+        if (isGemini3Pro) {
+            let level = this.thinkingLevel ?? 'low';
+            if (level === 'minimal' || level === 'medium') {
+                level = 'low';
+            }
+            generationConfig.thinkingConfig = {
+                thinkingLevel: level.toUpperCase(),
+            };
+        }
+        else if (isGemini3Flash) {
+            if (this.thinkingLevel !== null) {
+                generationConfig.thinkingConfig = {
+                    thinkingLevel: this.thinkingLevel.toUpperCase(),
+                };
+            }
+            else {
+                generationConfig.thinkingConfig = {
+                    thinkingBudget: this.thinkingBudget === null ? -1 : this.thinkingBudget,
+                };
+            }
+        }
+        else {
+            let budget = this.thinkingBudget;
+            if (budget === null &&
+                (this.model.includes('gemini-2.5') ||
+                    this.model.includes('gemini-flash'))) {
+                budget = -1;
+            }
+            if (budget !== null) {
+                generationConfig.thinkingConfig = { thinkingBudget: budget };
+            }
+        }
+        if (this.maxOutputTokens !== null) {
+            generationConfig.maxOutputTokens = this.maxOutputTokens;
+        }
         // Try to get schema from output_format
-        const schemaForJson = output_format &&
-            'schema' in output_format &&
-            output_format.schema
-            ? output_format.schema
-            : null;
+        const schemaForJson = (() => {
+            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;
+        })();
+        let cleanSchemaForJson = null;
         if (schemaForJson) {
             try {
-                const jsonSchema = zodToJsonSchema(schemaForJson);
-                // Clean up the schema for Google's format
-                const cleanSchema = this._cleanSchemaForGoogle(jsonSchema);
-                generationConfig.responseSchema = cleanSchema;
+                const jsonSchema = zodSchemaToJsonSchema(schemaForJson);
+                const optimizedSchema = SchemaOptimizer.createGeminiOptimizedSchema(jsonSchema);
+                cleanSchemaForJson = this._cleanSchemaForGoogle(optimizedSchema);
             }
-            catch (e) {
-                console.warn('Failed to set responseSchema', e);
+            catch {
+                cleanSchemaForJson = null;
+            }
+        }
+        if (cleanSchemaForJson && this.supportsStructuredOutput) {
+            generationConfig.responseMimeType = 'application/json';
+            generationConfig.responseSchema = cleanSchemaForJson;
+        }
+        const requestContents = contents.map((entry) => ({
+            ...entry,
+            parts: Array.isArray(entry?.parts)
+                ? entry.parts.map((part) => ({ ...part }))
+                : entry?.parts,
+        }));
+        if (output_format && cleanSchemaForJson && !this.supportsStructuredOutput) {
+            const jsonInstruction = '\n\nPlease respond with a valid JSON object that matches this schema: ' +
+                JSON.stringify(cleanSchemaForJson);
+            for (let i = requestContents.length - 1; i >= 0; i -= 1) {
+                const content = requestContents[i];
+                if (content?.role === 'user' && Array.isArray(content?.parts)) {
+                    content.parts = [...content.parts, { text: jsonInstruction }];
+                    break;
+                }
             }
         }
         const request = {
             model: this.model,
-            contents,
+            contents: requestContents,
         };
-        if (systemInstruction) {
+        if (systemInstruction && !this.includeSystemInUser) {
             request.systemInstruction = {
                 role: 'system',
                 parts: [{ text: systemInstruction }],
@@ -100,47 +305,45 @@ export class ChatGoogle {
         if (Object.keys(generationConfig).length > 0) {
             request.generationConfig = generationConfig;
         }
-        const result = await this.client.models.generateContent(request, options.signal ? { signal: options.signal } : undefined);
-        // Extract text from first candidate
-        const candidate = result.candidates?.[0];
-        const textParts = candidate?.content?.parts?.filter((p) => p.text) || [];
-        const text = textParts.map((p) => p.text).join('');
-        let completion = text;
-        if (output_format) {
+        for (let attempt = 0; attempt < this.maxRetries; attempt += 1) {
             try {
+                const result = await this.client.models.generateContent(request, options.signal ? { signal: options.signal } : undefined);
+                const candidate = result.candidates?.[0];
+                const textParts = candidate?.content?.parts?.filter((p) => p.text) || [];
+                const text = textParts.map((p) => p.text).join('');
+                let completion = text;
+                const stopReason = result?.candidates?.[0]?.finishReason ?? null;
                 let parsed = text;
-                if (generationConfig.responseMimeType === 'application/json') {
-                    let jsonText = text.trim();
-                    // Handle markdown code fences like ```json ... ```
-                    const fencedMatch = jsonText.match(/```(?:json)?\s*([\s\S]*?)```/i);
-                    if (fencedMatch && fencedMatch[1]) {
-                        jsonText = fencedMatch[1].trim();
-                    }
-                    // Try to extract JSON object from text
-                    const firstBrace = jsonText.indexOf('{');
-                    const lastBrace = jsonText.lastIndexOf('}');
-                    if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
-                        jsonText = jsonText.slice(firstBrace, lastBrace + 1);
+                if (output_format && schemaForJson) {
+                    parsed = this._parseStructuredJson(text);
+                }
+                if (output_format) {
+                    const output = output_format;
+                    if (schemaForJson &&
+                        output &&
+                        typeof output === 'object' &&
+                        output.schema &&
+                        typeof output.schema.parse === 'function') {
+                        completion = output.schema.parse(parsed);
                     }
                     else {
-                        // If no JSON object found, the model returned plain text
-                        // Try to wrap it in a minimal valid structure
-                        console.warn('Google LLM returned plain text instead of JSON. Raw response:', text.slice(0, 200));
-                        throw new Error(`Expected JSON response but got plain text: "${text.slice(0, 50)}..."`);
+                        completion = output.parse(parsed);
                     }
-                    parsed = JSON.parse(jsonText);
                 }
-                completion = output_format.parse(parsed);
+                return new ChatInvokeCompletion(completion, this.getUsage(result), null, null, stopReason);
             }
-            catch (e) {
-                console.error('Failed to parse completion', e);
-                throw e;
+            catch (error) {
+                const providerError = this._toModelProviderError(error);
+                const shouldRetry = this.retryableStatusCodes.includes(providerError.statusCode) &&
+                    attempt < this.maxRetries - 1;
+                if (!shouldRetry) {
+                    throw providerError;
+                }
+                const delaySeconds = Math.min(this.retryBaseDelay * 2 ** attempt, this.retryMaxDelay);
+                const jitter = Math.random() * delaySeconds * 0.1;
+                await this._sleep((delaySeconds + jitter) * 1000);
             }
         }
-        return new ChatInvokeCompletion(completion, {
-            prompt_tokens: result.usageMetadata?.promptTokenCount ?? 0,
-            completion_tokens: result.usageMetadata?.candidatesTokenCount ?? 0,
-            total_tokens: result.usageMetadata?.totalTokenCount ?? 0,
-        });
+        throw new ModelProviderError('Retry loop completed without response', 500, this.model);
     }
 }

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

@@ -1,6 +1,14 @@
 import type { Content } from '@google/genai';
 import { type Message } from '../messages.js';
+export interface SerializedGoogleMessages {
+    contents: Content[];
+    systemInstruction: string | null;
+}
 export declare class GoogleMessageSerializer {
     serialize(messages: Message[]): Content[];
-    private serializeMessage;
+    serializeWithSystem(messages: Message[], includeSystemInUser?: boolean): SerializedGoogleMessages;
+    private serializeUserMessage;
+    private serializeAssistantMessage;
+    private serializeImagePart;
+    private extractMessageText;
 }