@browserbasehq/orca 3.0.9-alpha-4 → 3.1.0-patch.0

package/dist/esm/lib/v3/llm/CerebrasClient.js

@@ -0,0 +1,235 @@
+import OpenAI from "openai";
+import { LLMClient, } from "./LLMClient.js";
+import { CreateChatCompletionResponseError } from "../types/public/sdkErrors.js";
+import { toJsonSchema } from "../zodCompat.js";
+export class CerebrasClient extends LLMClient {
+    type = "cerebras";
+    client;
+    hasVision = false;
+    constructor({ modelName, clientOptions, userProvidedInstructions, }) {
+        super(modelName, userProvidedInstructions);
+        // Create OpenAI client with the base URL set to Cerebras API
+        this.client = new OpenAI({
+            baseURL: "https://api.cerebras.ai/v1",
+            apiKey: clientOptions?.apiKey || process.env.CEREBRAS_API_KEY,
+            ...clientOptions,
+        });
+        this.modelName = modelName;
+        this.clientOptions = clientOptions;
+    }
+    async createChatCompletion({ options, retries, logger, }) {
+        const optionsWithoutImage = { ...options };
+        delete optionsWithoutImage.image;
+        logger({
+            category: "cerebras",
+            message: "creating chat completion",
+            level: 2,
+            auxiliary: {
+                options: {
+                    value: JSON.stringify(optionsWithoutImage),
+                    type: "object",
+                },
+            },
+        });
+        // Format messages for Cerebras API (using OpenAI format)
+        const formattedMessages = options.messages.map((msg) => {
+            const baseMessage = {
+                content: typeof msg.content === "string"
+                    ? msg.content
+                    : Array.isArray(msg.content) &&
+                        msg.content.length > 0 &&
+                        "text" in msg.content[0]
+                        ? msg.content[0].text
+                        : "",
+            };
+            // Cerebras only supports system, user, and assistant roles
+            if (msg.role === "system") {
+                return { ...baseMessage, role: "system" };
+            }
+            else if (msg.role === "assistant") {
+                return { ...baseMessage, role: "assistant" };
+            }
+            else {
+                // Default to user for any other role
+                return { ...baseMessage, role: "user" };
+            }
+        });
+        // Format tools if provided
+        let tools = options.tools?.map((tool) => ({
+            type: "function",
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                    type: "object",
+                    properties: tool.parameters.properties,
+                    required: tool.parameters.required,
+                },
+            },
+        }));
+        // Add response model as a tool if provided
+        if (options.response_model) {
+            const jsonSchema = toJsonSchema(options.response_model.schema);
+            const schemaProperties = jsonSchema.properties || {};
+            const schemaRequired = jsonSchema.required || [];
+            const responseTool = {
+                type: "function",
+                function: {
+                    name: "print_extracted_data",
+                    description: "Prints the extracted data based on the provided schema.",
+                    parameters: {
+                        type: "object",
+                        properties: schemaProperties,
+                        required: schemaRequired,
+                    },
+                },
+            };
+            tools = tools ? [...tools, responseTool] : [responseTool];
+        }
+        try {
+            // Use OpenAI client with Cerebras API
+            const apiResponse = await this.client.chat.completions.create({
+                model: this.modelName.split("cerebras-")[1],
+                messages: [
+                    ...formattedMessages,
+                    // Add explicit instruction to return JSON if we have a response model
+                    ...(options.response_model
+                        ? [
+                            {
+                                role: "system",
+                                content: `IMPORTANT: Your response must be valid JSON that matches this schema: ${JSON.stringify(options.response_model.schema)}`,
+                            },
+                        ]
+                        : []),
+                ],
+                temperature: options.temperature || 0.7,
+                max_tokens: options.maxOutputTokens,
+                tools: tools,
+                tool_choice: options.tool_choice || "auto",
+            });
+            // Format the response to match the expected LLMResponse format
+            const response = {
+                id: apiResponse.id,
+                object: "chat.completion",
+                created: Date.now(),
+                model: this.modelName.split("cerebras-")[1],
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: "assistant",
+                            content: apiResponse.choices[0]?.message?.content || null,
+                            tool_calls: apiResponse.choices[0]?.message?.tool_calls || [],
+                        },
+                        finish_reason: apiResponse.choices[0]?.finish_reason || "stop",
+                    },
+                ],
+                usage: {
+                    prompt_tokens: apiResponse.usage?.prompt_tokens || 0,
+                    completion_tokens: apiResponse.usage?.completion_tokens || 0,
+                    total_tokens: apiResponse.usage?.total_tokens || 0,
+                },
+            };
+            logger({
+                category: "cerebras",
+                message: "response",
+                level: 2,
+                auxiliary: {
+                    response: {
+                        value: JSON.stringify(response),
+                        type: "object",
+                    },
+                    requestId: {
+                        value: options.requestId,
+                        type: "string",
+                    },
+                },
+            });
+            // If we have no response model, just return the entire LLMResponse
+            if (!options.response_model) {
+                return response;
+            }
+            // If we have a response model, parse JSON from tool calls or content
+            const toolCall = response.choices[0]?.message?.tool_calls?.[0];
+            if (toolCall?.function?.arguments) {
+                try {
+                    const result = JSON.parse(toolCall.function.arguments);
+                    const finalResponse = {
+                        data: result,
+                        usage: response.usage,
+                    };
+                    return finalResponse;
+                }
+                catch (e) {
+                    logger({
+                        category: "cerebras",
+                        message: "failed to parse tool call arguments as JSON, retrying",
+                        level: 0,
+                        auxiliary: {
+                            error: {
+                                value: e.message,
+                                type: "string",
+                            },
+                        },
+                    });
+                }
+            }
+            // If we have content but no tool calls, try to parse the content as JSON
+            const content = response.choices[0]?.message?.content;
+            if (content) {
+                try {
+                    const jsonMatch = content.match(/\{[\s\S]*\}/);
+                    if (jsonMatch) {
+                        const result = JSON.parse(jsonMatch[0]);
+                        const finalResponse = {
+                            data: result,
+                            usage: response.usage,
+                        };
+                        return finalResponse;
+                    }
+                }
+                catch (e) {
+                    logger({
+                        category: "cerebras",
+                        message: "failed to parse content as JSON",
+                        level: 0,
+                        auxiliary: {
+                            error: {
+                                value: e.message,
+                                type: "string",
+                            },
+                        },
+                    });
+                }
+            }
+            // If we still haven't found valid JSON and have retries left, try again
+            if (!retries || retries < 5) {
+                return this.createChatCompletion({
+                    options,
+                    logger,
+                    retries: (retries ?? 0) + 1,
+                });
+            }
+            throw new CreateChatCompletionResponseError("Invalid response schema");
+        }
+        catch (error) {
+            logger({
+                category: "cerebras",
+                message: "error creating chat completion",
+                level: 0,
+                auxiliary: {
+                    error: {
+                        value: error.message,
+                        type: "string",
+                    },
+                    requestId: {
+                        value: options.requestId,
+                        type: "string",
+                    },
+                },
+            });
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=CerebrasClient.js.map

package/dist/esm/lib/v3/llm/CerebrasClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CerebrasClient.js","sourceRoot":"","sources":["../../../../../lib/v3/llm/CerebrasClient.ts"],"names":[],"mappings":"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","sourcesContent":["import OpenAI from \"openai\";\nimport type { ClientOptions } from \"openai\";\nimport { LogLine } from \"../types/public/logs.js\";\nimport { AvailableModel } from \"../types/public/model.js\";\nimport {\n  ChatMessage,\n  CreateChatCompletionOptions,\n  LLMClient,\n  LLMResponse,\n} from \"./LLMClient.js\";\nimport { CreateChatCompletionResponseError } from \"../types/public/sdkErrors.js\";\nimport { toJsonSchema } from \"../zodCompat.js\";\n\nexport class CerebrasClient extends LLMClient {\n  public type = \"cerebras\" as const;\n  private client: OpenAI;\n  declare public clientOptions: ClientOptions;\n  public hasVision = false;\n\n  constructor({\n    modelName,\n    clientOptions,\n    userProvidedInstructions,\n  }: {\n    logger: (message: LogLine) => void;\n    modelName: AvailableModel;\n    clientOptions?: ClientOptions;\n    userProvidedInstructions?: string;\n  }) {\n    super(modelName, userProvidedInstructions);\n\n    // Create OpenAI client with the base URL set to Cerebras API\n    this.client = new OpenAI({\n      baseURL: \"https://api.cerebras.ai/v1\",\n      apiKey: clientOptions?.apiKey || process.env.CEREBRAS_API_KEY,\n      ...clientOptions,\n    });\n\n    this.modelName = modelName;\n    this.clientOptions = clientOptions;\n  }\n\n  async createChatCompletion<T = LLMResponse>({\n    options,\n    retries,\n    logger,\n  }: CreateChatCompletionOptions): Promise<T> {\n    const optionsWithoutImage = { ...options };\n    delete optionsWithoutImage.image;\n\n    logger({\n      category: \"cerebras\",\n      message: \"creating chat completion\",\n      level: 2,\n      auxiliary: {\n        options: {\n          value: JSON.stringify(optionsWithoutImage),\n          type: \"object\",\n        },\n      },\n    });\n\n    // Format messages for Cerebras API (using OpenAI format)\n    const formattedMessages = options.messages.map((msg: ChatMessage) => {\n      const baseMessage = {\n        content:\n          typeof msg.content === \"string\"\n            ? msg.content\n            : Array.isArray(msg.content) &&\n                msg.content.length > 0 &&\n                \"text\" in msg.content[0]\n              ? msg.content[0].text\n              : \"\",\n      };\n\n      // Cerebras only supports system, user, and assistant roles\n      if (msg.role === \"system\") {\n        return { ...baseMessage, role: \"system\" as const };\n      } else if (msg.role === \"assistant\") {\n        return { ...baseMessage, role: \"assistant\" as const };\n      } else {\n        // Default to user for any other role\n        return { ...baseMessage, role: \"user\" as const };\n      }\n    });\n\n    // Format tools if provided\n    let tools = options.tools?.map((tool) => ({\n      type: \"function\" as const,\n      function: {\n        name: tool.name,\n        description: tool.description,\n        parameters: {\n          type: \"object\",\n          properties: tool.parameters.properties,\n          required: tool.parameters.required,\n        },\n      },\n    }));\n\n    // Add response model as a tool if provided\n    if (options.response_model) {\n      const jsonSchema = toJsonSchema(options.response_model.schema) as {\n        properties?: Record<string, unknown>;\n        required?: string[];\n      };\n      const schemaProperties = jsonSchema.properties || {};\n      const schemaRequired = jsonSchema.required || [];\n\n      const responseTool = {\n        type: \"function\" as const,\n        function: {\n          name: \"print_extracted_data\",\n          description:\n            \"Prints the extracted data based on the provided schema.\",\n          parameters: {\n            type: \"object\",\n            properties: schemaProperties,\n            required: schemaRequired,\n          },\n        },\n      };\n\n      tools = tools ? [...tools, responseTool] : [responseTool];\n    }\n\n    try {\n      // Use OpenAI client with Cerebras API\n      const apiResponse = await this.client.chat.completions.create({\n        model: this.modelName.split(\"cerebras-\")[1],\n        messages: [\n          ...formattedMessages,\n          // Add explicit instruction to return JSON if we have a response model\n          ...(options.response_model\n            ? [\n                {\n                  role: \"system\" as const,\n                  content: `IMPORTANT: Your response must be valid JSON that matches this schema: ${JSON.stringify(\n                    options.response_model.schema,\n                  )}`,\n                },\n              ]\n            : []),\n        ],\n        temperature: options.temperature || 0.7,\n        max_tokens: options.maxOutputTokens,\n        tools: tools,\n        tool_choice: options.tool_choice || \"auto\",\n      });\n\n      // Format the response to match the expected LLMResponse format\n      const response: LLMResponse = {\n        id: apiResponse.id,\n        object: \"chat.completion\",\n        created: Date.now(),\n        model: this.modelName.split(\"cerebras-\")[1],\n        choices: [\n          {\n            index: 0,\n            message: {\n              role: \"assistant\",\n              content: apiResponse.choices[0]?.message?.content || null,\n              tool_calls: apiResponse.choices[0]?.message?.tool_calls || [],\n            },\n            finish_reason: apiResponse.choices[0]?.finish_reason || \"stop\",\n          },\n        ],\n        usage: {\n          prompt_tokens: apiResponse.usage?.prompt_tokens || 0,\n          completion_tokens: apiResponse.usage?.completion_tokens || 0,\n          total_tokens: apiResponse.usage?.total_tokens || 0,\n        },\n      };\n\n      logger({\n        category: \"cerebras\",\n        message: \"response\",\n        level: 2,\n        auxiliary: {\n          response: {\n            value: JSON.stringify(response),\n            type: \"object\",\n          },\n          requestId: {\n            value: options.requestId,\n            type: \"string\",\n          },\n        },\n      });\n\n      // If we have no response model, just return the entire LLMResponse\n      if (!options.response_model) {\n        return response as T;\n      }\n\n      // If we have a response model, parse JSON from tool calls or content\n      const toolCall = response.choices[0]?.message?.tool_calls?.[0];\n      if (toolCall?.function?.arguments) {\n        try {\n          const result = JSON.parse(toolCall.function.arguments);\n          const finalResponse = {\n            data: result,\n            usage: response.usage,\n          };\n          return finalResponse as T;\n        } catch (e) {\n          logger({\n            category: \"cerebras\",\n            message: \"failed to parse tool call arguments as JSON, retrying\",\n            level: 0,\n            auxiliary: {\n              error: {\n                value: e.message,\n                type: \"string\",\n              },\n            },\n          });\n        }\n      }\n\n      // If we have content but no tool calls, try to parse the content as JSON\n      const content = response.choices[0]?.message?.content;\n      if (content) {\n        try {\n          const jsonMatch = content.match(/\\{[\\s\\S]*\\}/);\n          if (jsonMatch) {\n            const result = JSON.parse(jsonMatch[0]);\n            const finalResponse = {\n              data: result,\n              usage: response.usage,\n            };\n            return finalResponse as T;\n          }\n        } catch (e) {\n          logger({\n            category: \"cerebras\",\n            message: \"failed to parse content as JSON\",\n            level: 0,\n            auxiliary: {\n              error: {\n                value: e.message,\n                type: \"string\",\n              },\n            },\n          });\n        }\n      }\n\n      // If we still haven't found valid JSON and have retries left, try again\n      if (!retries || retries < 5) {\n        return this.createChatCompletion({\n          options,\n          logger,\n          retries: (retries ?? 0) + 1,\n        });\n      }\n\n      throw new CreateChatCompletionResponseError(\"Invalid response schema\");\n    } catch (error) {\n      logger({\n        category: \"cerebras\",\n        message: \"error creating chat completion\",\n        level: 0,\n        auxiliary: {\n          error: {\n            value: error.message,\n            type: \"string\",\n          },\n          requestId: {\n            value: options.requestId,\n            type: \"string\",\n          },\n        },\n      });\n      throw error;\n    }\n  }\n}\n"]}

