@ai-sdk/google 2.0.17 → 2.0.19

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -27,62 +37,71 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/google-provider.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
 
 // src/version.ts
-var VERSION = true ? "2.0.17" : "0.0.0-test";
+var VERSION = true ? "2.0.19" : "0.0.0-test";
 
 // 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_v43 = require("zod/v4");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var z3 = __toESM(require("zod/v4"));
 
 // src/google-error.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
-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 z = __toESM(require("zod/v4"));
+var googleErrorDataSchema = (0, import_provider_utils.lazySchema)(
+  () => (0, import_provider_utils.zodSchema)(
+    z.object({
+      error: z.object({
+        code: z.number().nullable(),
+        message: z.string(),
+        status: z.string()
+      })
+    })
+  )
+);
 var googleFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
   errorSchema: googleErrorDataSchema,
   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()
-});
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var z2 = __toESM(require("zod/v4"));
+var googleGenerativeAIEmbeddingProviderOptions = (0, import_provider_utils2.lazySchema)(
+  () => (0, import_provider_utils2.zodSchema)(
+    z2.object({
+      /**
+       * Optional. Optional reduced dimension for the output embedding.
+       * If set, excessive values in the output embedding are truncated from the end.
+       */
+      outputDimensionality: z2.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: z2.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 {
@@ -102,7 +121,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    const googleOptions = await (0, import_provider_utils2.parseProviderOptions)({
+    const googleOptions = await (0, import_provider_utils3.parseProviderOptions)({
       provider: "google",
       providerOptions,
       schema: googleGenerativeAIEmbeddingProviderOptions
@@ -115,8 +134,8 @@ var GoogleGenerativeAIEmbeddingModel = class {
         values
       });
     }
-    const mergedHeaders = (0, import_provider_utils2.combineHeaders)(
-      await (0, import_provider_utils2.resolve)(this.config.headers),
+    const mergedHeaders = (0, import_provider_utils3.combineHeaders)(
+      await (0, import_provider_utils3.resolve)(this.config.headers),
       headers
     );
     if (values.length === 1) {
@@ -124,7 +143,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
         responseHeaders: responseHeaders2,
         value: response2,
         rawValue: rawValue2
-      } = await (0, import_provider_utils2.postJsonToApi)({
+      } = await (0, import_provider_utils3.postJsonToApi)({
         url: `${this.config.baseURL}/models/${this.modelId}:embedContent`,
         headers: mergedHeaders,
         body: {
@@ -136,7 +155,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
           taskType: googleOptions == null ? void 0 : googleOptions.taskType
         },
         failedResponseHandler: googleFailedResponseHandler,
-        successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+        successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
           googleGenerativeAISingleEmbeddingResponseSchema
         ),
         abortSignal,
@@ -152,7 +171,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils2.postJsonToApi)({
+    } = await (0, import_provider_utils3.postJsonToApi)({
       url: `${this.config.baseURL}/models/${this.modelId}:batchEmbedContents`,
       headers: mergedHeaders,
       body: {
@@ -164,7 +183,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
         }))
       },
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
         googleGenerativeAITextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -177,16 +196,24 @@ var GoogleGenerativeAIEmbeddingModel = class {
     };
   }
 };
-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()) })
-});
+var googleGenerativeAITextEmbeddingResponseSchema = (0, import_provider_utils3.lazySchema)(
+  () => (0, import_provider_utils3.zodSchema)(
+    z3.object({
+      embeddings: z3.array(z3.object({ values: z3.array(z3.number()) }))
+    })
+  )
+);
+var googleGenerativeAISingleEmbeddingResponseSchema = (0, import_provider_utils3.lazySchema)(
+  () => (0, import_provider_utils3.zodSchema)(
+    z3.object({
+      embedding: z3.object({ values: z3.array(z3.number()) })
+    })
+  )
+);
 
 // src/google-generative-ai-language-model.ts
 var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
+var z5 = __toESM(require("zod/v4"));
 
 // src/convert-json-schema-to-openapi-schema.ts
 function convertJSONSchemaToOpenAPISchema(jsonSchema) {
@@ -211,12 +238,9 @@ function convertJSONSchemaToOpenAPISchema(jsonSchema) {
     enum: enumValues
   } = jsonSchema;
   const result = {};
-  if (description)
-    result.description = description;
-  if (required)
-    result.required = required;
-  if (format)
-    result.format = format;
+  if (description) result.description = description;
+  if (required) result.required = required;
+  if (format) result.format = format;
   if (constValue !== void 0) {
     result.enum = [constValue];
   }
@@ -287,7 +311,7 @@ function isEmptyObjectSchema(jsonSchema) {
 
 // src/convert-to-google-generative-ai-messages.ts
 var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
 function convertToGoogleGenerativeAIMessages(prompt, options) {
   var _a;
   const systemInstructionParts = [];
@@ -325,7 +349,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                 } : {
                   inlineData: {
                     mimeType: mediaType,
-                    data: (0, import_provider_utils3.convertToBase64)(part.data)
+                    data: (0, import_provider_utils4.convertToBase64)(part.data)
                   }
                 }
               );
@@ -370,7 +394,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                 return {
                   inlineData: {
                     mimeType: part.mediaType,
-                    data: (0, import_provider_utils3.convertToBase64)(part.data)
+                    data: (0, import_provider_utils4.convertToBase64)(part.data)
                   }
                 };
               }
@@ -461,72 +485,88 @@ function getModelPath(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([
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var z4 = __toESM(require("zod/v4"));
+var googleGenerativeAIProviderOptions = (0, import_provider_utils5.lazySchema)(
+  () => (0, import_provider_utils5.zodSchema)(
+    z4.object({
+      responseModalities: z4.array(z4.enum(["TEXT", "IMAGE"])).optional(),
+      thinkingConfig: z4.object({
+        thinkingBudget: z4.number().optional(),
+        includeThoughts: z4.boolean().optional()
+      }).optional(),
+      /**
+       * Optional.
+       * The name of the cached content used as context to serve the prediction.
+       * Format: cachedContents/{cachedContent}
+       */
+      cachedContent: z4.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: z4.boolean().optional(),
+      /**
+       * Optional. A list of unique safety settings for blocking unsafe content.
+       */
+      safetySettings: z4.array(
+        z4.object({
+          category: z4.enum([
+            "HARM_CATEGORY_UNSPECIFIED",
+            "HARM_CATEGORY_HATE_SPEECH",
+            "HARM_CATEGORY_DANGEROUS_CONTENT",
+            "HARM_CATEGORY_HARASSMENT",
+            "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+            "HARM_CATEGORY_CIVIC_INTEGRITY"
+          ]),
+          threshold: z4.enum([
+            "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+            "BLOCK_LOW_AND_ABOVE",
+            "BLOCK_MEDIUM_AND_ABOVE",
+            "BLOCK_ONLY_HIGH",
+            "BLOCK_NONE",
+            "OFF"
+          ])
+        })
+      ).optional(),
+      threshold: z4.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: z4.boolean().optional(),
+      /**
+       * Optional. Defines labels used in billing reports. Available on Vertex AI only.
+       *
+       * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/add-labels-to-api-calls
+       */
+      labels: z4.record(z4.string(), z4.string()).optional(),
+      /**
+       * Optional. If specified, the media resolution specified will be used.
+       *
+       * https://ai.google.dev/api/generate-content#MediaResolution
+       */
+      mediaResolution: z4.enum([
+        "MEDIA_RESOLUTION_UNSPECIFIED",
+        "MEDIA_RESOLUTION_LOW",
+        "MEDIA_RESOLUTION_MEDIUM",
+        "MEDIA_RESOLUTION_HIGH"
+      ]).optional()
     })
-  ).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(),
-  /**
-   * Optional. Defines labels used in billing reports. Available on Vertex AI only.
-   *
-   * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/add-labels-to-api-calls
-   */
-  labels: import_v44.z.record(import_v44.z.string(), import_v44.z.string()).optional()
-});
+  )
+);
 
 // src/google-prepare-tools.ts
 var import_provider3 = require("@ai-sdk/provider");
@@ -697,64 +737,6 @@ 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, config) {
@@ -1247,103 +1229,175 @@ function extractSources({
     title: chunk.web.title
   }));
 }
