@ai-sdk/google 2.0.0-canary.9 → 2.0.0

package/dist/index.js

@@ -26,22 +26,21 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/google-provider.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
 
 // src/google-generative-ai-embedding-model.ts
 var import_provider = require("@ai-sdk/provider");
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
+var import_v43 = require("zod/v4");
 
 // src/google-error.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_zod = require("zod");
-var googleErrorDataSchema = import_zod.z.object({
-  error: import_zod.z.object({
-    code: import_zod.z.number().nullable(),
-    message: import_zod.z.string(),
-    status: import_zod.z.string()
+var import_v4 = require("zod/v4");
+var googleErrorDataSchema = import_v4.z.object({
+  error: import_v4.z.object({
+    code: import_v4.z.number().nullable(),
+    message: import_v4.z.string(),
+    status: import_v4.z.string()
   })
 });
 var googleFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
@@ -49,28 +48,61 @@ var googleFailedResponseHandler = (0, import_provider_utils.createJsonErrorRespo
   errorToMessage: (data) => data.error.message
 });
 
+// src/google-generative-ai-embedding-options.ts
+var import_v42 = require("zod/v4");
+var googleGenerativeAIEmbeddingProviderOptions = import_v42.z.object({
+  /**
+   * Optional. Optional reduced dimension for the output embedding.
+   * If set, excessive values in the output embedding are truncated from the end.
+   */
+  outputDimensionality: import_v42.z.number().optional(),
+  /**
+   * Optional. Specifies the task type for generating embeddings.
+   * Supported task types:
+   * - SEMANTIC_SIMILARITY: Optimized for text similarity.
+   * - CLASSIFICATION: Optimized for text classification.
+   * - CLUSTERING: Optimized for clustering texts based on similarity.
+   * - RETRIEVAL_DOCUMENT: Optimized for document retrieval.
+   * - RETRIEVAL_QUERY: Optimized for query-based retrieval.
+   * - QUESTION_ANSWERING: Optimized for answering questions.
+   * - FACT_VERIFICATION: Optimized for verifying factual information.
+   * - CODE_RETRIEVAL_QUERY: Optimized for retrieving code blocks based on natural language queries.
+   */
+  taskType: import_v42.z.enum([
+    "SEMANTIC_SIMILARITY",
+    "CLASSIFICATION",
+    "CLUSTERING",
+    "RETRIEVAL_DOCUMENT",
+    "RETRIEVAL_QUERY",
+    "QUESTION_ANSWERING",
+    "FACT_VERIFICATION",
+    "CODE_RETRIEVAL_QUERY"
+  ]).optional()
+});
+
 // src/google-generative-ai-embedding-model.ts
 var GoogleGenerativeAIEmbeddingModel = class {
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.specificationVersion = "v2";
+    this.maxEmbeddingsPerCall = 2048;
+    this.supportsParallelCalls = true;
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
   }
   get provider() {
     return this.config.provider;
   }
-  get maxEmbeddingsPerCall() {
-    return 2048;
-  }
-  get supportsParallelCalls() {
-    return true;
-  }
   async doEmbed({
     values,
     headers,
-    abortSignal
+    abortSignal,
+    providerOptions
   }) {
+    const googleOptions = await (0, import_provider_utils2.parseProviderOptions)({
+      provider: "google",
+      providerOptions,
+      schema: googleGenerativeAIEmbeddingProviderOptions
+    });
     if (values.length > this.maxEmbeddingsPerCall) {
       throw new import_provider.TooManyEmbeddingValuesForCallError({
         provider: this.provider,
@@ -83,6 +115,35 @@ var GoogleGenerativeAIEmbeddingModel = class {
       await (0, import_provider_utils2.resolve)(this.config.headers),
       headers
     );
+    if (values.length === 1) {
+      const {
+        responseHeaders: responseHeaders2,
+        value: response2,
+        rawValue: rawValue2
+      } = await (0, import_provider_utils2.postJsonToApi)({
+        url: `${this.config.baseURL}/models/${this.modelId}:embedContent`,
+        headers: mergedHeaders,
+        body: {
+          model: `models/${this.modelId}`,
+          content: {
+            parts: [{ text: values[0] }]
+          },
+          outputDimensionality: googleOptions == null ? void 0 : googleOptions.outputDimensionality,
+          taskType: googleOptions == null ? void 0 : googleOptions.taskType
+        },
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+          googleGenerativeAISingleEmbeddingResponseSchema
+        ),
+        abortSignal,
+        fetch: this.config.fetch
+      });
+      return {
+        embeddings: [response2.embedding.values],
+        usage: void 0,
+        response: { headers: responseHeaders2, body: rawValue2 }
+      };
+    }
     const {
       responseHeaders,
       value: response,
@@ -94,7 +155,8 @@ var GoogleGenerativeAIEmbeddingModel = class {
         requests: values.map((value) => ({
           model: `models/${this.modelId}`,
           content: { role: "user", parts: [{ text: value }] },
-          outputDimensionality: this.settings.outputDimensionality
+          outputDimensionality: googleOptions == null ? void 0 : googleOptions.outputDimensionality,
+          taskType: googleOptions == null ? void 0 : googleOptions.taskType
         }))
       },
       failedResponseHandler: googleFailedResponseHandler,
@@ -111,13 +173,16 @@ var GoogleGenerativeAIEmbeddingModel = class {
     };
   }
 };
-var googleGenerativeAITextEmbeddingResponseSchema = import_zod2.z.object({
-  embeddings: import_zod2.z.array(import_zod2.z.object({ values: import_zod2.z.array(import_zod2.z.number()) }))
+var googleGenerativeAITextEmbeddingResponseSchema = import_v43.z.object({
+  embeddings: import_v43.z.array(import_v43.z.object({ values: import_v43.z.array(import_v43.z.number()) }))
+});
+var googleGenerativeAISingleEmbeddingResponseSchema = import_v43.z.object({
+  embedding: import_v43.z.object({ values: import_v43.z.array(import_v43.z.number()) })
 });
 
 // src/google-generative-ai-language-model.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_v47 = require("zod/v4");
 
 // src/convert-json-schema-to-openapi-schema.ts
 function convertJSONSchemaToOpenAPISchema(jsonSchema) {
@@ -213,16 +278,18 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema) {
   return result;
 }
 function isEmptyObjectSchema(jsonSchema) {
-  return jsonSchema != null && typeof jsonSchema === "object" && jsonSchema.type === "object" && (jsonSchema.properties == null || Object.keys(jsonSchema.properties).length === 0);
+  return jsonSchema != null && typeof jsonSchema === "object" && jsonSchema.type === "object" && (jsonSchema.properties == null || Object.keys(jsonSchema.properties).length === 0) && !jsonSchema.additionalProperties;
 }
 
 // src/convert-to-google-generative-ai-messages.ts
 var import_provider2 = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-function convertToGoogleGenerativeAIMessages(prompt) {
+function convertToGoogleGenerativeAIMessages(prompt, options) {
+  var _a;
   const systemInstructionParts = [];
   const contents = [];
   let systemMessagesAllowed = true;
+  const isGemmaModel = (_a = options == null ? void 0 : options.isGemmaModel) != null ? _a : false;
   for (const { role, content } of prompt) {
     switch (role) {
       case "system": {
@@ -296,7 +363,7 @@ function convertToGoogleGenerativeAIMessages(prompt) {
                 return {
                   functionCall: {
                     name: part.toolName,
-                    args: part.args
+                    args: part.input
                   }
                 };
               }
@@ -314,7 +381,7 @@ function convertToGoogleGenerativeAIMessages(prompt) {
               name: part.toolName,
               response: {
                 name: part.toolName,
-                content: part.result
+                content: part.output.value
               }
             }
           }))
@@ -323,8 +390,12 @@ function convertToGoogleGenerativeAIMessages(prompt) {
       }
     }
   }
+  if (isGemmaModel && systemInstructionParts.length > 0 && contents.length > 0 && contents[0].role === "user") {
+    const systemText = systemInstructionParts.map((part) => part.text).join("\n\n");
+    contents[0].parts.unshift({ text: systemText + "\n\n" });
+  }
   return {
-    systemInstruction: systemInstructionParts.length > 0 ? { parts: systemInstructionParts } : void 0,
+    systemInstruction: systemInstructionParts.length > 0 && !isGemmaModel ? { parts: systemInstructionParts } : void 0,
     contents
   };
 }
@@ -334,13 +405,73 @@ function getModelPath(modelId) {
   return modelId.includes("/") ? modelId : `models/${modelId}`;
 }
 
+// src/google-generative-ai-options.ts
+var import_v44 = require("zod/v4");
+var googleGenerativeAIProviderOptions = import_v44.z.object({
+  responseModalities: import_v44.z.array(import_v44.z.enum(["TEXT", "IMAGE"])).optional(),
+  thinkingConfig: import_v44.z.object({
+    thinkingBudget: import_v44.z.number().optional(),
+    includeThoughts: import_v44.z.boolean().optional()
+  }).optional(),
+  /**
+  Optional.
+  The name of the cached content used as context to serve the prediction.
+  Format: cachedContents/{cachedContent}
+     */
+  cachedContent: import_v44.z.string().optional(),
+  /**
+   * Optional. Enable structured output. Default is true.
+   *
+   * This is useful when the JSON Schema contains elements that are
+   * not supported by the OpenAPI schema version that
+   * Google Generative AI uses. You can use this to disable
+   * structured outputs if you need to.
+   */
+  structuredOutputs: import_v44.z.boolean().optional(),
+  /**
+  Optional. A list of unique safety settings for blocking unsafe content.
+   */
+  safetySettings: import_v44.z.array(
+    import_v44.z.object({
+      category: import_v44.z.enum([
+        "HARM_CATEGORY_UNSPECIFIED",
+        "HARM_CATEGORY_HATE_SPEECH",
+        "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "HARM_CATEGORY_HARASSMENT",
+        "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "HARM_CATEGORY_CIVIC_INTEGRITY"
+      ]),
+      threshold: import_v44.z.enum([
+        "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+        "BLOCK_LOW_AND_ABOVE",
+        "BLOCK_MEDIUM_AND_ABOVE",
+        "BLOCK_ONLY_HIGH",
+        "BLOCK_NONE",
+        "OFF"
+      ])
+    })
+  ).optional(),
+  threshold: import_v44.z.enum([
+    "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+    "BLOCK_LOW_AND_ABOVE",
+    "BLOCK_MEDIUM_AND_ABOVE",
+    "BLOCK_ONLY_HIGH",
+    "BLOCK_NONE",
+    "OFF"
+  ]).optional(),
+  /**
+   * Optional. Enables timestamp understanding for audio-only files.
+   *
+   * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
+   */
+  audioTimestamp: import_v44.z.boolean().optional()
+});
+
 // src/google-prepare-tools.ts
 var import_provider3 = require("@ai-sdk/provider");
 function prepareTools({
   tools,
   toolChoice,
-  useSearchGrounding,
-  dynamicRetrievalConfig,
   modelId
 }) {
   var _a;
@@ -348,28 +479,87 @@ function prepareTools({
   const toolWarnings = [];
   const isGemini2 = modelId.includes("gemini-2");
   const supportsDynamicRetrieval = modelId.includes("gemini-1.5-flash") && !modelId.includes("-8b");
-  if (useSearchGrounding) {
+  if (tools == null) {
+    return { tools: void 0, toolConfig: void 0, toolWarnings };
+  }
+  const hasFunctionTools = tools.some((tool) => tool.type === "function");
+  const hasProviderDefinedTools = tools.some(
+    (tool) => tool.type === "provider-defined"
+  );
+  if (hasFunctionTools && hasProviderDefinedTools) {
+    toolWarnings.push({
+      type: "unsupported-tool",
+      tool: tools.find((tool) => tool.type === "function"),
+      details: "Cannot mix function tools with provider-defined tools in the same request. Please use either function tools or provider-defined tools, but not both."
+    });
+  }
+  if (hasProviderDefinedTools) {
+    const googleTools2 = {};
+    const providerDefinedTools = tools.filter(
+      (tool) => tool.type === "provider-defined"
+    );
+    providerDefinedTools.forEach((tool) => {
+      switch (tool.id) {
+        case "google.google_search":
+          if (isGemini2) {
+            googleTools2.googleSearch = {};
+          } else if (supportsDynamicRetrieval) {
+            googleTools2.googleSearchRetrieval = {
+              dynamicRetrievalConfig: {
+                mode: tool.args.mode,
+                dynamicThreshold: tool.args.dynamicThreshold
+              }
+            };
+          } else {
+            googleTools2.googleSearchRetrieval = {};
+          }
+          break;
+        case "google.url_context":
+          if (isGemini2) {
+            googleTools2.urlContext = {};
+          } else {
+            toolWarnings.push({
+              type: "unsupported-tool",
+              tool,
+              details: "The URL context tool is not supported with other Gemini models than Gemini 2."
+            });
+          }
+          break;
+        case "google.code_execution":
+          if (isGemini2) {
+            googleTools2.codeExecution = {};
+          } else {
+            toolWarnings.push({
+              type: "unsupported-tool",
+              tool,
+              details: "The code execution tools is not supported with other Gemini models than Gemini 2."
+            });
+          }
+          break;
+        default:
+          toolWarnings.push({ type: "unsupported-tool", tool });
+          break;
+      }
+    });
     return {
-      tools: isGemini2 ? { googleSearch: {} } : {
-        googleSearchRetrieval: !supportsDynamicRetrieval || !dynamicRetrievalConfig ? {} : { dynamicRetrievalConfig }
-      },
+      tools: Object.keys(googleTools2).length > 0 ? googleTools2 : void 0,
       toolConfig: void 0,
       toolWarnings
     };
   }
-  if (tools == null) {
-    return { tools: void 0, toolConfig: void 0, toolWarnings };
-  }
   const functionDeclarations = [];
   for (const tool of tools) {
-    if (tool.type === "provider-defined") {
-      toolWarnings.push({ type: "unsupported-tool", tool });
-    } else {
-      functionDeclarations.push({
-        name: tool.name,
-        description: (_a = tool.description) != null ? _a : "",
-        parameters: convertJSONSchemaToOpenAPISchema(tool.parameters)
-      });
+    switch (tool.type) {
+      case "function":
+        functionDeclarations.push({
+          name: tool.name,
+          description: (_a = tool.description) != null ? _a : "",
+          parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema)
+        });
+        break;
+      default:
+        toolWarnings.push({ type: "unsupported-tool", tool });
+        break;
     }
   }
   if (toolChoice == null) {
@@ -446,23 +636,80 @@ function mapGoogleGenerativeAIFinishReason({
   }
 }
 
+// src/tool/google-search.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_v45 = require("zod/v4");
+var groundingChunkSchema = import_v45.z.object({
+  web: import_v45.z.object({ uri: import_v45.z.string(), title: import_v45.z.string() }).nullish(),
+  retrievedContext: import_v45.z.object({ uri: import_v45.z.string(), title: import_v45.z.string() }).nullish()
+});
+var groundingMetadataSchema = import_v45.z.object({
+  webSearchQueries: import_v45.z.array(import_v45.z.string()).nullish(),
+  retrievalQueries: import_v45.z.array(import_v45.z.string()).nullish(),
+  searchEntryPoint: import_v45.z.object({ renderedContent: import_v45.z.string() }).nullish(),
+  groundingChunks: import_v45.z.array(groundingChunkSchema).nullish(),
+  groundingSupports: import_v45.z.array(
+    import_v45.z.object({
+      segment: import_v45.z.object({
+        startIndex: import_v45.z.number().nullish(),
+        endIndex: import_v45.z.number().nullish(),
+        text: import_v45.z.string().nullish()
+      }),
+      segment_text: import_v45.z.string().nullish(),
+      groundingChunkIndices: import_v45.z.array(import_v45.z.number()).nullish(),
+      supportChunkIndices: import_v45.z.array(import_v45.z.number()).nullish(),
+      confidenceScores: import_v45.z.array(import_v45.z.number()).nullish(),
+      confidenceScore: import_v45.z.array(import_v45.z.number()).nullish()
+    })
+  ).nullish(),
+  retrievalMetadata: import_v45.z.union([
+    import_v45.z.object({
+      webDynamicRetrievalScore: import_v45.z.number()
+    }),
+    import_v45.z.object({})
+  ]).nullish()
+});
+var googleSearch = (0, import_provider_utils4.createProviderDefinedToolFactory)({
+  id: "google.google_search",
+  name: "google_search",
+  inputSchema: import_v45.z.object({
+    mode: import_v45.z.enum(["MODE_DYNAMIC", "MODE_UNSPECIFIED"]).default("MODE_UNSPECIFIED"),
+    dynamicThreshold: import_v45.z.number().default(1)
+  })
+});
+
+// src/tool/url-context.ts
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_v46 = require("zod/v4");
+var urlMetadataSchema = import_v46.z.object({
+  retrievedUrl: import_v46.z.string(),
+  urlRetrievalStatus: import_v46.z.string()
+});
+var urlContextMetadataSchema = import_v46.z.object({
+  urlMetadata: import_v46.z.array(urlMetadataSchema)
+});
+var urlContext = (0, import_provider_utils5.createProviderDefinedToolFactory)({
+  id: "google.url_context",
+  name: "url_context",
+  inputSchema: import_v46.z.object({})
+});
+
 // src/google-generative-ai-language-model.ts
 var GoogleGenerativeAILanguageModel = class {
-  constructor(modelId, settings, config) {
+  constructor(modelId, config) {
     this.specificationVersion = "v2";
-    this.defaultObjectGenerationMode = "json";
-    this.supportsImageUrls = false;
+    var _a;
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
-  }
-  get supportsStructuredOutputs() {
-    var _a;
-    return (_a = this.settings.structuredOutputs) != null ? _a : true;
+    this.generateId = (_a = config.generateId) != null ? _a : import_provider_utils6.generateId;
   }
   get provider() {
     return this.config.provider;
   }
+  get supportedUrls() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+  }
   async getArgs({
     prompt,
     maxOutputTokens,
@@ -478,23 +725,31 @@ var GoogleGenerativeAILanguageModel = class {
     toolChoice,
     providerOptions
   }) {
-    var _a;
+    var _a, _b;
     const warnings = [];
-    const googleOptions = (0, import_provider_utils4.parseProviderOptions)({
+    const googleOptions = await (0, import_provider_utils6.parseProviderOptions)({
       provider: "google",
       providerOptions,
-      schema: googleGenerativeAIProviderOptionsSchema
+      schema: googleGenerativeAIProviderOptions
     });
-    const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(prompt);
+    if (((_a = googleOptions == null ? void 0 : googleOptions.thinkingConfig) == null ? void 0 : _a.includeThoughts) === true && !this.config.provider.startsWith("google.vertex.")) {
+      warnings.push({
+        type: "other",
+        message: `The 'includeThoughts' option is only supported with the Google Vertex provider and might not be supported or could behave unexpectedly with the current Google provider (${this.config.provider}).`
+      });
+    }
+    const isGemmaModel = this.modelId.toLowerCase().startsWith("gemma-");
+    const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(
+      prompt,
+      { isGemmaModel }
+    );
     const {
-      tools: googleTools,
+      tools: googleTools2,
       toolConfig: googleToolConfig,
       toolWarnings
     } = prepareTools({
       tools,
       toolChoice,
-      useSearchGrounding: (_a = this.settings.useSearchGrounding) != null ? _a : false,
-      dynamicRetrievalConfig: this.settings.dynamicRetrievalConfig,
       modelId: this.modelId
     });
     return {
@@ -513,62 +768,89 @@ var GoogleGenerativeAILanguageModel = class {
           responseMimeType: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? "application/json" : void 0,
           responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
           // so this is needed as an escape hatch:
-          this.supportsStructuredOutputs ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
-          ...this.settings.audioTimestamp && {
-            audioTimestamp: this.settings.audioTimestamp
+          // TODO convert into provider option
+          ((_b = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _b : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
+          ...(googleOptions == null ? void 0 : googleOptions.audioTimestamp) && {
+            audioTimestamp: googleOptions.audioTimestamp
           },
           // provider options:
-          responseModalities: googleOptions == null ? void 0 : googleOptions.responseModalities
+          responseModalities: googleOptions == null ? void 0 : googleOptions.responseModalities,
+          thinkingConfig: googleOptions == null ? void 0 : googleOptions.thinkingConfig
         },
         contents,
-        systemInstruction,
-        safetySettings: this.settings.safetySettings,
-        tools: googleTools,
+        systemInstruction: isGemmaModel ? void 0 : systemInstruction,
+        safetySettings: googleOptions == null ? void 0 : googleOptions.safetySettings,
+        tools: googleTools2,
         toolConfig: googleToolConfig,
-        cachedContent: this.settings.cachedContent
+        cachedContent: googleOptions == null ? void 0 : googleOptions.cachedContent
       },
       warnings: [...warnings, ...toolWarnings]
     };
   }
-  supportsUrl(url) {
-    return this.config.isSupportedUrl(url);
-  }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
     const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
-    const mergedHeaders = (0, import_provider_utils4.combineHeaders)(
-      await (0, import_provider_utils4.resolve)(this.config.headers),
+    const mergedHeaders = (0, import_provider_utils6.combineHeaders)(
+      await (0, import_provider_utils6.resolve)(this.config.headers),
       options.headers
     );
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils4.postJsonToApi)({
+    } = await (0, import_provider_utils6.postJsonToApi)({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:generateContent`,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(responseSchema),
+      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(responseSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     const candidate = response.candidates[0];
     const content = [];
-    const parts = candidate.content == null || typeof candidate.content !== "object" || !("parts" in candidate.content) ? [] : (_a = candidate.content.parts) != null ? _a : [];
+    const parts = (_b = (_a = candidate.content) == null ? void 0 : _a.parts) != null ? _b : [];
+    const usageMetadata = response.usageMetadata;
+    let lastCodeExecutionToolCallId;
     for (const part of parts) {
-      if ("text" in part && part.text.length > 0) {
-        content.push({ type: "text", text: part.text });
+      if ("executableCode" in part && ((_c = part.executableCode) == null ? void 0 : _c.code)) {
+        const toolCallId = this.config.generateId();
+        lastCodeExecutionToolCallId = toolCallId;
+        content.push({
+          type: "tool-call",
+          toolCallId,
+          toolName: "code_execution",
+          input: JSON.stringify(part.executableCode),
+          providerExecuted: true
+        });
+      } else if ("codeExecutionResult" in part && part.codeExecutionResult) {
+        content.push({
+          type: "tool-result",
+          // Assumes a result directly follows its corresponding call part.
+          toolCallId: lastCodeExecutionToolCallId,
+          toolName: "code_execution",
+          result: {
+            outcome: part.codeExecutionResult.outcome,
+            output: part.codeExecutionResult.output
+          },
+          providerExecuted: true
+        });
+        lastCodeExecutionToolCallId = void 0;
+      } else if ("text" in part && part.text != null && part.text.length > 0) {
+        if (part.thought === true) {
+          content.push({ type: "reasoning", text: part.text });
+        } else {
+          content.push({ type: "text", text: part.text });
+        }
       } else if ("functionCall" in part) {
         content.push({
           type: "tool-call",
-          toolCallType: "function",
           toolCallId: this.config.generateId(),
           toolName: part.functionCall.name,
-          args: JSON.stringify(part.functionCall.args)
+          input: JSON.stringify(part.functionCall.args)
         });
       } else if ("inlineData" in part) {
         content.push({
@@ -578,14 +860,13 @@ var GoogleGenerativeAILanguageModel = class {
         });
       }
     }
-    const sources = (_b = extractSources({
+    const sources = (_d = extractSources({
       groundingMetadata: candidate.groundingMetadata,
       generateId: this.config.generateId
-    })) != null ? _b : [];
+    })) != null ? _d : [];
     for (const source of sources) {
       content.push(source);
     }
-    const usageMetadata = response.usageMetadata;
     return {
       content,
       finishReason: mapGoogleGenerativeAIFinishReason({
@@ -593,14 +874,19 @@ var GoogleGenerativeAILanguageModel = class {
         hasToolCalls: content.some((part) => part.type === "tool-call")
       }),
       usage: {
-        inputTokens: (_c = usageMetadata == null ? void 0 : usageMetadata.promptTokenCount) != null ? _c : void 0,
-        outputTokens: (_d = usageMetadata == null ? void 0 : usageMetadata.candidatesTokenCount) != null ? _d : void 0
+        inputTokens: (_e = usageMetadata == null ? void 0 : usageMetadata.promptTokenCount) != null ? _e : void 0,
+        outputTokens: (_f = usageMetadata == null ? void 0 : usageMetadata.candidatesTokenCount) != null ? _f : void 0,
+        totalTokens: (_g = usageMetadata == null ? void 0 : usageMetadata.totalTokenCount) != null ? _g : void 0,
+        reasoningTokens: (_h = usageMetadata == null ? void 0 : usageMetadata.thoughtsTokenCount) != null ? _h : void 0,
+        cachedInputTokens: (_i = usageMetadata == null ? void 0 : usageMetadata.cachedContentTokenCount) != null ? _i : void 0
       },
       warnings,
       providerMetadata: {
         google: {
-          groundingMetadata: (_e = candidate.groundingMetadata) != null ? _e : null,
-          safetyRatings: (_f = candidate.safetyRatings) != null ? _f : null
+          groundingMetadata: (_j = candidate.groundingMetadata) != null ? _j : null,
+          urlContextMetadata: (_k = candidate.urlContextMetadata) != null ? _k : null,
+          safetyRatings: (_l = candidate.safetyRatings) != null ? _l : null,
+          usageMetadata: usageMetadata != null ? usageMetadata : null
         }
       },
       request: { body },
@@ -614,29 +900,35 @@ var GoogleGenerativeAILanguageModel = class {
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
-    const headers = (0, import_provider_utils4.combineHeaders)(
-      await (0, import_provider_utils4.resolve)(this.config.headers),
+    const headers = (0, import_provider_utils6.combineHeaders)(
+      await (0, import_provider_utils6.resolve)(this.config.headers),
       options.headers
     );
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils6.postJsonToApi)({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:streamGenerateContent?alt=sse`,
       headers,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createEventSourceResponseHandler)(chunkSchema),
+      successfulResponseHandler: (0, import_provider_utils6.createEventSourceResponseHandler)(chunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     let finishReason = "unknown";
     const usage = {
       inputTokens: void 0,
-      outputTokens: void 0
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let providerMetadata = void 0;
-    const generateId2 = this.config.generateId;
+    const generateId3 = this.config.generateId;
     let hasToolCalls = false;
+    let currentTextBlockId = null;
+    let currentReasoningBlockId = null;
+    let blockCounter = 0;
+    const emittedSourceUrls = /* @__PURE__ */ new Set();
+    let lastCodeExecutionToolCallId;
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -644,7 +936,10 @@ var GoogleGenerativeAILanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+            if (options.includeRawChunks) {
+              controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
+            }
             if (!chunk.success) {
               controller.enqueue({ type: "error", error: chunk.error });
               return;
@@ -654,16 +949,99 @@ var GoogleGenerativeAILanguageModel = class {
             if (usageMetadata != null) {
               usage.inputTokens = (_a = usageMetadata.promptTokenCount) != null ? _a : void 0;
               usage.outputTokens = (_b = usageMetadata.candidatesTokenCount) != null ? _b : void 0;
+              usage.totalTokens = (_c = usageMetadata.totalTokenCount) != null ? _c : void 0;
+              usage.reasoningTokens = (_d = usageMetadata.thoughtsTokenCount) != null ? _d : void 0;
+              usage.cachedInputTokens = (_e = usageMetadata.cachedContentTokenCount) != null ? _e : void 0;
             }
-            const candidate = (_c = value.candidates) == null ? void 0 : _c[0];
+            const candidate = (_f = value.candidates) == null ? void 0 : _f[0];
             if (candidate == null) {
               return;
             }
             const content = candidate.content;
+            const sources = extractSources({
+              groundingMetadata: candidate.groundingMetadata,
+              generateId: generateId3
+            });
+            if (sources != null) {
+              for (const source of sources) {
+                if (source.sourceType === "url" && !emittedSourceUrls.has(source.url)) {
+                  emittedSourceUrls.add(source.url);
+                  controller.enqueue(source);
+                }
+              }
+            }
             if (content != null) {
-              const deltaText = getTextFromParts(content.parts);
-              if (deltaText != null) {
-                controller.enqueue(deltaText);
+              const parts = (_g = content.parts) != null ? _g : [];
+              for (const part of parts) {
+                if ("executableCode" in part && ((_h = part.executableCode) == null ? void 0 : _h.code)) {
+                  const toolCallId = generateId3();
+                  lastCodeExecutionToolCallId = toolCallId;
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId,
+                    toolName: "code_execution",
+                    input: JSON.stringify(part.executableCode),
+                    providerExecuted: true
+                  });
+                  hasToolCalls = true;
+                } else if ("codeExecutionResult" in part && part.codeExecutionResult) {
+                  const toolCallId = lastCodeExecutionToolCallId;
+                  if (toolCallId) {
+                    controller.enqueue({
+                      type: "tool-result",
+                      toolCallId,
+                      toolName: "code_execution",
+                      result: {
+                        outcome: part.codeExecutionResult.outcome,
+                        output: part.codeExecutionResult.output
+                      },
+                      providerExecuted: true
+                    });
+                    lastCodeExecutionToolCallId = void 0;
+                  }
+                } else if ("text" in part && part.text != null && part.text.length > 0) {
+                  if (part.thought === true) {
+                    if (currentTextBlockId !== null) {
+                      controller.enqueue({
+                        type: "text-end",
+                        id: currentTextBlockId
+                      });
+                      currentTextBlockId = null;
+                    }
+                    if (currentReasoningBlockId === null) {
+                      currentReasoningBlockId = String(blockCounter++);
+                      controller.enqueue({
+                        type: "reasoning-start",
+                        id: currentReasoningBlockId
+                      });
+                    }
+                    controller.enqueue({
+                      type: "reasoning-delta",
+                      id: currentReasoningBlockId,
+                      delta: part.text
+                    });
+                  } else {
+                    if (currentReasoningBlockId !== null) {
+                      controller.enqueue({
+                        type: "reasoning-end",
+                        id: currentReasoningBlockId
+                      });
+                      currentReasoningBlockId = null;
+                    }
+                    if (currentTextBlockId === null) {
+                      currentTextBlockId = String(blockCounter++);
+                      controller.enqueue({
+                        type: "text-start",
+                        id: currentTextBlockId
+                      });
+                    }
+                    controller.enqueue({
+                      type: "text-delta",
+                      id: currentTextBlockId,
+                      delta: part.text
+                    });
+                  }
+                }
               }
               const inlineDataParts = getInlineDataParts(content.parts);
               if (inlineDataParts != null) {
@@ -677,23 +1055,29 @@ var GoogleGenerativeAILanguageModel = class {
               }
               const toolCallDeltas = getToolCallsFromParts({
                 parts: content.parts,
-                generateId: generateId2
+                generateId: generateId3
               });
               if (toolCallDeltas != null) {
                 for (const toolCall of toolCallDeltas) {
                   controller.enqueue({
-                    type: "tool-call-delta",
-                    toolCallType: "function",
-                    toolCallId: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    argsTextDelta: toolCall.args
+                    type: "tool-input-start",
+                    id: toolCall.toolCallId,
+                    toolName: toolCall.toolName
+                  });
+                  controller.enqueue({
+                    type: "tool-input-delta",
+                    id: toolCall.toolCallId,
+                    delta: toolCall.args
+                  });
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: toolCall.toolCallId
                   });
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallType: "function",
                     toolCallId: toolCall.toolCallId,
                     toolName: toolCall.toolName,
-                    args: toolCall.args
+                    input: toolCall.args
                   });
                   hasToolCalls = true;
                 }
@@ -704,22 +1088,31 @@ var GoogleGenerativeAILanguageModel = class {
                 finishReason: candidate.finishReason,
                 hasToolCalls
               });
-              const sources = (_d = extractSources({
-                groundingMetadata: candidate.groundingMetadata,
-                generateId: generateId2
-              })) != null ? _d : [];
-              for (const source of sources) {
-                controller.enqueue(source);
-              }
               providerMetadata = {
                 google: {
-                  groundingMetadata: (_e = candidate.groundingMetadata) != null ? _e : null,
-                  safetyRatings: (_f = candidate.safetyRatings) != null ? _f : null
+                  groundingMetadata: (_i = candidate.groundingMetadata) != null ? _i : null,
+                  urlContextMetadata: (_j = candidate.urlContextMetadata) != null ? _j : null,
+                  safetyRatings: (_k = candidate.safetyRatings) != null ? _k : null
                 }
               };
+              if (usageMetadata != null) {
+                providerMetadata.google.usageMetadata = usageMetadata;
+              }
             }
           },
           flush(controller) {
+            if (currentTextBlockId !== null) {
+              controller.enqueue({
+                type: "text-end",
+                id: currentTextBlockId
+              });
+            }
+            if (currentReasoningBlockId !== null) {
+              controller.enqueue({
+                type: "reasoning-end",
+                id: currentReasoningBlockId
+              });
+            }
             controller.enqueue({
               type: "finish",
               finishReason,
@@ -736,26 +1129,18 @@ var GoogleGenerativeAILanguageModel = class {
 };
 function getToolCallsFromParts({
   parts,
-  generateId: generateId2
+  generateId: generateId3
 }) {
   const functionCallParts = parts == null ? void 0 : parts.filter(
     (part) => "functionCall" in part
   );
   return functionCallParts == null || functionCallParts.length === 0 ? void 0 : functionCallParts.map((part) => ({
     type: "tool-call",
-    toolCallType: "function",
-    toolCallId: generateId2(),
+    toolCallId: generateId3(),
     toolName: part.functionCall.name,
     args: JSON.stringify(part.functionCall.args)
   }));
 }
-function getTextFromParts(parts) {
-  const textParts = parts == null ? void 0 : parts.filter((part) => "text" in part);
-  return textParts == null || textParts.length === 0 ? void 0 : {
-    type: "text",
-    text: textParts.map((part) => part.text).join("")
-  };
-}
 function getInlineDataParts(parts) {
   return parts == null ? void 0 : parts.filter(
     (part) => "inlineData" in part
@@ -763,7 +1148,7 @@ function getInlineDataParts(parts) {
 }
 function extractSources({
   groundingMetadata,
-  generateId: generateId2
+  generateId: generateId3
 }) {
   var _a;
   return (_a = groundingMetadata == null ? void 0 : groundingMetadata.groundingChunks) == null ? void 0 : _a.filter(
@@ -771,146 +1156,273 @@ function extractSources({
   ).map((chunk) => ({
     type: "source",
     sourceType: "url",
-    id: generateId2(),
+    id: generateId3(),
     url: chunk.web.uri,
     title: chunk.web.title
   }));
 }
-var contentSchema = import_zod3.z.object({
-  role: import_zod3.z.string(),
-  parts: import_zod3.z.array(
-    import_zod3.z.union([
-      import_zod3.z.object({
-        text: import_zod3.z.string()
-      }),
-      import_zod3.z.object({
-        functionCall: import_zod3.z.object({
-          name: import_zod3.z.string(),
-          args: import_zod3.z.unknown()
+var contentSchema = import_v47.z.object({
+  parts: import_v47.z.array(
+    import_v47.z.union([
+      // note: order matters since text can be fully empty
+      import_v47.z.object({
+        functionCall: import_v47.z.object({
+          name: import_v47.z.string(),
+          args: import_v47.z.unknown()
         })
       }),
-      import_zod3.z.object({
-        inlineData: import_zod3.z.object({
-          mimeType: import_zod3.z.string(),
-          data: import_zod3.z.string()
+      import_v47.z.object({
+        inlineData: import_v47.z.object({
+          mimeType: import_v47.z.string(),
+          data: import_v47.z.string()
         })
+      }),
+      import_v47.z.object({
+        executableCode: import_v47.z.object({
+          language: import_v47.z.string(),
+          code: import_v47.z.string()
+        }).nullish(),
+        codeExecutionResult: import_v47.z.object({
+          outcome: import_v47.z.string(),
+          output: import_v47.z.string()
+        }).nullish(),
+        text: import_v47.z.string().nullish(),
+        thought: import_v47.z.boolean().nullish()
       })
     ])
   ).nullish()
 });
-var groundingChunkSchema = import_zod3.z.object({
-  web: import_zod3.z.object({ uri: import_zod3.z.string(), title: import_zod3.z.string() }).nullish(),
-  retrievedContext: import_zod3.z.object({ uri: import_zod3.z.string(), title: import_zod3.z.string() }).nullish()
+var safetyRatingSchema = import_v47.z.object({
+  category: import_v47.z.string().nullish(),
+  probability: import_v47.z.string().nullish(),
+  probabilityScore: import_v47.z.number().nullish(),
+  severity: import_v47.z.string().nullish(),
+  severityScore: import_v47.z.number().nullish(),
+  blocked: import_v47.z.boolean().nullish()
 });
-var groundingMetadataSchema = import_zod3.z.object({
-  webSearchQueries: import_zod3.z.array(import_zod3.z.string()).nullish(),
-  retrievalQueries: import_zod3.z.array(import_zod3.z.string()).nullish(),
-  searchEntryPoint: import_zod3.z.object({ renderedContent: import_zod3.z.string() }).nullish(),
-  groundingChunks: import_zod3.z.array(groundingChunkSchema).nullish(),
-  groundingSupports: import_zod3.z.array(
-    import_zod3.z.object({
-      segment: import_zod3.z.object({
-        startIndex: import_zod3.z.number().nullish(),
-        endIndex: import_zod3.z.number().nullish(),
-        text: import_zod3.z.string().nullish()
-      }),
-      segment_text: import_zod3.z.string().nullish(),
-      groundingChunkIndices: import_zod3.z.array(import_zod3.z.number()).nullish(),
-      supportChunkIndices: import_zod3.z.array(import_zod3.z.number()).nullish(),
-      confidenceScores: import_zod3.z.array(import_zod3.z.number()).nullish(),
-      confidenceScore: import_zod3.z.array(import_zod3.z.number()).nullish()
-    })
-  ).nullish(),
-  retrievalMetadata: import_zod3.z.union([
-    import_zod3.z.object({
-      webDynamicRetrievalScore: import_zod3.z.number()
-    }),
-    import_zod3.z.object({})
-  ]).nullish()
-});
-var safetyRatingSchema = import_zod3.z.object({
-  category: import_zod3.z.string(),
-  probability: import_zod3.z.string(),
-  probabilityScore: import_zod3.z.number().nullish(),
-  severity: import_zod3.z.string().nullish(),
-  severityScore: import_zod3.z.number().nullish(),
-  blocked: import_zod3.z.boolean().nullish()
+var usageSchema = import_v47.z.object({
+  cachedContentTokenCount: import_v47.z.number().nullish(),
+  thoughtsTokenCount: import_v47.z.number().nullish(),
+  promptTokenCount: import_v47.z.number().nullish(),
+  candidatesTokenCount: import_v47.z.number().nullish(),
+  totalTokenCount: import_v47.z.number().nullish()
 });
-var responseSchema = import_zod3.z.object({
-  candidates: import_zod3.z.array(
-    import_zod3.z.object({
-      content: contentSchema.nullish().or(import_zod3.z.object({}).strict()),
-      finishReason: import_zod3.z.string().nullish(),
-      safetyRatings: import_zod3.z.array(safetyRatingSchema).nullish(),
-      groundingMetadata: groundingMetadataSchema.nullish()
+var responseSchema = import_v47.z.object({
+  candidates: import_v47.z.array(
+    import_v47.z.object({
+      content: contentSchema.nullish().or(import_v47.z.object({}).strict()),
+      finishReason: import_v47.z.string().nullish(),
+      safetyRatings: import_v47.z.array(safetyRatingSchema).nullish(),
+      groundingMetadata: groundingMetadataSchema.nullish(),
+      urlContextMetadata: urlContextMetadataSchema.nullish()
     })
   ),
-  usageMetadata: import_zod3.z.object({
-    promptTokenCount: import_zod3.z.number().nullish(),
-    candidatesTokenCount: import_zod3.z.number().nullish(),
-    totalTokenCount: import_zod3.z.number().nullish()
-  }).nullish()
+  usageMetadata: usageSchema.nullish()
 });
-var chunkSchema = import_zod3.z.object({
-  candidates: import_zod3.z.array(
-    import_zod3.z.object({
+var chunkSchema = import_v47.z.object({
+  candidates: import_v47.z.array(
+    import_v47.z.object({
       content: contentSchema.nullish(),
-      finishReason: import_zod3.z.string().nullish(),
-      safetyRatings: import_zod3.z.array(safetyRatingSchema).nullish(),
-      groundingMetadata: groundingMetadataSchema.nullish()
+      finishReason: import_v47.z.string().nullish(),
+      safetyRatings: import_v47.z.array(safetyRatingSchema).nullish(),
+      groundingMetadata: groundingMetadataSchema.nullish(),
+      urlContextMetadata: urlContextMetadataSchema.nullish()
     })
   ).nullish(),
-  usageMetadata: import_zod3.z.object({
-    promptTokenCount: import_zod3.z.number().nullish(),
-    candidatesTokenCount: import_zod3.z.number().nullish(),
-    totalTokenCount: import_zod3.z.number().nullish()
-  }).nullish()
+  usageMetadata: usageSchema.nullish()
 });
-var googleGenerativeAIProviderOptionsSchema = import_zod3.z.object({
-  responseModalities: import_zod3.z.array(import_zod3.z.enum(["TEXT", "IMAGE"])).nullish()
+
+// src/tool/code-execution.ts
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
+var import_v48 = require("zod/v4");
+var codeExecution = (0, import_provider_utils7.createProviderDefinedToolFactoryWithOutputSchema)({
+  id: "google.code_execution",
+  name: "code_execution",
+  inputSchema: import_v48.z.object({
+    language: import_v48.z.string().describe("The programming language of the code."),
+    code: import_v48.z.string().describe("The code to be executed.")
+  }),
+  outputSchema: import_v48.z.object({
+    outcome: import_v48.z.string().describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
+    output: import_v48.z.string().describe("The output from the code execution.")
+  })
 });
 
-// src/google-supported-file-url.ts
-function isSupportedFileUrl(url) {
-  return url.toString().startsWith("https://generativelanguage.googleapis.com/v1beta/files/");
-}
+// src/google-tools.ts
+var googleTools = {
+  /**
+   * Creates a Google search tool that gives Google direct access to real-time web content.
+   * Must have name "google_search".
+   */
+  googleSearch,
+  /**
+   * Creates a URL context tool that gives Google direct access to real-time web content.
+   * Must have name "url_context".
+   */
+  urlContext,
+  /**
+   * A tool that enables the model to generate and run Python code.
+   * Must have name "code_execution".
+   *
+   * @note Ensure the selected model supports Code Execution.
+   * Multi-tool usage with the code execution tool is typically compatible with Gemini >=2 models.
+   *
+   * @see https://ai.google.dev/gemini-api/docs/code-execution (Google AI)
+   * @see https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/code-execution-api (Vertex AI)
+   */
+  codeExecution
+};
+
+// src/google-generative-ai-image-model.ts
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
+var import_v49 = require("zod/v4");
+var GoogleGenerativeAIImageModel = class {
+  constructor(modelId, settings, config) {
+    this.modelId = modelId;
+    this.settings = settings;
+    this.config = config;
+    this.specificationVersion = "v2";
+  }
+  get maxImagesPerCall() {
+    var _a;
+    return (_a = this.settings.maxImagesPerCall) != null ? _a : 4;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doGenerate(options) {
+    var _a, _b, _c;
+    const {
+      prompt,
+      n = 1,
+      size = "1024x1024",
+      aspectRatio = "1:1",
+      seed,
+      providerOptions,
+      headers,
+      abortSignal
+    } = options;
+    const warnings = [];
+    if (size != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "size",
+        details: "This model does not support the `size` option. Use `aspectRatio` instead."
+      });
+    }
+    if (seed != null) {
+      warnings.push({
+        type: "unsupported-setting",
+        setting: "seed",
+        details: "This model does not support the `seed` option through this provider."
+      });
+    }
+    const googleOptions = await (0, import_provider_utils8.parseProviderOptions)({
+      provider: "google",
+      providerOptions,
+      schema: googleImageProviderOptionsSchema
+    });
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const parameters = {
+      sampleCount: n
+    };
+    if (aspectRatio != null) {
+      parameters.aspectRatio = aspectRatio;
+    }
+    if (googleOptions) {
+      Object.assign(parameters, googleOptions);
+    }
+    const body = {
+      instances: [{ prompt }],
+      parameters
+    };
+    const { responseHeaders, value: response } = await (0, import_provider_utils8.postJsonToApi)({
+      url: `${this.config.baseURL}/models/${this.modelId}:predict`,
+      headers: (0, import_provider_utils8.combineHeaders)(await (0, import_provider_utils8.resolve)(this.config.headers), headers),
+      body,
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils8.createJsonResponseHandler)(
+        googleImageResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      images: response.predictions.map(
+        (p) => p.bytesBase64Encoded
+      ),
+      warnings: warnings != null ? warnings : [],
+      providerMetadata: {
+        google: {
+          images: response.predictions.map((prediction) => ({
+            // Add any prediction-specific metadata here
+          }))
+        }
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders
+      }
+    };
+  }
+};
+var googleImageResponseSchema = import_v49.z.object({
+  predictions: import_v49.z.array(import_v49.z.object({ bytesBase64Encoded: import_v49.z.string() })).default([])
+});
+var googleImageProviderOptionsSchema = import_v49.z.object({
+  personGeneration: import_v49.z.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+  aspectRatio: import_v49.z.enum(["1:1", "3:4", "4:3", "9:16", "16:9"]).nullish()
+});
 
 // src/google-provider.ts
 function createGoogleGenerativeAI(options = {}) {
   var _a;
-  const baseURL = (_a = (0, import_provider_utils5.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
+  const baseURL = (_a = (0, import_provider_utils9.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
   const getHeaders = () => ({
-    "x-goog-api-key": (0, import_provider_utils5.loadApiKey)({
+    "x-goog-api-key": (0, import_provider_utils9.loadApiKey)({
       apiKey: options.apiKey,
       environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
       description: "Google Generative AI"
     }),
     ...options.headers
   });
-  const createChatModel = (modelId, settings = {}) => {
+  const createChatModel = (modelId) => {
     var _a2;
-    return new GoogleGenerativeAILanguageModel(modelId, settings, {
+    return new GoogleGenerativeAILanguageModel(modelId, {
       provider: "google.generative-ai",
       baseURL,
       headers: getHeaders,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils5.generateId,
-      isSupportedUrl: isSupportedFileUrl,
+      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils9.generateId,
+      supportedUrls: () => ({
+        "*": [
+          // Only allow requests to the Google Generative Language "files" endpoint
+          // e.g. https://generativelanguage.googleapis.com/v1beta/files/...
+          new RegExp(`^${baseURL}/files/.*$`)
+        ]
+      }),
       fetch: options.fetch
     });
   };
-  const createEmbeddingModel = (modelId, settings = {}) => new GoogleGenerativeAIEmbeddingModel(modelId, settings, {
+  const createEmbeddingModel = (modelId) => new GoogleGenerativeAIEmbeddingModel(modelId, {
     provider: "google.generative-ai",
     baseURL,
     headers: getHeaders,
     fetch: options.fetch
   });
-  const provider = function(modelId, settings) {
+  const createImageModel = (modelId, settings = {}) => new GoogleGenerativeAIImageModel(modelId, settings, {
+    provider: "google.generative-ai",
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const provider = function(modelId) {
     if (new.target) {
       throw new Error(
         "The Google Generative AI model function cannot be called with the new keyword."
       );
     }
-    return createChatModel(modelId, settings);
+    return createChatModel(modelId);
   };
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
@@ -918,9 +1430,9 @@ function createGoogleGenerativeAI(options = {}) {
   provider.embedding = createEmbeddingModel;
   provider.textEmbedding = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
-  provider.imageModel = (modelId) => {
-    throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
-  };
+  provider.image = createImageModel;
+  provider.imageModel = createImageModel;
+  provider.tools = googleTools;
   return provider;
 }
 var google = createGoogleGenerativeAI();