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

package/dist/index.js

@@ -1,81 +1,78 @@
-"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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VERSION: () => VERSION,
-  createGoogleGenerativeAI: () => createGoogleGenerativeAI,
-  google: () => google
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/google-provider.ts
-var import_provider_utils17 = require("@ai-sdk/provider-utils");
+import {
+  generateId as generateId2,
+  loadApiKey,
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "4.0.0-beta.36" : "0.0.0-test";
+var VERSION = true ? "4.0.0-beta.38" : "0.0.0-test";
 
 // src/google-generative-ai-embedding-model.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_v43 = require("zod/v4");
+import {
+  TooManyEmbeddingValuesForCallError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  createJsonResponseHandler,
+  lazySchema as lazySchema3,
+  parseProviderOptions,
+  postJsonToApi,
+  resolve,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  zodSchema as zodSchema3
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/google-error.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
-var googleErrorDataSchema = (0, import_provider_utils.lazySchema)(
-  () => (0, import_provider_utils.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_utils.createJsonErrorResponseHandler)({
+var googleFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: googleErrorDataSchema,
   errorToMessage: (data) => data.error.message
 });
 
 // src/google-generative-ai-embedding-options.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
-var googleEmbeddingContentPartSchema = import_v42.z.union([
-  import_v42.z.object({ text: import_v42.z.string() }),
-  import_v42.z.object({
-    inlineData: import_v42.z.object({
-      mimeType: import_v42.z.string(),
-      data: import_v42.z.string()
+import {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+var googleEmbeddingContentPartSchema = z2.union([
+  z2.object({ text: z2.string() }),
+  z2.object({
+    inlineData: z2.object({
+      mimeType: z2.string(),
+      data: z2.string()
     })
   })
 ]);
-var googleEmbeddingModelOptions = (0, import_provider_utils2.lazySchema)(
-  () => (0, import_provider_utils2.zodSchema)(
-    import_v42.z.object({
+var googleEmbeddingModelOptions = lazySchema2(
+  () => zodSchema2(
+    z2.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(),
+      outputDimensionality: z2.number().optional(),
       /**
        * Optional. Specifies the task type for generating embeddings.
        * Supported task types:
@@ -88,7 +85,7 @@ var googleEmbeddingModelOptions = (0, import_provider_utils2.lazySchema)(
        * - 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([
+      taskType: z2.enum([
         "SEMANTIC_SIMILARITY",
         "CLASSIFICATION",
         "CLUSTERING",
@@ -107,13 +104,13 @@ var googleEmbeddingModelOptions = (0, import_provider_utils2.lazySchema)(
        * The array length must match the number of values being embedded. In
        * the case of a single embedding, the array length must be 1.
        */
-      content: import_v42.z.array(import_v42.z.array(googleEmbeddingContentPartSchema).min(1).nullable()).optional()
+      content: z2.array(z2.array(googleEmbeddingContentPartSchema).min(1).nullable()).optional()
     })
   )
 );
 
 // src/google-generative-ai-embedding-model.ts
-var GoogleGenerativeAIEmbeddingModel = class {
+var GoogleGenerativeAIEmbeddingModel = class _GoogleGenerativeAIEmbeddingModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.maxEmbeddingsPerCall = 2048;
@@ -121,6 +118,18 @@ var GoogleGenerativeAIEmbeddingModel = class {
     this.modelId = modelId;
     this.config = config;
   }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _GoogleGenerativeAIEmbeddingModel(
+      options.modelId,
+      options.config
+    );
+  }
   get provider() {
     return this.config.provider;
   }
@@ -130,21 +139,21 @@ var GoogleGenerativeAIEmbeddingModel = class {
     abortSignal,
     providerOptions
   }) {
-    const googleOptions = await (0, import_provider_utils3.parseProviderOptions)({
+    const googleOptions = await parseProviderOptions({
       provider: "google",
       providerOptions,
       schema: googleEmbeddingModelOptions
     });
     if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider.TooManyEmbeddingValuesForCallError({
+      throw new TooManyEmbeddingValuesForCallError({
         provider: this.provider,
         modelId: this.modelId,
         maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
         values
       });
     }
-    const mergedHeaders = (0, import_provider_utils3.combineHeaders)(
-      await (0, import_provider_utils3.resolve)(this.config.headers),
+    const mergedHeaders = combineHeaders(
+      this.config.headers ? await resolve(this.config.headers) : void 0,
       headers
     );
     const multimodalContent = googleOptions == null ? void 0 : googleOptions.content;
@@ -161,7 +170,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
         responseHeaders: responseHeaders2,
         value: response2,
         rawValue: rawValue2
-      } = await (0, import_provider_utils3.postJsonToApi)({
+      } = await postJsonToApi({
         url: `${this.config.baseURL}/models/${this.modelId}:embedContent`,
         headers: mergedHeaders,
         body: {
@@ -173,7 +182,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
           taskType: googleOptions == null ? void 0 : googleOptions.taskType
         },
         failedResponseHandler: googleFailedResponseHandler,
-        successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler(
           googleGenerativeAISingleEmbeddingResponseSchema
         ),
         abortSignal,
@@ -190,7 +199,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
       responseHeaders,
       value: response,
       rawValue
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await postJsonToApi({
       url: `${this.config.baseURL}/models/${this.modelId}:batchEmbedContents`,
       headers: mergedHeaders,
       body: {
@@ -209,7 +218,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
         })
       },
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         googleGenerativeAITextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -223,24 +232,40 @@ var GoogleGenerativeAIEmbeddingModel = class {
     };
   }
 };
-var googleGenerativeAITextEmbeddingResponseSchema = (0, import_provider_utils3.lazySchema)(
-  () => (0, import_provider_utils3.zodSchema)(
-    import_v43.z.object({
-      embeddings: import_v43.z.array(import_v43.z.object({ values: import_v43.z.array(import_v43.z.number()) }))
+var googleGenerativeAITextEmbeddingResponseSchema = lazySchema3(
+  () => zodSchema3(
+    z3.object({
+      embeddings: z3.array(z3.object({ values: z3.array(z3.number()) }))
     })
   )
 );
-var googleGenerativeAISingleEmbeddingResponseSchema = (0, import_provider_utils3.lazySchema)(
-  () => (0, import_provider_utils3.zodSchema)(
-    import_v43.z.object({
-      embedding: import_v43.z.object({ values: import_v43.z.array(import_v43.z.number()) })
+var googleGenerativeAISingleEmbeddingResponseSchema = lazySchema3(
+  () => zodSchema3(
+    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_v45 = require("zod/v4");
+import {
+  combineHeaders as combineHeaders2,
+  createEventSourceResponseHandler,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  generateId,
+  isCustomReasoning,
+  lazySchema as lazySchema5,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve2,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2,
+  zodSchema as zodSchema5
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
 
 // src/convert-google-generative-ai-usage.ts
 function convertGoogleGenerativeAIUsage(usage) {
@@ -398,8 +423,14 @@ function isEmptyObjectSchema(jsonSchema) {
 }
 
 // src/convert-to-google-generative-ai-messages.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils4 = 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);
@@ -432,7 +463,6 @@ function appendToolResultParts(parts, toolName, outputValue) {
         responseTextParts.push(contentPart.text);
         break;
       }
-      case "image-data":
       case "file-data": {
         functionResponseParts.push({
           inlineData: {
@@ -442,7 +472,6 @@ function appendToolResultParts(parts, toolName, outputValue) {
         });
         break;
       }
-      case "image-url":
       case "file-url": {
         const functionResponsePart = convertUrlToolResultPart(
           contentPart.url
@@ -485,18 +514,22 @@ function appendLegacyToolResultParts(parts, toolName, outputValue) {
           }
         });
         break;
-      case "image-data":
-        parts.push(
-          {
-            inlineData: {
-              mimeType: String(contentPart.mediaType),
-              data: String(contentPart.data)
+      case "file-data":
+        if (contentPart.mediaType.startsWith("image/")) {
+          parts.push(
+            {
+              inlineData: {
+                mimeType: contentPart.mediaType,
+                data: contentPart.data
+              }
+            },
+            {
+              text: "Tool executed successfully and returned this image as a response"
             }
-          },
-          {
-            text: "Tool executed successfully and returned this image as a response"
-          }
-        );
+          );
+        } else {
+          parts.push({ text: JSON.stringify(contentPart) });
+        }
         break;
       default:
         parts.push({ text: JSON.stringify(contentPart) });
@@ -516,7 +549,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
     switch (role) {
       case "system": {
         if (!systemMessagesAllowed) {
-          throw new import_provider2.UnsupportedFunctionalityError({
+          throw new UnsupportedFunctionalityError({
             functionality: "system messages are only supported at the beginning of the conversation"
           });
         }
@@ -541,16 +574,16 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                     fileUri: part.data.toString()
                   }
                 });
-              } else if ((0, import_provider_utils4.isProviderReference)(part.data)) {
+              } else if (isProviderReference(part.data)) {
                 if (providerOptionsName === "vertex") {
-                  throw new import_provider2.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError({
                     functionality: "file parts with provider references"
                   });
                 }
                 parts.push({
                   fileData: {
                     mimeType: mediaType,
-                    fileUri: (0, import_provider_utils4.resolveProviderReference)({
+                    fileUri: resolveProviderReference({
                       reference: part.data,
                       provider: "google"
                     })
@@ -560,7 +593,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                 parts.push({
                   inlineData: {
                     mimeType: mediaType,
-                    data: (0, import_provider_utils4.convertToBase64)(part.data)
+                    data: convertToBase64(part.data)
                   }
                 });
               }
@@ -595,14 +628,14 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
               }
               case "reasoning-file": {
                 if (part.data instanceof URL) {
-                  throw new import_provider2.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError({
                     functionality: "File data URLs in assistant messages are not supported"
                   });
                 }
                 return {
                   inlineData: {
                     mimeType: part.mediaType,
-                    data: (0, import_provider_utils4.convertToBase64)(part.data)
+                    data: convertToBase64(part.data)
                   },
                   thought: true,
                   thoughtSignature
@@ -610,20 +643,20 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
               }
               case "file": {
                 if (part.data instanceof URL) {
-                  throw new import_provider2.UnsupportedFunctionalityError({
+                  throw new UnsupportedFunctionalityError({
                     functionality: "File data URLs in assistant messages are not supported"
                   });
                 }
-                if ((0, import_provider_utils4.isProviderReference)(part.data)) {
+                if (isProviderReference(part.data)) {
                   if (providerOptionsName === "vertex") {
-                    throw new import_provider2.UnsupportedFunctionalityError({
+                    throw new UnsupportedFunctionalityError({
                       functionality: "file parts with provider references"
                     });
                   }
                   return {
                     fileData: {
                       mimeType: part.mediaType,
-                      fileUri: (0, import_provider_utils4.resolveProviderReference)({
+                      fileUri: resolveProviderReference({
                         reference: part.data,
                         provider: "google"
                       })
@@ -635,7 +668,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                 return {
                   inlineData: {
                     mimeType: part.mediaType,
-                    data: (0, import_provider_utils4.convertToBase64)(part.data)
+                    data: convertToBase64(part.data)
                   },
                   ...(providerOpts == null ? void 0 : providerOpts.thought) === true ? { thought: true } : {},
                   thoughtSignature
@@ -752,24 +785,24 @@ function getModelPath(modelId) {
 }
 
 // src/google-generative-ai-options.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
-var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
-  () => (0, import_provider_utils5.zodSchema)(
-    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(),
+import { lazySchema as lazySchema4, zodSchema as zodSchema4 } from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
+var googleLanguageModelOptions = lazySchema4(
+  () => zodSchema4(
+    z4.object({
+      responseModalities: z4.array(z4.enum(["TEXT", "IMAGE"])).optional(),
+      thinkingConfig: z4.object({
+        thinkingBudget: z4.number().optional(),
+        includeThoughts: z4.boolean().optional(),
         // https://ai.google.dev/gemini-api/docs/gemini-3?thinking=high#thinking_level
-        thinkingLevel: import_v44.z.enum(["minimal", "low", "medium", "high"]).optional()
+        thinkingLevel: z4.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_v44.z.string().optional(),
+      cachedContent: z4.string().optional(),
       /**
        * Optional. Enable structured output. Default is true.
        *
@@ -778,13 +811,13 @@ var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
        * Google Generative AI uses. You can use this to disable
        * structured outputs if you need to.
        */
-      structuredOutputs: import_v44.z.boolean().optional(),
+      structuredOutputs: z4.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([
+      safetySettings: z4.array(
+        z4.object({
+          category: z4.enum([
             "HARM_CATEGORY_UNSPECIFIED",
             "HARM_CATEGORY_HATE_SPEECH",
             "HARM_CATEGORY_DANGEROUS_CONTENT",
@@ -792,7 +825,7 @@ var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
             "HARM_CATEGORY_SEXUALLY_EXPLICIT",
             "HARM_CATEGORY_CIVIC_INTEGRITY"
           ]),
-          threshold: import_v44.z.enum([
+          threshold: z4.enum([
             "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
             "BLOCK_LOW_AND_ABOVE",
             "BLOCK_MEDIUM_AND_ABOVE",
@@ -802,7 +835,7 @@ var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
           ])
         })
       ).optional(),
-      threshold: import_v44.z.enum([
+      threshold: z4.enum([
         "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
         "BLOCK_LOW_AND_ABOVE",
         "BLOCK_MEDIUM_AND_ABOVE",
@@ -815,19 +848,19 @@ var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
        *
        * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
        */
-      audioTimestamp: import_v44.z.boolean().optional(),
+      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: import_v44.z.record(import_v44.z.string(), import_v44.z.string()).optional(),
+      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: import_v44.z.enum([
+      mediaResolution: z4.enum([
         "MEDIA_RESOLUTION_UNSPECIFIED",
         "MEDIA_RESOLUTION_LOW",
         "MEDIA_RESOLUTION_MEDIUM",
@@ -838,8 +871,8 @@ var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
        *
        * https://ai.google.dev/gemini-api/docs/image-generation#aspect_ratios
        */
-      imageConfig: import_v44.z.object({
-        aspectRatio: import_v44.z.enum([
+      imageConfig: z4.object({
+        aspectRatio: z4.enum([
           "1:1",
           "2:3",
           "3:2",
@@ -855,7 +888,7 @@ var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
           "1:4",
           "4:1"
         ]).optional(),
-        imageSize: import_v44.z.enum(["1K", "2K", "4K", "512"]).optional()
+        imageSize: z4.enum(["1K", "2K", "4K", "512"]).optional()
       }).optional(),
       /**
        * Optional. Configuration for grounding retrieval.
@@ -863,10 +896,10 @@ var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
        *
        * https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-maps
        */
-      retrievalConfig: import_v44.z.object({
-        latLng: import_v44.z.object({
-          latitude: import_v44.z.number(),
-          longitude: import_v44.z.number()
+      retrievalConfig: z4.object({
+        latLng: z4.object({
+          latitude: z4.number(),
+          longitude: z4.number()
         }).optional()
       }).optional(),
       /**
@@ -879,11 +912,11 @@ var googleLanguageModelOptions = (0, import_provider_utils5.lazySchema)(
        *
        * https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/function-calling#streaming-fc
        */
-      streamFunctionCallArguments: import_v44.z.boolean().optional(),
+      streamFunctionCallArguments: z4.boolean().optional(),
       /**
        * Optional. The service tier to use for the request.
        */
-      serviceTier: import_v44.z.enum(["standard", "flex", "priority"]).optional()
+      serviceTier: z4.enum(["standard", "flex", "priority"]).optional()
     })
   )
 );
@@ -894,7 +927,9 @@ var VertexServiceTierMap = {
 };
 
 // src/google-prepare-tools.ts
-var import_provider3 = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 function prepareTools({
   tools,
   toolChoice,
@@ -1136,7 +1171,7 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider3.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
@@ -1393,13 +1428,22 @@ function mapGoogleGenerativeAIFinishReason({
 }
 
 // src/google-generative-ai-language-model.ts
-var GoogleGenerativeAILanguageModel = class {
+var GoogleGenerativeAILanguageModel = class _GoogleGenerativeAILanguageModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     var _a;
     this.modelId = modelId;
     this.config = config;
-    this.generateId = (_a = config.generateId) != null ? _a : import_provider_utils6.generateId;
+    this.generateId = (_a = config.generateId) != null ? _a : generateId;
+  }
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _GoogleGenerativeAILanguageModel(options.modelId, options.config);
   }
   get provider() {
     return this.config.provider;
@@ -1427,13 +1471,13 @@ var GoogleGenerativeAILanguageModel = class {
     var _a, _b;
     const warnings = [];
     const providerOptionsName = this.config.provider.includes("vertex") ? "vertex" : "google";
-    let googleOptions = await (0, import_provider_utils6.parseProviderOptions)({
+    let googleOptions = await parseProviderOptions2({
       provider: providerOptionsName,
       providerOptions,
       schema: googleLanguageModelOptions
     });
     if (googleOptions == null && providerOptionsName !== "google") {
-      googleOptions = await (0, import_provider_utils6.parseProviderOptions)({
+      googleOptions = await parseProviderOptions2({
         provider: "google",
         providerOptions,
         schema: googleLanguageModelOptions
@@ -1543,22 +1587,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_utils6.combineHeaders)(
-      await (0, import_provider_utils6.resolve)(this.config.headers),
+    const mergedHeaders = combineHeaders2(
+      this.config.headers ? await resolve2(this.config.headers) : void 0,
       options.headers
     );
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils6.postJsonToApi)({
+    } = await postJsonToApi2({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:generateContent`,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(responseSchema),
+      successfulResponseHandler: createJsonResponseHandler2(responseSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -1725,18 +1769,18 @@ var GoogleGenerativeAILanguageModel = class {
       options,
       { isStreaming: true }
     );
-    const headers = (0, import_provider_utils6.combineHeaders)(
-      await (0, import_provider_utils6.resolve)(this.config.headers),
+    const headers = combineHeaders2(
+      this.config.headers ? await resolve2(this.config.headers) : void 0,
       options.headers
     );
-    const { responseHeaders, value: response } = await (0, import_provider_utils6.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi2({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:streamGenerateContent?alt=sse`,
       headers,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils6.createEventSourceResponseHandler)(chunkSchema),
+      successfulResponseHandler: createEventSourceResponseHandler(chunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -2132,7 +2176,7 @@ function resolveThinkingConfig({
   modelId,
   warnings
 }) {
-  if (!(0, import_provider_utils6.isCustomReasoning)(reasoning)) {
+  if (!isCustomReasoning(reasoning)) {
     return void 0;
   }
   if (isGemini3Model(modelId) && !modelId.includes("gemini-3-pro-image")) {
@@ -2147,7 +2191,7 @@ function resolveGemini3ThinkingConfig({
   if (reasoning === "none") {
     return { thinkingLevel: "minimal" };
   }
-  const thinkingLevel = (0, import_provider_utils6.mapReasoningToProviderEffort)({
+  const thinkingLevel = mapReasoningToProviderEffort({
     reasoning,
     effortMap: {
       minimal: "minimal",
@@ -2171,7 +2215,7 @@ function resolveGemini25ThinkingConfig({
   if (reasoning === "none") {
     return { thinkingBudget: 0 };
   }
-  const thinkingBudget = (0, import_provider_utils6.mapReasoningToProviderBudget)({
+  const thinkingBudget = mapReasoningToProviderBudget({
     reasoning,
     maxOutputTokens: getMaxOutputTokensForGemini25Model(),
     maxReasoningBudget: getMaxThinkingTokensForGemini25Model(modelId),
@@ -2277,270 +2321,286 @@ function extractSources({
   }
   return sources.length > 0 ? sources : void 0;
 }
-var getGroundingMetadataSchema = () => import_v45.z.object({
-  webSearchQueries: import_v45.z.array(import_v45.z.string()).nullish(),
-  imageSearchQueries: 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(
-    import_v45.z.object({
-      web: import_v45.z.object({ uri: import_v45.z.string(), title: import_v45.z.string().nullish() }).nullish(),
-      image: import_v45.z.object({
-        sourceUri: import_v45.z.string(),
-        imageUri: import_v45.z.string(),
-        title: import_v45.z.string().nullish(),
-        domain: import_v45.z.string().nullish()
+var getGroundingMetadataSchema = () => z5.object({
+  webSearchQueries: z5.array(z5.string()).nullish(),
+  imageSearchQueries: 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() }).nullish(),
+      image: z5.object({
+        sourceUri: z5.string(),
+        imageUri: z5.string(),
+        title: z5.string().nullish(),
+        domain: z5.string().nullish()
       }).nullish(),
-      retrievedContext: import_v45.z.object({
-        uri: import_v45.z.string().nullish(),
-        title: import_v45.z.string().nullish(),
-        text: import_v45.z.string().nullish(),
-        fileSearchStore: import_v45.z.string().nullish()
+      retrievedContext: z5.object({
+        uri: z5.string().nullish(),
+        title: z5.string().nullish(),
+        text: z5.string().nullish(),
+        fileSearchStore: z5.string().nullish()
       }).nullish(),
-      maps: import_v45.z.object({
-        uri: import_v45.z.string().nullish(),
-        title: import_v45.z.string().nullish(),
-        text: import_v45.z.string().nullish(),
-        placeId: import_v45.z.string().nullish()
+      maps: z5.object({
+        uri: z5.string().nullish(),
+        title: z5.string().nullish(),
+        text: z5.string().nullish(),
+        placeId: z5.string().nullish()
       }).nullish()
     })
   ).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()
+  groundingSupports: z5.array(
+    z5.object({
+      segment: z5.object({
+        startIndex: z5.number().nullish(),
+        endIndex: z5.number().nullish(),
+        text: z5.string().nullish()
       }).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()
+      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: import_v45.z.union([
-    import_v45.z.object({
-      webDynamicRetrievalScore: import_v45.z.number()
+  retrievalMetadata: z5.union([
+    z5.object({
+      webDynamicRetrievalScore: z5.number()
     }),
-    import_v45.z.object({})
+    z5.object({})
   ]).nullish()
 });
-var partialArgSchema = import_v45.z.object({
-  jsonPath: import_v45.z.string(),
-  stringValue: import_v45.z.string().nullish(),
-  numberValue: import_v45.z.number().nullish(),
-  boolValue: import_v45.z.boolean().nullish(),
-  nullValue: import_v45.z.unknown().nullish(),
-  willContinue: import_v45.z.boolean().nullish()
+var partialArgSchema = z5.object({
+  jsonPath: z5.string(),
+  stringValue: z5.string().nullish(),
+  numberValue: z5.number().nullish(),
+  boolValue: z5.boolean().nullish(),
+  nullValue: z5.unknown().nullish(),
+  willContinue: z5.boolean().nullish()
 });
-var getContentSchema = () => import_v45.z.object({
-  parts: import_v45.z.array(
-    import_v45.z.union([
+var getContentSchema = () => z5.object({
+  parts: z5.array(
+    z5.union([
       // note: order matters since text can be fully empty
-      import_v45.z.object({
-        functionCall: import_v45.z.object({
-          name: import_v45.z.string().nullish(),
-          args: import_v45.z.unknown().nullish(),
-          partialArgs: import_v45.z.array(partialArgSchema).nullish(),
-          willContinue: import_v45.z.boolean().nullish()
+      z5.object({
+        functionCall: z5.object({
+          name: z5.string().nullish(),
+          args: z5.unknown().nullish(),
+          partialArgs: z5.array(partialArgSchema).nullish(),
+          willContinue: z5.boolean().nullish()
         }),
-        thoughtSignature: import_v45.z.string().nullish()
+        thoughtSignature: z5.string().nullish()
       }),
-      import_v45.z.object({
-        inlineData: import_v45.z.object({
-          mimeType: import_v45.z.string(),
-          data: import_v45.z.string()
+      z5.object({
+        inlineData: z5.object({
+          mimeType: z5.string(),
+          data: z5.string()
         }),
-        thought: import_v45.z.boolean().nullish(),
-        thoughtSignature: import_v45.z.string().nullish()
+        thought: z5.boolean().nullish(),
+        thoughtSignature: z5.string().nullish()
       }),
-      import_v45.z.object({
-        toolCall: import_v45.z.object({
-          toolType: import_v45.z.string(),
-          args: import_v45.z.unknown().nullish(),
-          id: import_v45.z.string()
+      z5.object({
+        toolCall: z5.object({
+          toolType: z5.string(),
+          args: z5.unknown().nullish(),
+          id: z5.string()
         }),
-        thoughtSignature: import_v45.z.string().nullish()
+        thoughtSignature: z5.string().nullish()
       }),
-      import_v45.z.object({
-        toolResponse: import_v45.z.object({
-          toolType: import_v45.z.string(),
-          response: import_v45.z.unknown().nullish(),
-          id: import_v45.z.string()
+      z5.object({
+        toolResponse: z5.object({
+          toolType: z5.string(),
+          response: z5.unknown().nullish(),
+          id: z5.string()
         }),
-        thoughtSignature: import_v45.z.string().nullish()
+        thoughtSignature: z5.string().nullish()
       }),
-      import_v45.z.object({
-        executableCode: import_v45.z.object({
-          language: import_v45.z.string(),
-          code: import_v45.z.string()
+      z5.object({
+        executableCode: z5.object({
+          language: z5.string(),
+          code: z5.string()
         }).nullish(),
-        codeExecutionResult: import_v45.z.object({
-          outcome: import_v45.z.string(),
-          output: import_v45.z.string().nullish()
+        codeExecutionResult: z5.object({
+          outcome: z5.string(),
+          output: z5.string().nullish()
         }).nullish(),
-        text: import_v45.z.string().nullish(),
-        thought: import_v45.z.boolean().nullish(),
-        thoughtSignature: import_v45.z.string().nullish()
+        text: z5.string().nullish(),
+        thought: z5.boolean().nullish(),
+        thoughtSignature: z5.string().nullish()
       })
     ])
   ).nullish()
 });
-var getSafetyRatingSchema = () => import_v45.z.object({
-  category: import_v45.z.string().nullish(),
-  probability: import_v45.z.string().nullish(),
-  probabilityScore: import_v45.z.number().nullish(),
-  severity: import_v45.z.string().nullish(),
-  severityScore: import_v45.z.number().nullish(),
-  blocked: import_v45.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 tokenDetailsSchema = import_v45.z.array(
-  import_v45.z.object({
-    modality: import_v45.z.string(),
-    tokenCount: import_v45.z.number()
+var tokenDetailsSchema = z5.array(
+  z5.object({
+    modality: z5.string(),
+    tokenCount: z5.number()
   })
 ).nullish();
-var usageSchema = import_v45.z.object({
-  cachedContentTokenCount: import_v45.z.number().nullish(),
-  thoughtsTokenCount: import_v45.z.number().nullish(),
-  promptTokenCount: import_v45.z.number().nullish(),
-  candidatesTokenCount: import_v45.z.number().nullish(),
-  totalTokenCount: import_v45.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(),
   // https://cloud.google.com/vertex-ai/generative-ai/docs/reference/rest/v1/GenerateContentResponse#TrafficType
-  trafficType: import_v45.z.string().nullish(),
+  trafficType: z5.string().nullish(),
   // https://ai.google.dev/api/generate-content#Modality
   promptTokensDetails: tokenDetailsSchema,
   candidatesTokensDetails: tokenDetailsSchema
 });
-var getUrlContextMetadataSchema = () => import_v45.z.object({
-  urlMetadata: import_v45.z.array(
-    import_v45.z.object({
-      retrievedUrl: import_v45.z.string(),
-      urlRetrievalStatus: import_v45.z.string()
+var getUrlContextMetadataSchema = () => z5.object({
+  urlMetadata: z5.array(
+    z5.object({
+      retrievedUrl: z5.string(),
+      urlRetrievalStatus: z5.string()
     })
   ).nullish()
 });
-var responseSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    import_v45.z.object({
-      candidates: import_v45.z.array(
-        import_v45.z.object({
-          content: getContentSchema().nullish().or(import_v45.z.object({}).strict()),
-          finishReason: import_v45.z.string().nullish(),
-          finishMessage: import_v45.z.string().nullish(),
-          safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish(),
+var responseSchema = lazySchema5(
+  () => zodSchema5(
+    z5.object({
+      candidates: z5.array(
+        z5.object({
+          content: getContentSchema().nullish().or(z5.object({}).strict()),
+          finishReason: z5.string().nullish(),
+          finishMessage: z5.string().nullish(),
+          safetyRatings: z5.array(getSafetyRatingSchema()).nullish(),
           groundingMetadata: getGroundingMetadataSchema().nullish(),
           urlContextMetadata: getUrlContextMetadataSchema().nullish()
         })
       ),
       usageMetadata: usageSchema.nullish(),
-      promptFeedback: import_v45.z.object({
-        blockReason: import_v45.z.string().nullish(),
-        safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish()
+      promptFeedback: z5.object({
+        blockReason: z5.string().nullish(),
+        safetyRatings: z5.array(getSafetyRatingSchema()).nullish()
       }).nullish(),
-      serviceTier: import_v45.z.string().nullish()
+      serviceTier: z5.string().nullish()
     })
   )
 );
-var chunkSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    import_v45.z.object({
-      candidates: import_v45.z.array(
-        import_v45.z.object({
+var chunkSchema = lazySchema5(
+  () => zodSchema5(
+    z5.object({
+      candidates: z5.array(
+        z5.object({
           content: getContentSchema().nullish(),
-          finishReason: import_v45.z.string().nullish(),
-          finishMessage: import_v45.z.string().nullish(),
-          safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish(),
+          finishReason: z5.string().nullish(),
+          finishMessage: z5.string().nullish(),
+          safetyRatings: z5.array(getSafetyRatingSchema()).nullish(),
           groundingMetadata: getGroundingMetadataSchema().nullish(),
           urlContextMetadata: getUrlContextMetadataSchema().nullish()
         })
       ).nullish(),
       usageMetadata: usageSchema.nullish(),
-      promptFeedback: import_v45.z.object({
-        blockReason: import_v45.z.string().nullish(),
-        safetyRatings: import_v45.z.array(getSafetyRatingSchema()).nullish()
+      promptFeedback: z5.object({
+        blockReason: z5.string().nullish(),
+        safetyRatings: z5.array(getSafetyRatingSchema()).nullish()
       }).nullish(),
-      serviceTier: import_v45.z.string().nullish()
+      serviceTier: z5.string().nullish()
     })
   )
 );
 
 // src/tool/code-execution.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var codeExecution = (0, import_provider_utils7.createProviderToolFactoryWithOutputSchema)({
+import { createProviderToolFactoryWithOutputSchema } from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var codeExecution = createProviderToolFactoryWithOutputSchema({
   id: "google.code_execution",
-  inputSchema: import_v46.z.object({
-    language: import_v46.z.string().describe("The programming language of the code."),
-    code: import_v46.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_v46.z.object({
-    outcome: import_v46.z.string().describe('The outcome of the execution (e.g., "OUTCOME_OK").'),
-    output: import_v46.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/enterprise-web-search.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_v47 = require("zod/v4");
-var enterpriseWebSearch = (0, import_provider_utils8.createProviderToolFactory)({
+import {
+  createProviderToolFactory,
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema6
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var enterpriseWebSearch = createProviderToolFactory({
   id: "google.enterprise_web_search",
-  inputSchema: (0, import_provider_utils8.lazySchema)(() => (0, import_provider_utils8.zodSchema)(import_v47.z.object({})))
+  inputSchema: lazySchema6(() => zodSchema6(z7.object({})))
 });
 
 // src/tool/file-search.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
-var import_v48 = require("zod/v4");
-var fileSearchArgsBaseSchema = import_v48.z.object({
+import {
+  createProviderToolFactory as createProviderToolFactory2,
+  lazySchema as lazySchema7,
+  zodSchema as zodSchema7
+} from "@ai-sdk/provider-utils";
+import { z as z8 } from "zod/v4";
+var fileSearchArgsBaseSchema = z8.object({
   /** The names of the file_search_stores to retrieve from.
    *  Example: `fileSearchStores/my-file-search-store-123`
    */
-  fileSearchStoreNames: import_v48.z.array(import_v48.z.string()).describe(
+  fileSearchStoreNames: z8.array(z8.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_v48.z.number().int().positive().describe("The number of file search retrieval chunks to retrieve.").optional(),
+  topK: z8.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_v48.z.string().describe(
+  metadataFilter: z8.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_utils9.lazySchema)(
-  () => (0, import_provider_utils9.zodSchema)(fileSearchArgsBaseSchema)
+var fileSearchArgsSchema = lazySchema7(
+  () => zodSchema7(fileSearchArgsBaseSchema)
 );
-var fileSearch = (0, import_provider_utils9.createProviderToolFactory)({
+var fileSearch = createProviderToolFactory2({
   id: "google.file_search",
   inputSchema: fileSearchArgsSchema
 });
 
 // src/tool/google-maps.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var import_v49 = require("zod/v4");
-var googleMaps = (0, import_provider_utils10.createProviderToolFactory)({
+import {
+  createProviderToolFactory as createProviderToolFactory3,
+  lazySchema as lazySchema8,
+  zodSchema as zodSchema8
+} from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+var googleMaps = createProviderToolFactory3({
   id: "google.google_maps",
-  inputSchema: (0, import_provider_utils10.lazySchema)(() => (0, import_provider_utils10.zodSchema)(import_v49.z.object({})))
+  inputSchema: lazySchema8(() => zodSchema8(z9.object({})))
 });
 
 // src/tool/google-search.ts
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
-var import_v410 = require("zod/v4");
-var googleSearchToolArgsBaseSchema = import_v410.z.object({
-  searchTypes: import_v410.z.object({
-    webSearch: import_v410.z.object({}).optional(),
-    imageSearch: import_v410.z.object({}).optional()
+import {
+  createProviderToolFactory as createProviderToolFactory4,
+  lazySchema as lazySchema9,
+  zodSchema as zodSchema9
+} from "@ai-sdk/provider-utils";
+import { z as z10 } from "zod/v4";
+var googleSearchToolArgsBaseSchema = z10.object({
+  searchTypes: z10.object({
+    webSearch: z10.object({}).optional(),
+    imageSearch: z10.object({}).optional()
   }).optional(),
-  timeRangeFilter: import_v410.z.object({
-    startTime: import_v410.z.string(),
-    endTime: import_v410.z.string()
+  timeRangeFilter: z10.object({
+    startTime: z10.string(),
+    endTime: z10.string()
   }).optional()
 }).passthrough();
-var googleSearchToolArgsSchema = (0, import_provider_utils11.lazySchema)(
-  () => (0, import_provider_utils11.zodSchema)(googleSearchToolArgsBaseSchema)
+var googleSearchToolArgsSchema = lazySchema9(
+  () => zodSchema9(googleSearchToolArgsBaseSchema)
 );
-var googleSearch = (0, import_provider_utils11.createProviderToolFactory)(
+var googleSearch = createProviderToolFactory4(
   {
     id: "google.google_search",
     inputSchema: googleSearchToolArgsSchema
@@ -2548,21 +2608,25 @@ var googleSearch = (0, import_provider_utils11.createProviderToolFactory)(
 );
 
 // src/tool/url-context.ts
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
-var import_v411 = require("zod/v4");
-var urlContext = (0, import_provider_utils12.createProviderToolFactory)({
+import {
+  createProviderToolFactory as createProviderToolFactory5,
+  lazySchema as lazySchema10,
+  zodSchema as zodSchema10
+} from "@ai-sdk/provider-utils";
+import { z as z11 } from "zod/v4";
+var urlContext = createProviderToolFactory5({
   id: "google.url_context",
-  inputSchema: (0, import_provider_utils12.lazySchema)(() => (0, import_provider_utils12.zodSchema)(import_v411.z.object({})))
+  inputSchema: lazySchema10(() => zodSchema10(z11.object({})))
 });
 
 // src/tool/vertex-rag-store.ts
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
-var import_v412 = require("zod/v4");
-var vertexRagStore = (0, import_provider_utils13.createProviderToolFactory)({
+import { createProviderToolFactory as createProviderToolFactory6 } from "@ai-sdk/provider-utils";
+import { z as z12 } from "zod/v4";
+var vertexRagStore = createProviderToolFactory6({
   id: "google.vertex_rag_store",
-  inputSchema: import_v412.z.object({
-    ragCorpus: import_v412.z.string(),
-    topK: import_v412.z.number().optional()
+  inputSchema: z12.object({
+    ragCorpus: z12.string(),
+    topK: z12.number().optional()
   })
 });
 
@@ -2627,15 +2691,41 @@ var googleTools = {
 };
 
 // src/google-generative-ai-image-model.ts
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
-var import_v413 = require("zod/v4");
-var GoogleGenerativeAIImageModel = class {
+import {
+  combineHeaders as combineHeaders3,
+  convertToBase64 as convertToBase642,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  generateId as defaultGenerateId,
+  lazySchema as lazySchema11,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve3,
+  serializeModelOptions as serializeModelOptions3,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3,
+  zodSchema as zodSchema11
+} from "@ai-sdk/provider-utils";
+import { z as z13 } from "zod/v4";
+var GoogleGenerativeAIImageModel = class _GoogleGenerativeAIImageModel {
   constructor(modelId, settings, config) {
     this.modelId = modelId;
     this.settings = settings;
     this.config = config;
     this.specificationVersion = "v4";
   }
+  static [WORKFLOW_SERIALIZE3](model) {
+    return serializeModelOptions3({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE3](options) {
+    return new _GoogleGenerativeAIImageModel(
+      options.modelId,
+      {},
+      options.config
+    );
+  }
   get maxImagesPerCall() {
     if (this.settings.maxImagesPerCall != null) {
       return this.settings.maxImagesPerCall;
@@ -2693,7 +2783,7 @@ var GoogleGenerativeAIImageModel = class {
         details: "This model does not support the `seed` option through this provider."
       });
     }
-    const googleOptions = await (0, import_provider_utils14.parseProviderOptions)({
+    const googleOptions = await parseProviderOptions3({
       provider: "google",
       providerOptions,
       schema: googleImageModelOptionsSchema
@@ -2712,12 +2802,15 @@ var GoogleGenerativeAIImageModel = class {
       instances: [{ prompt }],
       parameters
     };
-    const { responseHeaders, value: response } = await (0, import_provider_utils14.postJsonToApi)({
+    const { responseHeaders, value: response } = await postJsonToApi3({
       url: `${this.config.baseURL}/models/${this.modelId}:predict`,
-      headers: (0, import_provider_utils14.combineHeaders)(await (0, import_provider_utils14.resolve)(this.config.headers), headers),
+      headers: combineHeaders3(
+        this.config.headers ? await resolve3(this.config.headers) : void 0,
+        headers
+      ),
       body,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils14.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         googleImageResponseSchema
       ),
       abortSignal,
@@ -2803,7 +2896,7 @@ var GoogleGenerativeAIImageModel = class {
       baseURL: this.config.baseURL,
       headers: (_a = this.config.headers) != null ? _a : {},
       fetch: this.config.fetch,
-      generateId: (_b = this.config.generateId) != null ? _b : import_provider_utils14.generateId
+      generateId: (_b = this.config.generateId) != null ? _b : defaultGenerateId
     });
     const result = await languageModel.doGenerate({
       prompt: languageModelPrompt,
@@ -2824,7 +2917,7 @@ var GoogleGenerativeAIImageModel = class {
     const images = [];
     for (const part of result.content) {
       if (part.type === "file" && part.mediaType.startsWith("image/")) {
-        images.push((0, import_provider_utils14.convertToBase64)(part.data));
+        images.push(convertToBase642(part.data));
       }
     }
     return {
@@ -2851,26 +2944,36 @@ var GoogleGenerativeAIImageModel = class {
 function isGeminiModel(modelId) {
   return modelId.startsWith("gemini-");
 }
-var googleImageResponseSchema = (0, import_provider_utils14.lazySchema)(
-  () => (0, import_provider_utils14.zodSchema)(
-    import_v413.z.object({
-      predictions: import_v413.z.array(import_v413.z.object({ bytesBase64Encoded: import_v413.z.string() })).default([])
+var googleImageResponseSchema = lazySchema11(
+  () => zodSchema11(
+    z13.object({
+      predictions: z13.array(z13.object({ bytesBase64Encoded: z13.string() })).default([])
     })
   )
 );
-var googleImageModelOptionsSchema = (0, import_provider_utils14.lazySchema)(
-  () => (0, import_provider_utils14.zodSchema)(
-    import_v413.z.object({
-      personGeneration: import_v413.z.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-      aspectRatio: import_v413.z.enum(["1:1", "3:4", "4:3", "9:16", "16:9"]).nullish()
+var googleImageModelOptionsSchema = lazySchema11(
+  () => zodSchema11(
+    z13.object({
+      personGeneration: z13.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      aspectRatio: z13.enum(["1:1", "3:4", "4:3", "9:16", "16:9"]).nullish()
     })
   )
 );
 
 // src/google-generative-ai-files.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
-var import_v414 = require("zod/v4");
+import {
+  AISDKError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders4,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  delay,
+  lazySchema as lazySchema12,
+  parseProviderOptions as parseProviderOptions4,
+  zodSchema as zodSchema12,
+  getFromApi
+} from "@ai-sdk/provider-utils";
+import { z as z14 } from "zod/v4";
 var GoogleGenerativeAIFiles = class {
   constructor(config) {
     this.config = config;
@@ -2881,7 +2984,7 @@ var GoogleGenerativeAIFiles = class {
   }
   async uploadFile(options) {
     var _a, _b, _c, _d;
-    const googleOptions = await (0, import_provider_utils15.parseProviderOptions)({
+    const googleOptions = await parseProviderOptions4({
       provider: "google",
       providerOptions: options.providerOptions,
       schema: googleFilesUploadOptionsSchema
@@ -2915,14 +3018,14 @@ var GoogleGenerativeAIFiles = class {
     });
     if (!initResponse.ok) {
       const errorBody = await initResponse.text();
-      throw new import_provider4.AISDKError({
+      throw new AISDKError({
         name: "GOOGLE_FILES_UPLOAD_ERROR",
         message: `Failed to initiate resumable upload: ${initResponse.status} ${errorBody}`
       });
     }
     const uploadUrl = initResponse.headers.get("x-goog-upload-url");
     if (!uploadUrl) {
-      throw new import_provider4.AISDKError({
+      throw new AISDKError({
         name: "GOOGLE_FILES_UPLOAD_ERROR",
         message: "No upload URL returned from initiation request"
       });
@@ -2938,7 +3041,7 @@ var GoogleGenerativeAIFiles = class {
     });
     if (!uploadResponse.ok) {
       const errorBody = await uploadResponse.text();
-      throw new import_provider4.AISDKError({
+      throw new AISDKError({
         name: "GOOGLE_FILES_UPLOAD_ERROR",
         message: `Failed to upload file data: ${uploadResponse.status} ${errorBody}`
       });
@@ -2950,16 +3053,16 @@ var GoogleGenerativeAIFiles = class {
     const startTime = Date.now();
     while (file.state === "PROCESSING") {
       if (Date.now() - startTime > pollTimeoutMs) {
-        throw new import_provider4.AISDKError({
+        throw new AISDKError({
           name: "GOOGLE_FILES_UPLOAD_TIMEOUT",
           message: `File processing timed out after ${pollTimeoutMs}ms`
         });
       }
-      await (0, import_provider_utils15.delay)(pollIntervalMs);
-      const { value: fileStatus } = await (0, import_provider_utils15.getFromApi)({
+      await delay(pollIntervalMs);
+      const { value: fileStatus } = await getFromApi({
         url: `${this.config.baseURL}/${file.name}`,
-        headers: (0, import_provider_utils15.combineHeaders)(resolvedHeaders),
-        successfulResponseHandler: (0, import_provider_utils15.createJsonResponseHandler)(
+        headers: combineHeaders4(resolvedHeaders),
+        successfulResponseHandler: createJsonResponseHandler4(
           googleFileResponseSchema
         ),
         failedResponseHandler: googleFailedResponseHandler,
@@ -2968,7 +3071,7 @@ var GoogleGenerativeAIFiles = class {
       file = fileStatus;
     }
     if (file.state === "FAILED") {
-      throw new import_provider4.AISDKError({
+      throw new AISDKError({
         name: "GOOGLE_FILES_UPLOAD_FAILED",
         message: `File processing failed for ${file.name}`
       });
@@ -2994,36 +3097,49 @@ var GoogleGenerativeAIFiles = class {
     };
   }
 };
-var googleFileResponseSchema = (0, import_provider_utils15.lazySchema)(
-  () => (0, import_provider_utils15.zodSchema)(
-    import_v414.z.object({
-      name: import_v414.z.string(),
-      displayName: import_v414.z.string().nullish(),
-      mimeType: import_v414.z.string(),
-      sizeBytes: import_v414.z.string().nullish(),
-      createTime: import_v414.z.string().nullish(),
-      updateTime: import_v414.z.string().nullish(),
-      expirationTime: import_v414.z.string().nullish(),
-      sha256Hash: import_v414.z.string().nullish(),
-      uri: import_v414.z.string(),
-      state: import_v414.z.string()
+var googleFileResponseSchema = lazySchema12(
+  () => zodSchema12(
+    z14.object({
+      name: z14.string(),
+      displayName: z14.string().nullish(),
+      mimeType: z14.string(),
+      sizeBytes: z14.string().nullish(),
+      createTime: z14.string().nullish(),
+      updateTime: z14.string().nullish(),
+      expirationTime: z14.string().nullish(),
+      sha256Hash: z14.string().nullish(),
+      uri: z14.string(),
+      state: z14.string()
     })
   )
 );
-var googleFilesUploadOptionsSchema = (0, import_provider_utils15.lazySchema)(
-  () => (0, import_provider_utils15.zodSchema)(
-    import_v414.z.object({
-      displayName: import_v414.z.string().nullish(),
-      pollIntervalMs: import_v414.z.number().positive().nullish(),
-      pollTimeoutMs: import_v414.z.number().positive().nullish()
+var googleFilesUploadOptionsSchema = lazySchema12(
+  () => zodSchema12(
+    z14.object({
+      displayName: z14.string().nullish(),
+      pollIntervalMs: z14.number().positive().nullish(),
+      pollTimeoutMs: z14.number().positive().nullish()
     }).passthrough()
   )
 );
 
 // src/google-generative-ai-video-model.ts
-var import_provider5 = require("@ai-sdk/provider");
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
-var import_v415 = require("zod/v4");
+import {
+  AISDKError as AISDKError2
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders5,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler as createJsonResponseHandler5,
+  delay as delay2,
+  getFromApi as getFromApi2,
+  lazySchema as lazySchema13,
+  parseProviderOptions as parseProviderOptions5,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve4,
+  zodSchema as zodSchema13
+} from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
 var GoogleGenerativeAIVideoModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -3040,7 +3156,7 @@ var GoogleGenerativeAIVideoModel = class {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     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 warnings = [];
-    const googleOptions = await (0, import_provider_utils16.parseProviderOptions)({
+    const googleOptions = await parseProviderOptions5({
       provider: "google",
       providerOptions: options.providerOptions,
       schema: googleVideoModelOptionsSchema
@@ -3058,7 +3174,7 @@ var GoogleGenerativeAIVideoModel = class {
           details: "Google Generative AI video models require base64-encoded images. URL will be ignored."
         });
       } else {
-        const base64Data = typeof options.image.data === "string" ? options.image.data : (0, import_provider_utils16.convertUint8ArrayToBase64)(options.image.data);
+        const base64Data = typeof options.image.data === "string" ? options.image.data : convertUint8ArrayToBase64(options.image.data);
         instance.image = {
           inlineData: {
             mimeType: options.image.mediaType || "image/png",
@@ -3124,17 +3240,17 @@ var GoogleGenerativeAIVideoModel = class {
         }
       }
     }
-    const { value: operation } = await (0, import_provider_utils16.postJsonToApi)({
+    const { value: operation } = await postJsonToApi4({
       url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
-      headers: (0, import_provider_utils16.combineHeaders)(
-        await (0, import_provider_utils16.resolve)(this.config.headers),
+      headers: combineHeaders5(
+        await resolve4(this.config.headers),
         options.headers
       ),
       body: {
         instances,
         parameters
       },
-      successfulResponseHandler: (0, import_provider_utils16.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler5(
         googleOperationSchema
       ),
       failedResponseHandler: googleFailedResponseHandler,
@@ -3143,7 +3259,7 @@ var GoogleGenerativeAIVideoModel = class {
     });
     const operationName = operation.name;
     if (!operationName) {
-      throw new import_provider5.AISDKError({
+      throw new AISDKError2({
         name: "GOOGLE_VIDEO_GENERATION_ERROR",
         message: "No operation name returned from API"
       });
@@ -3155,25 +3271,25 @@ var GoogleGenerativeAIVideoModel = class {
     let responseHeaders;
     while (!finalOperation.done) {
       if (Date.now() - startTime > pollTimeoutMs) {
-        throw new import_provider5.AISDKError({
+        throw new AISDKError2({
           name: "GOOGLE_VIDEO_GENERATION_TIMEOUT",
           message: `Video generation timed out after ${pollTimeoutMs}ms`
         });
       }
-      await (0, import_provider_utils16.delay)(pollIntervalMs);
+      await delay2(pollIntervalMs);
       if ((_f = options.abortSignal) == null ? void 0 : _f.aborted) {
-        throw new import_provider5.AISDKError({
+        throw new AISDKError2({
           name: "GOOGLE_VIDEO_GENERATION_ABORTED",
           message: "Video generation request was aborted"
         });
       }
-      const { value: statusOperation, responseHeaders: pollHeaders } = await (0, import_provider_utils16.getFromApi)({
+      const { value: statusOperation, responseHeaders: pollHeaders } = await getFromApi2({
         url: `${this.config.baseURL}/${operationName}`,
-        headers: (0, import_provider_utils16.combineHeaders)(
-          await (0, import_provider_utils16.resolve)(this.config.headers),
+        headers: combineHeaders5(
+          await resolve4(this.config.headers),
           options.headers
         ),
-        successfulResponseHandler: (0, import_provider_utils16.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler5(
           googleOperationSchema
         ),
         failedResponseHandler: googleFailedResponseHandler,
@@ -3184,21 +3300,21 @@ var GoogleGenerativeAIVideoModel = class {
       responseHeaders = pollHeaders;
     }
     if (finalOperation.error) {
-      throw new import_provider5.AISDKError({
+      throw new AISDKError2({
         name: "GOOGLE_VIDEO_GENERATION_FAILED",
         message: `Video generation failed: ${finalOperation.error.message}`
       });
     }
     const response = finalOperation.response;
     if (!((_g = response == null ? void 0 : response.generateVideoResponse) == null ? void 0 : _g.generatedSamples) || response.generateVideoResponse.generatedSamples.length === 0) {
-      throw new import_provider5.AISDKError({
+      throw new AISDKError2({
         name: "GOOGLE_VIDEO_GENERATION_ERROR",
         message: `No videos in response. Response: ${JSON.stringify(finalOperation)}`
       });
     }
     const videos = [];
     const videoMetadata = [];
-    const resolvedHeaders = await (0, import_provider_utils16.resolve)(this.config.headers);
+    const resolvedHeaders = await resolve4(this.config.headers);
     const apiKey = resolvedHeaders == null ? void 0 : resolvedHeaders["x-goog-api-key"];
     for (const generatedSample of response.generateVideoResponse.generatedSamples) {
       if ((_h = generatedSample.video) == null ? void 0 : _h.uri) {
@@ -3214,7 +3330,7 @@ var GoogleGenerativeAIVideoModel = class {
       }
     }
     if (videos.length === 0) {
-      throw new import_provider5.AISDKError({
+      throw new AISDKError2({
         name: "GOOGLE_VIDEO_GENERATION_ERROR",
         message: "No valid videos in response"
       });
@@ -3235,37 +3351,37 @@ var GoogleGenerativeAIVideoModel = class {
     };
   }
 };
-var googleOperationSchema = import_v415.z.object({
-  name: import_v415.z.string().nullish(),
-  done: import_v415.z.boolean().nullish(),
-  error: import_v415.z.object({
-    code: import_v415.z.number().nullish(),
-    message: import_v415.z.string(),
-    status: import_v415.z.string().nullish()
+var googleOperationSchema = z15.object({
+  name: z15.string().nullish(),
+  done: z15.boolean().nullish(),
+  error: z15.object({
+    code: z15.number().nullish(),
+    message: z15.string(),
+    status: z15.string().nullish()
   }).nullish(),
-  response: import_v415.z.object({
-    generateVideoResponse: import_v415.z.object({
-      generatedSamples: import_v415.z.array(
-        import_v415.z.object({
-          video: import_v415.z.object({
-            uri: import_v415.z.string().nullish()
+  response: z15.object({
+    generateVideoResponse: z15.object({
+      generatedSamples: z15.array(
+        z15.object({
+          video: z15.object({
+            uri: z15.string().nullish()
           }).nullish()
         })
       ).nullish()
     }).nullish()
   }).nullish()
 });
-var googleVideoModelOptionsSchema = (0, import_provider_utils16.lazySchema)(
-  () => (0, import_provider_utils16.zodSchema)(
-    import_v415.z.object({
-      pollIntervalMs: import_v415.z.number().positive().nullish(),
-      pollTimeoutMs: import_v415.z.number().positive().nullish(),
-      personGeneration: import_v415.z.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-      negativePrompt: import_v415.z.string().nullish(),
-      referenceImages: import_v415.z.array(
-        import_v415.z.object({
-          bytesBase64Encoded: import_v415.z.string().nullish(),
-          gcsUri: import_v415.z.string().nullish()
+var googleVideoModelOptionsSchema = lazySchema13(
+  () => zodSchema13(
+    z15.object({
+      pollIntervalMs: z15.number().positive().nullish(),
+      pollTimeoutMs: z15.number().positive().nullish(),
+      personGeneration: z15.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      negativePrompt: z15.string().nullish(),
+      referenceImages: z15.array(
+        z15.object({
+          bytesBase64Encoded: z15.string().nullish(),
+          gcsUri: z15.string().nullish()
         })
       ).nullish()
     }).passthrough()
@@ -3275,11 +3391,11 @@ var googleVideoModelOptionsSchema = (0, import_provider_utils16.lazySchema)(
 // src/google-provider.ts
 function createGoogleGenerativeAI(options = {}) {
   var _a, _b;
-  const baseURL = (_a = (0, import_provider_utils17.withoutTrailingSlash)(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
+  const baseURL = (_a = withoutTrailingSlash(options.baseURL)) != null ? _a : "https://generativelanguage.googleapis.com/v1beta";
   const providerName = (_b = options.name) != null ? _b : "google.generative-ai";
-  const getHeaders = () => (0, import_provider_utils17.withUserAgentSuffix)(
+  const getHeaders = () => withUserAgentSuffix(
     {
-      "x-goog-api-key": (0, import_provider_utils17.loadApiKey)({
+      "x-goog-api-key": loadApiKey({
         apiKey: options.apiKey,
         environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
         description: "Google Generative AI"
@@ -3294,7 +3410,7 @@ function createGoogleGenerativeAI(options = {}) {
       provider: providerName,
       baseURL,
       headers: getHeaders,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils17.generateId,
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId2,
       supportedUrls: () => ({
         "*": [
           // Google Generative Language "files" endpoint
@@ -3335,7 +3451,7 @@ function createGoogleGenerativeAI(options = {}) {
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils17.generateId
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId2
     });
   };
   const provider = function(modelId) {
@@ -3363,10 +3479,9 @@ function createGoogleGenerativeAI(options = {}) {
   return provider;
 }
 var google = createGoogleGenerativeAI();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   VERSION,
   createGoogleGenerativeAI,
   google
-});
+};
 //# sourceMappingURL=index.js.map