@ai-sdk/google 4.0.0-beta.36 → 4.0.0-beta.37

package/dist/internal/index.js

@@ -1,35 +1,19 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/internal/index.ts
-var index_exports = {};
-__export(index_exports, {
-  GoogleGenerativeAILanguageModel: () => GoogleGenerativeAILanguageModel,
-  getGroundingMetadataSchema: () => getGroundingMetadataSchema,
-  getUrlContextMetadataSchema: () => getUrlContextMetadataSchema,
-  googleTools: () => googleTools
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/google-generative-ai-language-model.ts
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+import {
+  combineHeaders,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler,
+  generateId,
+  isCustomReasoning,
+  lazySchema as lazySchema3,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
+  parseProviderOptions,
+  postJsonToApi,
+  resolve,
+  zodSchema as zodSchema3
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/convert-google-generative-ai-usage.ts
 function convertGoogleGenerativeAIUsage(usage) {
@@ -187,8 +171,14 @@ function isEmptyObjectSchema(jsonSchema) {
 }
 
 // src/convert-to-google-generative-ai-messages.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  convertToBase64,
+  isProviderReference,
+  resolveProviderReference
+} from "@ai-sdk/provider-utils";
 var dataUrlRegex = /^data:([^;,]+);base64,(.+)$/s;
 function parseBase64DataUrl(value) {
   const match = dataUrlRegex.exec(value);
@@ -305,7 +295,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
     switch (role) {
       case "system": {
         if (!systemMessagesAllowed) {
-          throw new import_provider.UnsupportedFunctionalityError({
+          throw new UnsupportedFunctionalityError({
             functionality: "system messages are only supported at the beginning of the conversation"
           });
         }
@@ -330,16 +320,16 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                     fileUri: part.data.toString()
                   }
                 });
-              } else if ((0, import_provider_utils.isProviderReference)(part.data)) {
+              } else if (isProviderReference(part.data)) {
                 if (providerOptionsName === "vertex") {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError({
                     functionality: "file parts with provider references"
                   });
                 }
                 parts.push({
                   fileData: {
                     mimeType: mediaType,
-                    fileUri: (0, import_provider_utils.resolveProviderReference)({
+                    fileUri: resolveProviderReference({
                       reference: part.data,
                       provider: "google"
                     })
@@ -349,7 +339,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                 parts.push({
                   inlineData: {
                     mimeType: mediaType,
-                    data: (0, import_provider_utils.convertToBase64)(part.data)
+                    data: convertToBase64(part.data)
                   }
                 });
               }
@@ -384,14 +374,14 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
               }
               case "reasoning-file": {
                 if (part.data instanceof URL) {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError({
                     functionality: "File data URLs in assistant messages are not supported"
                   });
                 }
                 return {
                   inlineData: {
                     mimeType: part.mediaType,
-                    data: (0, import_provider_utils.convertToBase64)(part.data)
+                    data: convertToBase64(part.data)
                   },
                   thought: true,
                   thoughtSignature
@@ -399,20 +389,20 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
               }
               case "file": {
                 if (part.data instanceof URL) {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError({
                     functionality: "File data URLs in assistant messages are not supported"
                   });
                 }
-                if ((0, import_provider_utils.isProviderReference)(part.data)) {
+                if (isProviderReference(part.data)) {
                   if (providerOptionsName === "vertex") {
-                    throw new import_provider.UnsupportedFunctionalityError({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "file parts with provider references"
                     });
                   }
                   return {
                     fileData: {
                       mimeType: part.mediaType,
-                      fileUri: (0, import_provider_utils.resolveProviderReference)({
+                      fileUri: resolveProviderReference({
                         reference: part.data,
                         provider: "google"
                       })
@@ -424,7 +414,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                 return {
                   inlineData: {
                     mimeType: part.mediaType,
-                    data: (0, import_provider_utils.convertToBase64)(part.data)
+                    data: convertToBase64(part.data)
                   },
                   ...(providerOpts == null ? void 0 : providerOpts.thought) === true ? { thought: true } : {},
                   thoughtSignature
@@ -541,43 +531,47 @@ function getModelPath(modelId) {
 }
 
 // src/google-error.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
-var googleErrorDataSchema = (0, import_provider_utils2.lazySchema)(
-  () => (0, import_provider_utils2.zodSchema)(
-    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()
+import {
+  createJsonErrorResponseHandler,
+  lazySchema,
+  zodSchema
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var googleErrorDataSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      error: z.object({
+        code: z.number().nullable(),
+        message: z.string(),
+        status: z.string()
       })
     })
   )
 );
-var googleFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
+var googleFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: googleErrorDataSchema,
   errorToMessage: (data) => data.error.message
 });
 
 // src/google-generative-ai-options.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
-var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
-  () => (0, import_provider_utils3.zodSchema)(
-    import_v42.z.object({
-      responseModalities: import_v42.z.array(import_v42.z.enum(["TEXT", "IMAGE"])).optional(),
-      thinkingConfig: import_v42.z.object({
-        thinkingBudget: import_v42.z.number().optional(),
-        includeThoughts: import_v42.z.boolean().optional(),
+import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+var googleLanguageModelOptions = lazySchema2(
+  () => zodSchema2(
+    z2.object({
+      responseModalities: z2.array(z2.enum(["TEXT", "IMAGE"])).optional(),
+      thinkingConfig: z2.object({
+        thinkingBudget: z2.number().optional(),
+        includeThoughts: z2.boolean().optional(),
         // https://ai.google.dev/gemini-api/docs/gemini-3?thinking=high#thinking_level
-        thinkingLevel: import_v42.z.enum(["minimal", "low", "medium", "high"]).optional()
+        thinkingLevel: z2.enum(["minimal", "low", "medium", "high"]).optional()
       }).optional(),
       /**
        * Optional.
        * The name of the cached content used as context to serve the prediction.
        * Format: cachedContents/{cachedContent}
        */
-      cachedContent: import_v42.z.string().optional(),
+      cachedContent: z2.string().optional(),
       /**
        * Optional. Enable structured output. Default is true.
        *
@@ -586,13 +580,13 @@ var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
        * Google Generative AI uses. You can use this to disable
        * structured outputs if you need to.
        */
-      structuredOutputs: import_v42.z.boolean().optional(),
+      structuredOutputs: z2.boolean().optional(),
       /**
        * Optional. A list of unique safety settings for blocking unsafe content.
        */
-      safetySettings: import_v42.z.array(
-        import_v42.z.object({
-          category: import_v42.z.enum([
+      safetySettings: z2.array(
+        z2.object({
+          category: z2.enum([
             "HARM_CATEGORY_UNSPECIFIED",
             "HARM_CATEGORY_HATE_SPEECH",
             "HARM_CATEGORY_DANGEROUS_CONTENT",
@@ -600,7 +594,7 @@ var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
             "HARM_CATEGORY_SEXUALLY_EXPLICIT",
             "HARM_CATEGORY_CIVIC_INTEGRITY"
           ]),
-          threshold: import_v42.z.enum([
+          threshold: z2.enum([
             "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
             "BLOCK_LOW_AND_ABOVE",
             "BLOCK_MEDIUM_AND_ABOVE",
@@ -610,7 +604,7 @@ var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
           ])
         })
       ).optional(),
-      threshold: import_v42.z.enum([
+      threshold: z2.enum([
         "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
         "BLOCK_LOW_AND_ABOVE",
         "BLOCK_MEDIUM_AND_ABOVE",
@@ -623,19 +617,19 @@ var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
        *
        * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
        */
-      audioTimestamp: import_v42.z.boolean().optional(),
+      audioTimestamp: z2.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_v42.z.record(import_v42.z.string(), import_v42.z.string()).optional(),
+      labels: z2.record(z2.string(), z2.string()).optional(),
       /**
        * Optional. If specified, the media resolution specified will be used.
        *
        * https://ai.google.dev/api/generate-content#MediaResolution
        */
-      mediaResolution: import_v42.z.enum([
+      mediaResolution: z2.enum([
         "MEDIA_RESOLUTION_UNSPECIFIED",
         "MEDIA_RESOLUTION_LOW",
         "MEDIA_RESOLUTION_MEDIUM",
@@ -646,8 +640,8 @@ var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
        *
        * https://ai.google.dev/gemini-api/docs/image-generation#aspect_ratios
        */
-      imageConfig: import_v42.z.object({
-        aspectRatio: import_v42.z.enum([
+      imageConfig: z2.object({
+        aspectRatio: z2.enum([
           "1:1",
           "2:3",
           "3:2",
@@ -663,7 +657,7 @@ var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
           "1:4",
           "4:1"
         ]).optional(),
-        imageSize: import_v42.z.enum(["1K", "2K", "4K", "512"]).optional()
+        imageSize: z2.enum(["1K", "2K", "4K", "512"]).optional()
       }).optional(),
       /**
        * Optional. Configuration for grounding retrieval.
@@ -671,10 +665,10 @@ var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
        *
        * https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
        */
-      retrievalConfig: import_v42.z.object({
-        latLng: import_v42.z.object({
-          latitude: import_v42.z.number(),
-          longitude: import_v42.z.number()
+      retrievalConfig: z2.object({
+        latLng: z2.object({
+          latitude: z2.number(),
+          longitude: z2.number()
         }).optional()
       }).optional(),
       /**
@@ -687,11 +681,11 @@ var googleLanguageModelOptions = (0, import_provider_utils3.lazySchema)(
        *
        * https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/function-calling#streaming-fc
        */
-      streamFunctionCallArguments: import_v42.z.boolean().optional(),
+      streamFunctionCallArguments: z2.boolean().optional(),
       /**
        * Optional. The service tier to use for the request.
        */
-      serviceTier: import_v42.z.enum(["standard", "flex", "priority"]).optional()
+      serviceTier: z2.enum(["standard", "flex", "priority"]).optional()
     })
   )
 );
@@ -702,7 +696,9 @@ var VertexServiceTierMap = {
 };
 
 // src/google-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 function prepareTools({
   tools,
   toolChoice,
@@ -944,7 +940,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -1207,7 +1203,7 @@ var GoogleGenerativeAILanguageModel = class {
     var _a;
     this.modelId = modelId;
     this.config = config;
-    this.generateId = (_a = config.generateId) != null ? _a : import_provider_utils4.generateId;
+    this.generateId = (_a = config.generateId) != null ? _a : generateId;
   }
   get provider() {
     return this.config.provider;
@@ -1235,13 +1231,13 @@ var GoogleGenerativeAILanguageModel = class {
     var _a, _b;
     const warnings = [];
     const providerOptionsName = this.config.provider.includes("vertex") ? "vertex" : "google";
-    let googleOptions = await (0, import_provider_utils4.parseProviderOptions)({
+    let googleOptions = await parseProviderOptions({
       provider: providerOptionsName,
       providerOptions,
       schema: googleLanguageModelOptions
     });
     if (googleOptions == null && providerOptionsName !== "google") {
-      googleOptions = await (0, import_provider_utils4.parseProviderOptions)({
+      googleOptions = await parseProviderOptions({
         provider: "google",
         providerOptions,
         schema: googleLanguageModelOptions
@@ -1351,22 +1347,22 @@ var GoogleGenerativeAILanguageModel = class {
   async doGenerate(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
     const { args, warnings, providerOptionsName } = await this.getArgs(options);
-    const mergedHeaders = (0, import_provider_utils4.combineHeaders)(
-      await (0, import_provider_utils4.resolve)(this.config.headers),
+    const mergedHeaders = combineHeaders(
+      await resolve(this.config.headers),
       options.headers
     );
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils4.postJsonToApi)({
+    } = await postJsonToApi({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:generateContent`,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(responseSchema),
+      successfulResponseHandler: createJsonResponseHandler(responseSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -1533,18 +1529,18 @@ var GoogleGenerativeAILanguageModel = class {
       options,
       { isStreaming: true }
     );
-    const headers = (0, import_provider_utils4.combineHeaders)(
-      await (0, import_provider_utils4.resolve)(this.config.headers),
+    const headers = combineHeaders(
+      await resolve(this.config.headers),
       options.headers
     );
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:streamGenerateContent?alt=sse`,
       headers,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createEventSourceResponseHandler)(chunkSchema),
+      successfulResponseHandler: createEventSourceResponseHandler(chunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -1940,7 +1936,7 @@ function resolveThinkingConfig({
   modelId,
   warnings
 }) {
-  if (!(0, import_provider_utils4.isCustomReasoning)(reasoning)) {
+  if (!isCustomReasoning(reasoning)) {
     return void 0;
   }
   if (isGemini3Model(modelId) && !modelId.includes("gemini-3-pro-image")) {
@@ -1955,7 +1951,7 @@ function resolveGemini3ThinkingConfig({
   if (reasoning === "none") {
     return { thinkingLevel: "minimal" };
   }
-  const thinkingLevel = (0, import_provider_utils4.mapReasoningToProviderEffort)({
+  const thinkingLevel = mapReasoningToProviderEffort({
     reasoning,
     effortMap: {
       minimal: "minimal",
@@ -1979,7 +1975,7 @@ function resolveGemini25ThinkingConfig({
   if (reasoning === "none") {
     return { thinkingBudget: 0 };
   }
-  const thinkingBudget = (0, import_provider_utils4.mapReasoningToProviderBudget)({
+  const thinkingBudget = mapReasoningToProviderBudget({
     reasoning,
     maxOutputTokens: getMaxOutputTokensForGemini25Model(),
     maxReasoningBudget: getMaxThinkingTokensForGemini25Model(modelId),
@@ -2085,270 +2081,286 @@ function extractSources({
   }
   return sources.length > 0 ? sources : void 0;
 }
-var getGroundingMetadataSchema = () => import_v43.z.object({
-  webSearchQueries: import_v43.z.array(import_v43.z.string()).nullish(),
-  imageSearchQueries: import_v43.z.array(import_v43.z.string()).nullish(),
-  retrievalQueries: import_v43.z.array(import_v43.z.string()).nullish(),
-  searchEntryPoint: import_v43.z.object({ renderedContent: import_v43.z.string() }).nullish(),
-  groundingChunks: import_v43.z.array(
-    import_v43.z.object({
-      web: import_v43.z.object({ uri: import_v43.z.string(), title: import_v43.z.string().nullish() }).nullish(),
-      image: import_v43.z.object({
-        sourceUri: import_v43.z.string(),
-        imageUri: import_v43.z.string(),
-        title: import_v43.z.string().nullish(),
-        domain: import_v43.z.string().nullish()
+var getGroundingMetadataSchema = () => z3.object({
+  webSearchQueries: z3.array(z3.string()).nullish(),
+  imageSearchQueries: z3.array(z3.string()).nullish(),
+  retrievalQueries: z3.array(z3.string()).nullish(),
+  searchEntryPoint: z3.object({ renderedContent: z3.string() }).nullish(),
+  groundingChunks: z3.array(
+    z3.object({
+      web: z3.object({ uri: z3.string(), title: z3.string().nullish() }).nullish(),
+      image: z3.object({
+        sourceUri: z3.string(),
+        imageUri: z3.string(),
+        title: z3.string().nullish(),
+        domain: z3.string().nullish()
       }).nullish(),
-      retrievedContext: import_v43.z.object({
-        uri: import_v43.z.string().nullish(),
-        title: import_v43.z.string().nullish(),
-        text: import_v43.z.string().nullish(),
-        fileSearchStore: import_v43.z.string().nullish()
+      retrievedContext: z3.object({
+        uri: z3.string().nullish(),
+        title: z3.string().nullish(),
+        text: z3.string().nullish(),
+        fileSearchStore: z3.string().nullish()
       }).nullish(),
-      maps: import_v43.z.object({
-        uri: import_v43.z.string().nullish(),
-        title: import_v43.z.string().nullish(),
-        text: import_v43.z.string().nullish(),
-        placeId: import_v43.z.string().nullish()
+      maps: z3.object({
+        uri: z3.string().nullish(),
+        title: z3.string().nullish(),
+        text: z3.string().nullish(),
+        placeId: z3.string().nullish()
       }).nullish()
     })
   ).nullish(),
-  groundingSupports: import_v43.z.array(
-    import_v43.z.object({
-      segment: import_v43.z.object({
-        startIndex: import_v43.z.number().nullish(),
-        endIndex: import_v43.z.number().nullish(),
-        text: import_v43.z.string().nullish()
+  groundingSupports: z3.array(
+    z3.object({
+      segment: z3.object({
+        startIndex: z3.number().nullish(),
+        endIndex: z3.number().nullish(),
+        text: z3.string().nullish()
       }).nullish(),
-      segment_text: import_v43.z.string().nullish(),
-      groundingChunkIndices: import_v43.z.array(import_v43.z.number()).nullish(),
-      supportChunkIndices: import_v43.z.array(import_v43.z.number()).nullish(),
-      confidenceScores: import_v43.z.array(import_v43.z.number()).nullish(),
-      confidenceScore: import_v43.z.array(import_v43.z.number()).nullish()
+      segment_text: z3.string().nullish(),
+      groundingChunkIndices: z3.array(z3.number()).nullish(),
+      supportChunkIndices: z3.array(z3.number()).nullish(),
+      confidenceScores: z3.array(z3.number()).nullish(),
+      confidenceScore: z3.array(z3.number()).nullish()
     })
   ).nullish(),
-  retrievalMetadata: import_v43.z.union([
-    import_v43.z.object({
-      webDynamicRetrievalScore: import_v43.z.number()
+  retrievalMetadata: z3.union([
+    z3.object({
+      webDynamicRetrievalScore: z3.number()
     }),
-    import_v43.z.object({})
+    z3.object({})
   ]).nullish()
 });
-var partialArgSchema = import_v43.z.object({
-  jsonPath: import_v43.z.string(),
-  stringValue: import_v43.z.string().nullish(),
-  numberValue: import_v43.z.number().nullish(),
-  boolValue: import_v43.z.boolean().nullish(),
-  nullValue: import_v43.z.unknown().nullish(),
-  willContinue: import_v43.z.boolean().nullish()
+var partialArgSchema = z3.object({
+  jsonPath: z3.string(),
+  stringValue: z3.string().nullish(),
+  numberValue: z3.number().nullish(),
+  boolValue: z3.boolean().nullish(),
+  nullValue: z3.unknown().nullish(),
+  willContinue: z3.boolean().nullish()
 });
-var getContentSchema = () => import_v43.z.object({
-  parts: import_v43.z.array(
-    import_v43.z.union([
+var getContentSchema = () => z3.object({
+  parts: z3.array(
+    z3.union([
       // note: order matters since text can be fully empty
-      import_v43.z.object({
-        functionCall: import_v43.z.object({
-          name: import_v43.z.string().nullish(),
-          args: import_v43.z.unknown().nullish(),
-          partialArgs: import_v43.z.array(partialArgSchema).nullish(),
-          willContinue: import_v43.z.boolean().nullish()
+      z3.object({
+        functionCall: z3.object({
+          name: z3.string().nullish(),
+          args: z3.unknown().nullish(),
+          partialArgs: z3.array(partialArgSchema).nullish(),
+          willContinue: z3.boolean().nullish()
         }),
-        thoughtSignature: import_v43.z.string().nullish()
+        thoughtSignature: z3.string().nullish()
       }),
-      import_v43.z.object({
-        inlineData: import_v43.z.object({
-          mimeType: import_v43.z.string(),
-          data: import_v43.z.string()
+      z3.object({
+        inlineData: z3.object({
+          mimeType: z3.string(),
+          data: z3.string()
         }),
-        thought: import_v43.z.boolean().nullish(),
-        thoughtSignature: import_v43.z.string().nullish()
+        thought: z3.boolean().nullish(),
+        thoughtSignature: z3.string().nullish()
       }),
-      import_v43.z.object({
-        toolCall: import_v43.z.object({
-          toolType: import_v43.z.string(),
-          args: import_v43.z.unknown().nullish(),
-          id: import_v43.z.string()
+      z3.object({
+        toolCall: z3.object({
+          toolType: z3.string(),
+          args: z3.unknown().nullish(),
+          id: z3.string()
         }),
-        thoughtSignature: import_v43.z.string().nullish()
+        thoughtSignature: z3.string().nullish()
       }),
-      import_v43.z.object({
-        toolResponse: import_v43.z.object({
-          toolType: import_v43.z.string(),
-          response: import_v43.z.unknown().nullish(),
-          id: import_v43.z.string()
+      z3.object({
+        toolResponse: z3.object({
+          toolType: z3.string(),
+          response: z3.unknown().nullish(),
+          id: z3.string()
         }),
-        thoughtSignature: import_v43.z.string().nullish()
+        thoughtSignature: z3.string().nullish()
       }),
-      import_v43.z.object({
-        executableCode: import_v43.z.object({
-          language: import_v43.z.string(),
-          code: import_v43.z.string()
+      z3.object({
+        executableCode: z3.object({
+          language: z3.string(),
+          code: z3.string()
         }).nullish(),
-        codeExecutionResult: import_v43.z.object({
-          outcome: import_v43.z.string(),
-          output: import_v43.z.string().nullish()
+        codeExecutionResult: z3.object({
+          outcome: z3.string(),
+          output: z3.string().nullish()
         }).nullish(),
-        text: import_v43.z.string().nullish(),
-        thought: import_v43.z.boolean().nullish(),
-        thoughtSignature: import_v43.z.string().nullish()
+        text: z3.string().nullish(),
+        thought: z3.boolean().nullish(),
+        thoughtSignature: z3.string().nullish()
       })
     ])
   ).nullish()
 });
-var getSafetyRatingSchema = () => import_v43.z.object({
-  category: import_v43.z.string().nullish(),
-  probability: import_v43.z.string().nullish(),
-  probabilityScore: import_v43.z.number().nullish(),
-  severity: import_v43.z.string().nullish(),
-  severityScore: import_v43.z.number().nullish(),
-  blocked: import_v43.z.boolean().nullish()
+var getSafetyRatingSchema = () => z3.object({
+  category: z3.string().nullish(),
+  probability: z3.string().nullish(),
+  probabilityScore: z3.number().nullish(),
+  severity: z3.string().nullish(),
+  severityScore: z3.number().nullish(),
+  blocked: z3.boolean().nullish()
 });
-var tokenDetailsSchema = import_v43.z.array(
-  import_v43.z.object({
-    modality: import_v43.z.string(),
-    tokenCount: import_v43.z.number()
+var tokenDetailsSchema = z3.array(
+  z3.object({
+    modality: z3.string(),
+    tokenCount: z3.number()
   })
 ).nullish();
-var usageSchema = import_v43.z.object({
-  cachedContentTokenCount: import_v43.z.number().nullish(),
-  thoughtsTokenCount: import_v43.z.number().nullish(),
-  promptTokenCount: import_v43.z.number().nullish(),
-  candidatesTokenCount: import_v43.z.number().nullish(),
-  totalTokenCount: import_v43.z.number().nullish(),
+var usageSchema = z3.object({
+  cachedContentTokenCount: z3.number().nullish(),
+  thoughtsTokenCount: z3.number().nullish(),
+  promptTokenCount: z3.number().nullish(),
+  candidatesTokenCount: z3.number().nullish(),
+  totalTokenCount: z3.number().nullish(),
   // https://cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/v1/GenerateContentResponse#TrafficType
-  trafficType: import_v43.z.string().nullish(),
+  trafficType: z3.string().nullish(),
   // https://ai.google.dev/api/generate-content#Modality
   promptTokensDetails: tokenDetailsSchema,
   candidatesTokensDetails: tokenDetailsSchema
 });
-var getUrlContextMetadataSchema = () => import_v43.z.object({
-  urlMetadata: import_v43.z.array(
-    import_v43.z.object({
-      retrievedUrl: import_v43.z.string(),
-      urlRetrievalStatus: import_v43.z.string()
+var getUrlContextMetadataSchema = () => z3.object({
+  urlMetadata: z3.array(
+    z3.object({
+      retrievedUrl: z3.string(),
+      urlRetrievalStatus: z3.string()
     })
   ).nullish()
 });
-var responseSchema = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v43.z.object({
-      candidates: import_v43.z.array(
-        import_v43.z.object({
-          content: getContentSchema().nullish().or(import_v43.z.object({}).strict()),
-          finishReason: import_v43.z.string().nullish(),
-          finishMessage: import_v43.z.string().nullish(),
-          safetyRatings: import_v43.z.array(getSafetyRatingSchema()).nullish(),
+var responseSchema = lazySchema3(
+  () => zodSchema3(
+    z3.object({
+      candidates: z3.array(
+        z3.object({
+          content: getContentSchema().nullish().or(z3.object({}).strict()),
+          finishReason: z3.string().nullish(),
+          finishMessage: z3.string().nullish(),
+          safetyRatings: z3.array(getSafetyRatingSchema()).nullish(),
           groundingMetadata: getGroundingMetadataSchema().nullish(),
           urlContextMetadata: getUrlContextMetadataSchema().nullish()
         })
       ),
       usageMetadata: usageSchema.nullish(),
-      promptFeedback: import_v43.z.object({
-        blockReason: import_v43.z.string().nullish(),
-        safetyRatings: import_v43.z.array(getSafetyRatingSchema()).nullish()
+      promptFeedback: z3.object({
+        blockReason: z3.string().nullish(),
+        safetyRatings: z3.array(getSafetyRatingSchema()).nullish()
       }).nullish(),
-      serviceTier: import_v43.z.string().nullish()
+      serviceTier: z3.string().nullish()
     })
   )
 );
-var chunkSchema = (0, import_provider_utils4.lazySchema)(
-  () => (0, import_provider_utils4.zodSchema)(
-    import_v43.z.object({
-      candidates: import_v43.z.array(
-        import_v43.z.object({
+var chunkSchema = lazySchema3(
+  () => zodSchema3(
+    z3.object({
+      candidates: z3.array(
+        z3.object({
           content: getContentSchema().nullish(),
-          finishReason: import_v43.z.string().nullish(),
-          finishMessage: import_v43.z.string().nullish(),
-          safetyRatings: import_v43.z.array(getSafetyRatingSchema()).nullish(),
+          finishReason: z3.string().nullish(),
+          finishMessage: z3.string().nullish(),
+          safetyRatings: z3.array(getSafetyRatingSchema()).nullish(),
           groundingMetadata: getGroundingMetadataSchema().nullish(),
           urlContextMetadata: getUrlContextMetadataSchema().nullish()
         })
       ).nullish(),
       usageMetadata: usageSchema.nullish(),
-      promptFeedback: import_v43.z.object({
-        blockReason: import_v43.z.string().nullish(),
-        safetyRatings: import_v43.z.array(getSafetyRatingSchema()).nullish()
+      promptFeedback: z3.object({
+        blockReason: z3.string().nullish(),
+        safetyRatings: z3.array(getSafetyRatingSchema()).nullish()
       }).nullish(),
-      serviceTier: import_v43.z.string().nullish()
+      serviceTier: z3.string().nullish()
     })
   )
 );
 
 // src/tool/code-execution.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
-var codeExecution = (0, import_provider_utils5.createProviderToolFactoryWithOutputSchema)({
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+var codeExecution = createProviderToolFactoryWithOutputSchema({
   id: "google.code_execution",
-  inputSchema: import_v44.z.object({
-    language: import_v44.z.string().describe("The programming language of the code."),
-    code: import_v44.z.string().describe("The code to be executed.")
+  inputSchema: z4.object({
+    language: z4.string().describe("The programming language of the code."),
+    code: z4.string().describe("The code to be executed.")
   }),
-  outputSchema: import_v44.z.object({
-    outcome: import_v44.z.string().describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
-    output: import_v44.z.string().describe("The output from the code execution.")
+  outputSchema: z4.object({
+    outcome: z4.string().describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
+    output: z4.string().describe("The output from the code execution.")
   })
 });
 
 // src/tool/enterprise-web-search.ts
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
-var enterpriseWebSearch = (0, import_provider_utils6.createProviderToolFactory)({
+import {
+  createProviderToolFactory,
+  lazySchema as lazySchema4,
+  zodSchema as zodSchema4
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+var enterpriseWebSearch = createProviderToolFactory({
   id: "google.enterprise_web_search",
-  inputSchema: (0, import_provider_utils6.lazySchema)(() => (0, import_provider_utils6.zodSchema)(import_v45.z.object({})))
+  inputSchema: lazySchema4(() => zodSchema4(z5.object({})))
 });
 
 // src/tool/file-search.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var fileSearchArgsBaseSchema = import_v46.z.object({
+import {
+  createProviderToolFactory as createProviderToolFactory2,
+  lazySchema as lazySchema5,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var fileSearchArgsBaseSchema = z6.object({
   /** The names of the file_search_stores to retrieve from.
    *  Example: `fileSearchStores/my-file-search-store-123`
    */
-  fileSearchStoreNames: import_v46.z.array(import_v46.z.string()).describe(
+  fileSearchStoreNames: z6.array(z6.string()).describe(
     "The names of the file_search_stores to retrieve from. Example: `fileSearchStores/my-file-search-store-123`"
   ),
   /** The number of file search retrieval chunks to retrieve. */
-  topK: import_v46.z.number().int().positive().describe("The number of file search retrieval chunks to retrieve.").optional(),
+  topK: z6.number().int().positive().describe("The number of file search retrieval chunks to retrieve.").optional(),
   /** Metadata filter to apply to the file search retrieval documents.
    *  See https://google.aip.dev/160 for the syntax of the filter expression.
    */
-  metadataFilter: import_v46.z.string().describe(
+  metadataFilter: z6.string().describe(
     "Metadata filter to apply to the file search retrieval documents. See https://google.aip.dev/160 for the syntax of the filter expression."
   ).optional()
 }).passthrough();
-var fileSearchArgsSchema = (0, import_provider_utils7.lazySchema)(
-  () => (0, import_provider_utils7.zodSchema)(fileSearchArgsBaseSchema)
+var fileSearchArgsSchema = lazySchema5(
+  () => zodSchema5(fileSearchArgsBaseSchema)
 );
-var fileSearch = (0, import_provider_utils7.createProviderToolFactory)({
+var fileSearch = createProviderToolFactory2({
   id: "google.file_search",
   inputSchema: fileSearchArgsSchema
 });
 
 // src/tool/google-maps.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-var googleMaps = (0, import_provider_utils8.createProviderToolFactory)({
+import {
+  createProviderToolFactory as createProviderToolFactory3,
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema6
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var googleMaps = createProviderToolFactory3({
   id: "google.google_maps",
-  inputSchema: (0, import_provider_utils8.lazySchema)(() => (0, import_provider_utils8.zodSchema)(import_v47.z.object({})))
+  inputSchema: lazySchema6(() => zodSchema6(z7.object({})))
 });
 
 // src/tool/google-search.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
-var googleSearchToolArgsBaseSchema = import_v48.z.object({
-  searchTypes: import_v48.z.object({
-    webSearch: import_v48.z.object({}).optional(),
-    imageSearch: import_v48.z.object({}).optional()
+import {
+  createProviderToolFactory as createProviderToolFactory4,
+  lazySchema as lazySchema7,
+  zodSchema as zodSchema7
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var googleSearchToolArgsBaseSchema = z8.object({
+  searchTypes: z8.object({
+    webSearch: z8.object({}).optional(),
+    imageSearch: z8.object({}).optional()
   }).optional(),
-  timeRangeFilter: import_v48.z.object({
-    startTime: import_v48.z.string(),
-    endTime: import_v48.z.string()
+  timeRangeFilter: z8.object({
+    startTime: z8.string(),
+    endTime: z8.string()
   }).optional()
 }).passthrough();
-var googleSearchToolArgsSchema = (0, import_provider_utils9.lazySchema)(
-  () => (0, import_provider_utils9.zodSchema)(googleSearchToolArgsBaseSchema)
+var googleSearchToolArgsSchema = lazySchema7(
+  () => zodSchema7(googleSearchToolArgsBaseSchema)
 );
-var googleSearch = (0, import_provider_utils9.createProviderToolFactory)(
+var googleSearch = createProviderToolFactory4(
   {
     id: "google.google_search",
     inputSchema: googleSearchToolArgsSchema
@@ -2356,21 +2368,25 @@ var googleSearch = (0, import_provider_utils9.createProviderToolFactory)(
 );
 
 // src/tool/url-context.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var import_v49 = require("zod/v4");
-var urlContext = (0, import_provider_utils10.createProviderToolFactory)({
+import {
+  createProviderToolFactory as createProviderToolFactory5,
+  lazySchema as lazySchema8,
+  zodSchema as zodSchema8
+} from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+var urlContext = createProviderToolFactory5({
   id: "google.url_context",
-  inputSchema: (0, import_provider_utils10.lazySchema)(() => (0, import_provider_utils10.zodSchema)(import_v49.z.object({})))
+  inputSchema: lazySchema8(() => zodSchema8(z9.object({})))
 });
 
 // src/tool/vertex-rag-store.ts
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
-var import_v410 = require("zod/v4");
-var vertexRagStore = (0, import_provider_utils11.createProviderToolFactory)({
+import { createProviderToolFactory as createProviderToolFactory6 } from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod/v4";
+var vertexRagStore = createProviderToolFactory6({
   id: "google.vertex_rag_store",
-  inputSchema: import_v410.z.object({
-    ragCorpus: import_v410.z.string(),
-    topK: import_v410.z.number().optional()
+  inputSchema: z10.object({
+    ragCorpus: z10.string(),
+    topK: z10.number().optional()
   })
 });
 
@@ -2433,11 +2449,10 @@ var googleTools = {
    */
   vertexRagStore
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   GoogleGenerativeAILanguageModel,
   getGroundingMetadataSchema,
   getUrlContextMetadataSchema,
   googleTools
-});
+};
 //# sourceMappingURL=index.js.map