-var contentSchema = import_v47.z.object({
-  parts: import_v47.z.array(
-    import_v47.z.union([
+var getGroundingMetadataSchema = () => z5.object({
+  webSearchQueries: z5.array(z5.string()).nullish(),
+  retrievalQueries: z5.array(z5.string()).nullish(),
+  searchEntryPoint: z5.object({ renderedContent: z5.string() }).nullish(),
+  groundingChunks: z5.array(
+    z5.object({
+      web: z5.object({ uri: z5.string(), title: z5.string() }).nullish(),
+      retrievedContext: z5.object({ uri: z5.string(), title: z5.string() }).nullish()
+    })
+  ).nullish(),
+  groundingSupports: z5.array(
+    z5.object({
+      segment: z5.object({
+        startIndex: z5.number().nullish(),
+        endIndex: z5.number().nullish(),
+        text: z5.string().nullish()
+      }),
+      segment_text: z5.string().nullish(),
+      groundingChunkIndices: z5.array(z5.number()).nullish(),
+      supportChunkIndices: z5.array(z5.number()).nullish(),
+      confidenceScores: z5.array(z5.number()).nullish(),
+      confidenceScore: z5.array(z5.number()).nullish()
+    })
+  ).nullish(),
+  retrievalMetadata: z5.union([
+    z5.object({
+      webDynamicRetrievalScore: z5.number()
+    }),
+    z5.object({})
+  ]).nullish()
+});
+var getContentSchema = () => z5.object({
+  parts: z5.array(
+    z5.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()
+      z5.object({
+        functionCall: z5.object({
+          name: z5.string(),
+          args: z5.unknown()
         }),
-        thoughtSignature: import_v47.z.string().nullish()
+        thoughtSignature: z5.string().nullish()
       }),
-      import_v47.z.object({
-        inlineData: import_v47.z.object({
-          mimeType: import_v47.z.string(),
-          data: import_v47.z.string()
+      z5.object({
+        inlineData: z5.object({
+          mimeType: z5.string(),
+          data: z5.string()
         })
       }),
-      import_v47.z.object({
-        executableCode: import_v47.z.object({
-          language: import_v47.z.string(),
-          code: import_v47.z.string()
+      z5.object({
+        executableCode: z5.object({
+          language: z5.string(),
+          code: z5.string()
         }).nullish(),
-        codeExecutionResult: import_v47.z.object({
-          outcome: import_v47.z.string(),
-          output: import_v47.z.string()
+        codeExecutionResult: z5.object({
+          outcome: z5.string(),
+          output: z5.string()
         }).nullish(),
-        text: import_v47.z.string().nullish(),
-        thought: import_v47.z.boolean().nullish(),
-        thoughtSignature: import_v47.z.string().nullish()
+        text: z5.string().nullish(),
+        thought: z5.boolean().nullish(),
+        thoughtSignature: z5.string().nullish()
       })
     ])
   ).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 getSafetyRatingSchema = () => z5.object({
+  category: z5.string().nullish(),
+  probability: z5.string().nullish(),
+  probabilityScore: z5.number().nullish(),
+  severity: z5.string().nullish(),
+  severityScore: z5.number().nullish(),
+  blocked: z5.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 usageSchema = z5.object({
+  cachedContentTokenCount: z5.number().nullish(),
+  thoughtsTokenCount: z5.number().nullish(),
+  promptTokenCount: z5.number().nullish(),
+  candidatesTokenCount: z5.number().nullish(),
+  totalTokenCount: z5.number().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()
+var getUrlContextMetadataSchema = () => z5.object({
+  urlMetadata: z5.array(
+    z5.object({
+      retrievedUrl: z5.string(),
+      urlRetrievalStatus: z5.string()
     })
-  ),
-  usageMetadata: usageSchema.nullish(),
-  promptFeedback: import_v47.z.object({
-    blockReason: import_v47.z.string().nullish(),
-    safetyRatings: import_v47.z.array(safetyRatingSchema).nullish()
-  }).nullish()
+  )
 });
-var chunkSchema = import_v47.z.object({
-  candidates: import_v47.z.array(
-    import_v47.z.object({
-      content: contentSchema.nullish(),
-      finishReason: import_v47.z.string().nullish(),
-      safetyRatings: import_v47.z.array(safetyRatingSchema).nullish(),
-      groundingMetadata: groundingMetadataSchema.nullish(),
-      urlContextMetadata: urlContextMetadataSchema.nullish()
+var responseSchema = (0, import_provider_utils6.lazySchema)(
+  () => (0, import_provider_utils6.zodSchema)(
+    z5.object({
+      candidates: z5.array(
+        z5.object({
+          content: getContentSchema().nullish().or(z5.object({}).strict()),
+          finishReason: z5.string().nullish(),
+          safetyRatings: z5.array(getSafetyRatingSchema()).nullish(),
+          groundingMetadata: getGroundingMetadataSchema().nullish(),
+          urlContextMetadata: getUrlContextMetadataSchema().nullish()
+        })
+      ),
+      usageMetadata: usageSchema.nullish(),
+      promptFeedback: z5.object({
+        blockReason: z5.string().nullish(),
+        safetyRatings: z5.array(getSafetyRatingSchema()).nullish()
+      }).nullish()
     })
-  ).nullish(),
-  usageMetadata: usageSchema.nullish(),
-  promptFeedback: import_v47.z.object({
-    blockReason: import_v47.z.string().nullish(),
-    safetyRatings: import_v47.z.array(safetyRatingSchema).nullish()
-  }).nullish()
-});
+  )
+);
+var chunkSchema = (0, import_provider_utils6.lazySchema)(
+  () => (0, import_provider_utils6.zodSchema)(
+    z5.object({
+      candidates: z5.array(
+        z5.object({
+          content: getContentSchema().nullish(),
+          finishReason: z5.string().nullish(),
+          safetyRatings: z5.array(getSafetyRatingSchema()).nullish(),
+          groundingMetadata: getGroundingMetadataSchema().nullish(),
+          urlContextMetadata: getUrlContextMetadataSchema().nullish()
+        })
+      ).nullish(),
+      usageMetadata: usageSchema.nullish(),
+      promptFeedback: z5.object({
+        blockReason: z5.string().nullish(),
+        safetyRatings: z5.array(getSafetyRatingSchema()).nullish()
+      }).nullish()
+    })
+  )
+);
 
 // src/tool/code-execution.ts
 var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
+var z6 = __toESM(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.")
+  inputSchema: z6.object({
+    language: z6.string().describe("The programming language of the code."),
+    code: z6.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.")
+  outputSchema: z6.object({
+    outcome: z6.string().describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
+    output: z6.string().describe("The output from the code execution.")
   })
 });
 
+// src/tool/google-search.ts
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
+var z7 = __toESM(require("zod/v4"));
+var googleSearch = (0, import_provider_utils8.createProviderDefinedToolFactory)({
+  id: "google.google_search",
+  name: "google_search",
+  inputSchema: (0, import_provider_utils8.lazySchema)(
+    () => (0, import_provider_utils8.zodSchema)(
+      z7.object({
+        mode: z7.enum(["MODE_DYNAMIC", "MODE_UNSPECIFIED"]).default("MODE_UNSPECIFIED"),
+        dynamicThreshold: z7.number().default(1)
+      })
+    )
+  )
+});
+
+// src/tool/url-context.ts
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var z8 = __toESM(require("zod/v4"));
+var urlContext = (0, import_provider_utils9.createProviderDefinedToolFactory)({
+  id: "google.url_context",
+  name: "url_context",
+  inputSchema: (0, import_provider_utils9.lazySchema)(() => (0, import_provider_utils9.zodSchema)(z8.object({})))
+});
+
 // src/google-tools.ts
 var googleTools = {
   /**
@@ -1370,8 +1424,8 @@ var googleTools = {
 };
 
 // src/google-generative-ai-image-model.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_v49 = require("zod/v4");
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var z9 = __toESM(require("zod/v4"));
 var GoogleGenerativeAIImageModel = class {
   constructor(modelId, settings, config) {
     this.modelId = modelId;
@@ -1413,7 +1467,7 @@ var GoogleGenerativeAIImageModel = class {
         details: "This model does not support the `seed` option through this provider."
       });
     }
-    const googleOptions = await (0, import_provider_utils8.parseProviderOptions)({
+    const googleOptions = await (0, import_provider_utils10.parseProviderOptions)({
       provider: "google",
       providerOptions,
       schema: googleImageProviderOptionsSchema
@@ -1432,12 +1486,12 @@ var GoogleGenerativeAIImageModel = class {
       instances: [{ prompt }],
       parameters
     };
-    const { responseHeaders, value: response } = await (0, import_provider_utils8.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils10.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),
+      headers: (0, import_provider_utils10.combineHeaders)(await (0, import_provider_utils10.resolve)(this.config.headers), headers),
       body,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils8.createJsonResponseHandler)(
+      successfulResponseHandler: (0, import_provider_utils10.createJsonResponseHandler)(
         googleImageResponseSchema
       ),
       abortSignal,
@@ -1463,21 +1517,29 @@ var GoogleGenerativeAIImageModel = class {
     };
   }
 };
-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()
-});
+var googleImageResponseSchema = (0, import_provider_utils10.lazySchema)(
+  () => (0, import_provider_utils10.zodSchema)(
+    z9.object({
+      predictions: z9.array(z9.object({ bytesBase64Encoded: z9.string() })).default([])
+    })
+  )
+);
+var googleImageProviderOptionsSchema = (0, import_provider_utils10.lazySchema)(
+  () => (0, import_provider_utils10.zodSchema)(
+    z9.object({
+      personGeneration: z9.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      aspectRatio: z9.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_utils9.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
-  const getHeaders = () => (0, import_provider_utils9.withUserAgentSuffix)(
+  const baseURL = (_a = (0, import_provider_utils11.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
+  const getHeaders = () => (0, import_provider_utils11.withUserAgentSuffix)(
     {
-      "x-goog-api-key": (0, import_provider_utils9.loadApiKey)({
+      "x-goog-api-key": (0, import_provider_utils11.loadApiKey)({
         apiKey: options.apiKey,
         environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
         description: "Google Generative AI"
@@ -1492,7 +1554,7 @@ function createGoogleGenerativeAI(options = {}) {
       provider: "google.generative-ai",
       baseURL,
       headers: getHeaders,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils9.generateId,
+      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils11.generateId,
       supportedUrls: () => ({
         "*": [
           // Google Generative Language "files" endpoint