package/dist/esm/lib/v3/llm/GoogleClient.d.ts

@@ -0,0 +1,19 @@
+import { LogLine } from "../types/public/logs.js";
+import { AvailableModel, ClientOptions } from "../types/public/model.js";
+import { CreateChatCompletionOptions, LLMClient, LLMResponse } from "./LLMClient.js";
+export declare class GoogleClient extends LLMClient {
+    type: "google";
+    private client;
+    clientOptions: ClientOptions;
+    hasVision: boolean;
+    private logger;
+    constructor({ logger, // Added logger based on other clients
+    modelName, clientOptions, }: {
+        logger: (message: LogLine) => void;
+        modelName: AvailableModel;
+        clientOptions?: ClientOptions;
+    });
+    private formatMessages;
+    private formatTools;
+    createChatCompletion<T = LLMResponse>({ options, logger, retries, }: CreateChatCompletionOptions): Promise<T>;
+}

package/dist/esm/lib/v3/llm/GoogleClient.js

@@ -0,0 +1,369 @@
+import { GoogleGenAI, HarmCategory, HarmBlockThreshold, Type, } from "@google/genai";
+import { validateZodSchema, toGeminiSchema, loadApiKeyFromEnv, } from "../../utils.js";
+import { LLMClient, AnnotatedScreenshotText, } from "./LLMClient.js";
+import { CreateChatCompletionResponseError, StagehandError, } from "../types/public/sdkErrors.js";
+// Mapping from generic roles to Gemini roles
+const roleMap = {
+    user: "user",
+    assistant: "model",
+    system: "user", // Gemini API prefers system instructions either via system_instruction or at the start of 'user' content
+};
+// Basic safety settings - adjust as needed
+const safetySettings = [
+    {
+        category: HarmCategory.HARM_CATEGORY_HARASSMENT,
+        threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    },
+    {
+        category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+        threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    },
+    {
+        category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+        threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    },
+    {
+        category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+        threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+    },
+];
+export class GoogleClient extends LLMClient {
+    type = "google";
+    client;
+    logger;
+    constructor({ logger, // Added logger based on other clients
+    modelName, clientOptions, }) {
+        super(modelName);
+        if (!clientOptions?.apiKey) {
+            // Try to get the API key from the environment variable GOOGLE_API_KEY
+            clientOptions.apiKey = loadApiKeyFromEnv("google_legacy", logger);
+        }
+        this.clientOptions = clientOptions;
+        this.client = new GoogleGenAI({ apiKey: clientOptions.apiKey });
+        this.modelName = modelName;
+        this.logger = logger;
+        // Determine vision capability based on model name (adjust as needed)
+        this.hasVision =
+            modelName.includes("vision") || modelName.includes("gemini-1.5"); // Example logic
+    }
+    // Helper to convert project's ChatMessage[] to Gemini's Content[]
+    formatMessages(messages, image) {
+        const contents = [];
+        let systemInstruction = null;
+        messages.forEach((msg, index) => {
+            const role = roleMap[msg.role];
+            if (!role) {
+                this.logger({
+                    category: "google",
+                    message: `WARNING: Unsupported role: ${msg.role}`,
+                    level: 1,
+                });
+                return; // Skip unsupported roles
+            }
+            // Handle system messages - prepend to the first user message or use system_instruction if available
+            if (msg.role === "system") {
+                if (typeof msg.content === "string") {
+                    systemInstruction =
+                        (systemInstruction ? systemInstruction + "\n\n" : "") + msg.content;
+                }
+                return; // Don't add system messages directly to contents yet
+            }
+            const parts = [];
+            if (Array.isArray(msg.content)) {
+                msg.content.forEach((partContent) => {
+                    if (partContent.type === "text") {
+                        parts.push({ text: partContent.text });
+                    }
+                    else if (partContent.type === "image_url") {
+                        if ("image_url" in partContent && partContent.image_url?.url) {
+                            // Assuming base64 data URI format: data:[<mediatype>];base64,<data>
+                            const base64Data = partContent.image_url.url.split(",")[1];
+                            const mimeTypeMatch = partContent.image_url.url.match(/^data:(image\/\w+);base64,/);
+                            if (base64Data && mimeTypeMatch) {
+                                parts.push({
+                                    inlineData: { mimeType: mimeTypeMatch[1], data: base64Data },
+                                });
+                            }
+                            else {
+                                this.logger({
+                                    category: "google",
+                                    message: "WARNING: Could not parse image data URI format",
+                                    level: 1,
+                                });
+                            }
+                        }
+                    }
+                });
+            }
+            else if (typeof msg.content === "string") {
+                parts.push({ text: msg.content });
+            }
+            // Add image from options if this is the last message and it's a user message
+            if (image && index === messages.length - 1 && msg.role === "user") {
+                const imageDesc = image.description || AnnotatedScreenshotText;
+                parts.push({ text: imageDesc }); // Add description first
+                parts.push({
+                    inlineData: {
+                        mimeType: "image/jpeg", // Assuming JPEG, adjust if needed
+                        data: image.buffer.toString("base64"),
+                    },
+                });
+            }
+            // Apply system instruction to the first non-system message if needed
+            if (systemInstruction && contents.length === 0 && role === "user") {
+                const firstPartText = parts.find((p) => "text" in p);
+                if (firstPartText && "text" in firstPartText) {
+                    firstPartText.text = `${systemInstruction}\n\n${firstPartText.text}`;
+                }
+                else {
+                    parts.unshift({ text: systemInstruction });
+                }
+                systemInstruction = null; // Clear after applying
+            }
+            if (parts.length > 0) {
+                contents.push({ role, parts });
+            }
+        });
+        // If system instruction wasn't applied (e.g., no user messages followed it), add it as a final user message
+        if (systemInstruction) {
+            contents.unshift({ role: "user", parts: [{ text: systemInstruction }] });
+        }
+        return contents;
+    }
+    // Helper to convert LLMTool[] to Gemini's Tool[]
+    formatTools(tools) {
+        if (!tools || tools.length === 0) {
+            return undefined;
+        }
+        return [
+            {
+                functionDeclarations: tools.map((tool) => {
+                    let parameters = undefined;
+                    if (tool.parameters) {
+                        parameters = {
+                            type: Type.OBJECT,
+                            properties: tool.parameters.properties,
+                            required: tool.parameters.required,
+                        };
+                    }
+                    return {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: parameters,
+                    };
+                }),
+            },
+        ];
+    }
+    async createChatCompletion({ 
+    // Ensure LLMResponse is compatible
+    options, logger, retries = 3, }) {
+        const { image, requestId, response_model, tools, temperature, top_p, maxOutputTokens, } = options;
+        const formattedMessages = this.formatMessages(options.messages, image);
+        const formattedTools = this.formatTools(tools);
+        const generationConfig = {
+            maxOutputTokens: maxOutputTokens,
+            temperature: temperature,
+            topP: top_p,
+            responseMimeType: response_model ? "application/json" : undefined,
+            responseSchema: response_model
+                ? toGeminiSchema(response_model.schema)
+                : undefined,
+        };
+        logger({
+            category: "google",
+            message: "creating chat completion",
+            level: 2,
+            auxiliary: {
+                modelName: { value: this.modelName, type: "string" },
+                requestId: { value: requestId, type: "string" },
+                requestPayloadSummary: {
+                    value: `Model: ${this.modelName}, Messages: ${formattedMessages.length}, Config Keys: ${Object.keys(generationConfig).join(", ")}, Tools: ${formattedTools ? formattedTools.length : 0}, Safety Categories: ${safetySettings.map((s) => s.category).join(", ")}`,
+                    type: "string",
+                },
+            },
+        });
+        // Construct the full request object
+        const requestPayload = {
+            model: this.modelName,
+            contents: formattedMessages,
+            config: {
+                ...generationConfig,
+                safetySettings: safetySettings,
+                tools: formattedTools,
+            },
+        };
+        // Log the full payload safely
+        try {
+            logger({
+                category: "google",
+                message: "Full request payload",
+                level: 2,
+                auxiliary: {
+                    requestId: { value: requestId, type: "string" },
+                    fullPayload: {
+                        value: JSON.stringify(requestPayload),
+                        type: "object",
+                    },
+                },
+            });
+        }
+        catch (e) {
+            logger({
+                category: "google",
+                message: "Failed to stringify full request payload for logging",
+                level: 0,
+                auxiliary: {
+                    requestId: { value: requestId, type: "string" },
+                    error: { value: e.message, type: "string" },
+                },
+            });
+        }
+        try {
+            const result = await this.client.models.generateContent(requestPayload); // Pass the constructed payload
+            logger({
+                category: "google",
+                message: "received response",
+                level: 2,
+                auxiliary: {
+                    requestId: { value: requestId, type: "string" },
+                    response: {
+                        value: JSON.stringify(result),
+                        type: "object",
+                    },
+                },
+            });
+            const finishReason = result.candidates?.[0]?.finishReason || "unknown";
+            const toolCalls = result.functionCalls?.map((fc, index) => ({
+                id: `tool_call_${requestId}_${index}`,
+                type: "function",
+                function: {
+                    name: fc.name,
+                    arguments: JSON.stringify(fc.args),
+                },
+            }));
+            let content = null;
+            try {
+                content = result.text;
+            }
+            catch (e) {
+                logger({
+                    category: "google",
+                    message: `Could not extract text content: ${e.message}`,
+                    level: 1,
+                    auxiliary: { requestId: { value: requestId, type: "string" } },
+                });
+                content = null;
+            }
+            // Construct LLMResponse shape
+            const llmResponse = {
+                id: result.candidates?.[0]?.index?.toString() || requestId,
+                object: "chat.completion",
+                created: Math.floor(Date.now() / 1000),
+                model: this.modelName,
+                choices: [
+                    {
+                        index: 0,
+                        message: {
+                            role: "assistant",
+                            content: content,
+                            tool_calls: toolCalls,
+                        },
+                        finish_reason: finishReason,
+                    },
+                ],
+                usage: {
+                    prompt_tokens: result.usageMetadata?.promptTokenCount || 0,
+                    completion_tokens: result.usageMetadata?.candidatesTokenCount || 0,
+                    total_tokens: result.usageMetadata?.totalTokenCount || 0,
+                },
+            };
+            // Validate schema if response_model was provided
+            if (response_model) {
+                let parsedData;
+                try {
+                    // Need to handle potential markdown fences if the model didn't follow instructions perfectly
+                    const potentialJson = content?.trim().replace(/^```json\n?|\n?```$/g, "") || "{}";
+                    parsedData = JSON.parse(potentialJson);
+                }
+                catch (e) {
+                    logger({
+                        category: "google",
+                        message: `Failed to parse JSON response: ${e.message}`,
+                        level: 0,
+                        auxiliary: {
+                            content: { value: content || "null", type: "string" },
+                        },
+                    });
+                    if (retries > 0) {
+                        return this.createChatCompletion({
+                            options,
+                            logger,
+                            retries: retries - 1,
+                        });
+                    }
+                    throw new CreateChatCompletionResponseError(`Failed to parse JSON response: ${e.message}`);
+                }
+                try {
+                    validateZodSchema(response_model.schema, parsedData);
+                }
+                catch (err) {
+                    logger({
+                        category: "google",
+                        message: "Response failed Zod schema validation",
+                        level: 0,
+                    });
+                    if (retries > 0) {
+                        return this.createChatCompletion({
+                            options,
+                            logger,
+                            retries: retries - 1,
+                        });
+                    }
+                    throw err;
+                }
+                // If schema validation passes, structure the response for extraction use case
+                const extractionResult = {
+                    data: parsedData,
+                    usage: llmResponse.usage,
+                };
+                return extractionResult;
+            }
+            return llmResponse;
+        }
+        catch (error) {
+            logger({
+                category: "google",
+                message: `Error during Google AI chat completion: ${error.message}`,
+                level: 0,
+                auxiliary: {
+                    errorDetails: {
+                        value: `Message: ${error.message}${error.stack ? "\nStack: " + error.stack : ""}`,
+                        type: "string",
+                    },
+                    requestId: { value: requestId, type: "string" },
+                },
+            });
+            // Basic retry logic
+            if (retries > 0) {
+                logger({
+                    category: "google",
+                    message: `Retrying... (${retries} attempts left)`,
+                    level: 1,
+                });
+                await new Promise((resolve) => setTimeout(resolve, 1000 * (4 - retries))); // Simple backoff
+                return this.createChatCompletion({
+                    options,
+                    logger,
+                    retries: retries - 1,
+                });
+            }
+            // Re-throw specific Stagehand errors or a generic one
+            if (error instanceof StagehandError) {
+                throw error;
+            }
+            throw new StagehandError(`Google AI API request failed: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GoogleClient.js.map