@ai-sdk/google 4.0.0-beta.9 → 4.0.0-canary.51

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 src_exports = {};
-__export(src_exports, {
-  VERSION: () => VERSION,
-  createGoogleGenerativeAI: () => createGoogleGenerativeAI,
-  google: () => google
-});
-module.exports = __toCommonJS(src_exports);
-
 // src/google-provider.ts
-var import_provider_utils16 = 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.9" : "0.0.0-test";
+var VERSION = true ? "4.0.0-canary.51" : "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");
+// src/google-embedding-model.ts
+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()
+// src/google-embedding-model-options.ts
+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 {
+// src/google-embedding-model.ts
+var GoogleEmbeddingModel = class _GoogleEmbeddingModel {
   constructor(modelId, config) {
     this.specificationVersion = "v4";
     this.maxEmbeddingsPerCall = 2048;
@@ -121,6 +118,15 @@ 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 _GoogleEmbeddingModel(options.modelId, options.config);
+  }
   get provider() {
     return this.config.provider;
   }
@@ -130,21 +136,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 +167,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 +179,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 +196,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 +215,7 @@ var GoogleGenerativeAIEmbeddingModel = class {
         })
       },
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         googleGenerativeAITextEmbeddingResponseSchema
       ),
       abortSignal,
@@ -223,27 +229,43 @@ 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");
+// src/google-language-model.ts
+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) {
+// src/convert-google-usage.ts
+function convertGoogleUsage(usage) {
   var _a, _b, _c, _d;
   if (usage == null) {
     return {
@@ -397,21 +419,151 @@ function isEmptyObjectSchema(jsonSchema) {
   return jsonSchema != null && typeof jsonSchema === "object" && jsonSchema.type === "object" && (jsonSchema.properties == null || Object.keys(jsonSchema.properties).length === 0) && !jsonSchema.additionalProperties;
 }
 
-// src/convert-to-google-generative-ai-messages.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-function convertToGoogleGenerativeAIMessages(prompt, options) {
-  var _a, _b, _c;
+// src/convert-to-google-messages.ts
+import {
+  UnsupportedFunctionalityError
+} from "@ai-sdk/provider";
+import {
+  convertToBase64,
+  getTopLevelMediaType,
+  isFullMediaType,
+  resolveFullMediaType,
+  resolveProviderReference
+} from "@ai-sdk/provider-utils";
+var dataUrlRegex = /^data:([^;,]+);base64,(.+)$/s;
+function parseBase64DataUrl(value) {
+  const match = dataUrlRegex.exec(value);
+  if (match == null) {
+    return void 0;
+  }
+  return {
+    mediaType: match[1],
+    data: match[2]
+  };
+}
+function convertUrlToolResultPart(url) {
+  const parsedDataUrl = parseBase64DataUrl(url);
+  if (parsedDataUrl == null) {
+    return void 0;
+  }
+  return {
+    inlineData: {
+      mimeType: parsedDataUrl.mediaType,
+      data: parsedDataUrl.data
+    }
+  };
+}
+function appendToolResultParts(parts, toolName, outputValue) {
+  const functionResponseParts = [];
+  const responseTextParts = [];
+  for (const contentPart of outputValue) {
+    switch (contentPart.type) {
+      case "text": {
+        responseTextParts.push(contentPart.text);
+        break;
+      }
+      case "file": {
+        if (contentPart.data.type === "data") {
+          functionResponseParts.push({
+            inlineData: {
+              mimeType: resolveFullMediaType({ part: contentPart }),
+              data: convertToBase64(contentPart.data.data)
+            }
+          });
+        } else if (contentPart.data.type === "url") {
+          const functionResponsePart = convertUrlToolResultPart(
+            contentPart.data.url.toString()
+          );
+          if (functionResponsePart != null) {
+            functionResponseParts.push(functionResponsePart);
+          } else {
+            responseTextParts.push(JSON.stringify(contentPart));
+          }
+        } else {
+          responseTextParts.push(JSON.stringify(contentPart));
+        }
+        break;
+      }
+      default: {
+        responseTextParts.push(JSON.stringify(contentPart));
+        break;
+      }
+    }
+  }
+  parts.push({
+    functionResponse: {
+      name: toolName,
+      response: {
+        name: toolName,
+        content: responseTextParts.length > 0 ? responseTextParts.join("\n") : "Tool executed successfully."
+      },
+      ...functionResponseParts.length > 0 ? { parts: functionResponseParts } : {}
+    }
+  });
+}
+function appendLegacyToolResultParts(parts, toolName, outputValue) {
+  for (const contentPart of outputValue) {
+    switch (contentPart.type) {
+      case "text":
+        parts.push({
+          functionResponse: {
+            name: toolName,
+            response: {
+              name: toolName,
+              content: contentPart.text
+            }
+          }
+        });
+        break;
+      case "file": {
+        if (contentPart.data.type === "data" && getTopLevelMediaType(contentPart.mediaType) === "image") {
+          parts.push(
+            {
+              inlineData: {
+                mimeType: resolveFullMediaType({ part: contentPart }),
+                data: convertToBase64(contentPart.data.data)
+              }
+            },
+            {
+              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) });
+        break;
+    }
+  }
+}
+function convertToGoogleMessages(prompt, options) {
+  var _a, _b, _c, _d;
   const systemInstructionParts = [];
   const contents = [];
   let systemMessagesAllowed = true;
   const isGemmaModel = (_a = options == null ? void 0 : options.isGemmaModel) != null ? _a : false;
-  const providerOptionsName = (_b = options == null ? void 0 : options.providerOptionsName) != null ? _b : "google";
+  const providerOptionsNames = (_b = options == null ? void 0 : options.providerOptionsNames) != null ? _b : ["google"];
+  const isVertexLike = !providerOptionsNames.includes("google");
+  const supportsFunctionResponseParts = (_c = options == null ? void 0 : options.supportsFunctionResponseParts) != null ? _c : true;
+  const readProviderOpts = (part) => {
+    var _a2, _b2, _c2, _d2, _e;
+    for (const name of providerOptionsNames) {
+      const v = (_a2 = part.providerOptions) == null ? void 0 : _a2[name];
+      if (v != null) return v;
+    }
+    if (isVertexLike) {
+      return (_b2 = part.providerOptions) == null ? void 0 : _b2.google;
+    }
+    return (_e = (_c2 = part.providerOptions) == null ? void 0 : _c2.googleVertex) != null ? _e : (_d2 = part.providerOptions) == null ? void 0 : _d2.vertex;
+  };
   for (const { role, content } of prompt) {
     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"
           });
         }
@@ -428,20 +580,54 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
               break;
             }
             case "file": {
-              const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
-              parts.push(
-                part.data instanceof URL ? {
-                  fileData: {
-                    mimeType: mediaType,
-                    fileUri: part.data.toString()
-                  }
-                } : {
-                  inlineData: {
-                    mimeType: mediaType,
-                    data: (0, import_provider_utils4.convertToBase64)(part.data)
+              switch (part.data.type) {
+                case "url": {
+                  parts.push({
+                    fileData: {
+                      mimeType: resolveFullMediaType({ part }),
+                      fileUri: part.data.url.toString()
+                    }
+                  });
+                  break;
+                }
+                case "reference": {
+                  if (isVertexLike) {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "file parts with provider references"
+                    });
                   }
+                  parts.push({
+                    fileData: {
+                      mimeType: resolveFullMediaType({ part }),
+                      fileUri: resolveProviderReference({
+                        reference: part.data.reference,
+                        provider: "google"
+                      })
+                    }
+                  });
+                  break;
+                }
+                case "text": {
+                  parts.push({
+                    inlineData: {
+                      mimeType: isFullMediaType(part.mediaType) ? part.mediaType : "text/plain",
+                      data: convertToBase64(
+                        new TextEncoder().encode(part.data.text)
+                      )
+                    }
+                  });
+                  break;
                 }
-              );
+                case "data": {
+                  parts.push({
+                    inlineData: {
+                      mimeType: resolveFullMediaType({ part }),
+                      data: convertToBase64(part.data.data)
+                    }
+                  });
+                  break;
+                }
+              }
               break;
             }
           }
@@ -454,8 +640,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
         contents.push({
           role: "model",
           parts: content.map((part) => {
-            var _a2, _b2, _c2, _d;
-            const providerOpts = (_d = (_a2 = part.providerOptions) == null ? void 0 : _a2[providerOptionsName]) != null ? _d : providerOptionsName !== "google" ? (_b2 = part.providerOptions) == null ? void 0 : _b2.google : (_c2 = part.providerOptions) == null ? void 0 : _c2.vertex;
+            const providerOpts = readProviderOpts(part);
             const thoughtSignature = (providerOpts == null ? void 0 : providerOpts.thoughtSignature) != null ? String(providerOpts.thoughtSignature) : void 0;
             switch (part.type) {
               case "text": {
@@ -471,22 +656,89 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                   thoughtSignature
                 };
               }
+              case "reasoning-file": {
+                switch (part.data.type) {
+                  case "url": {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "File data URLs in assistant messages are not supported"
+                    });
+                  }
+                  case "data": {
+                    return {
+                      inlineData: {
+                        mimeType: part.mediaType,
+                        data: convertToBase64(part.data.data)
+                      },
+                      thought: true,
+                      thoughtSignature
+                    };
+                  }
+                }
+                break;
+              }
               case "file": {
-                if (part.data instanceof URL) {
-                  throw new import_provider2.UnsupportedFunctionalityError({
-                    functionality: "File data URLs in assistant messages are not supported"
-                  });
+                switch (part.data.type) {
+                  case "url": {
+                    throw new UnsupportedFunctionalityError({
+                      functionality: "File data URLs in assistant messages are not supported"
+                    });
+                  }
+                  case "reference": {
+                    if (isVertexLike) {
+                      throw new UnsupportedFunctionalityError({
+                        functionality: "file parts with provider references"
+                      });
+                    }
+                    return {
+                      fileData: {
+                        mimeType: part.mediaType,
+                        fileUri: resolveProviderReference({
+                          reference: part.data.reference,
+                          provider: "google"
+                        })
+                      },
+                      ...(providerOpts == null ? void 0 : providerOpts.thought) === true ? { thought: true } : {},
+                      thoughtSignature
+                    };
+                  }
+                  case "text": {
+                    return {
+                      inlineData: {
+                        mimeType: isFullMediaType(part.mediaType) ? part.mediaType : "text/plain",
+                        data: convertToBase64(
+                          new TextEncoder().encode(part.data.text)
+                        )
+                      },
+                      ...(providerOpts == null ? void 0 : providerOpts.thought) === true ? { thought: true } : {},
+                      thoughtSignature
+                    };
+                  }
+                  case "data": {
+                    return {
+                      inlineData: {
+                        mimeType: part.mediaType,
+                        data: convertToBase64(part.data.data)
+                      },
+                      ...(providerOpts == null ? void 0 : providerOpts.thought) === true ? { thought: true } : {},
+                      thoughtSignature
+                    };
+                  }
                 }
-                return {
-                  inlineData: {
-                    mimeType: part.mediaType,
-                    data: (0, import_provider_utils4.convertToBase64)(part.data)
-                  },
-                  ...(providerOpts == null ? void 0 : providerOpts.thought) === true ? { thought: true } : {},
-                  thoughtSignature
-                };
+                break;
               }
               case "tool-call": {
+                const serverToolCallId = (providerOpts == null ? void 0 : providerOpts.serverToolCallId) != null ? String(providerOpts.serverToolCallId) : void 0;
+                const serverToolType = (providerOpts == null ? void 0 : providerOpts.serverToolType) != null ? String(providerOpts.serverToolType) : void 0;
+                if (serverToolCallId && serverToolType) {
+                  return {
+                    toolCall: {
+                      toolType: serverToolType,
+                      args: typeof part.input === "string" ? JSON.parse(part.input) : part.input,
+                      id: serverToolCallId
+                    },
+                    thoughtSignature
+                  };
+                }
                 return {
                   functionCall: {
                     name: part.toolName,
@@ -495,6 +747,21 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                   thoughtSignature
                 };
               }
+              case "tool-result": {
+                const serverToolCallId = (providerOpts == null ? void 0 : providerOpts.serverToolCallId) != null ? String(providerOpts.serverToolCallId) : void 0;
+                const serverToolType = (providerOpts == null ? void 0 : providerOpts.serverToolType) != null ? String(providerOpts.serverToolType) : void 0;
+                if (serverToolCallId && serverToolType) {
+                  return {
+                    toolResponse: {
+                      toolType: serverToolType,
+                      response: part.output.type === "json" ? part.output.value : {},
+                      id: serverToolCallId
+                    },
+                    thoughtSignature
+                  };
+                }
+                return void 0;
+              }
             }
           }).filter((part) => part !== void 0)
         });
@@ -507,38 +774,32 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
           if (part.type === "tool-approval-response") {
             continue;
           }
+          const partProviderOpts = readProviderOpts(part);
+          const serverToolCallId = (partProviderOpts == null ? void 0 : partProviderOpts.serverToolCallId) != null ? String(partProviderOpts.serverToolCallId) : void 0;
+          const serverToolType = (partProviderOpts == null ? void 0 : partProviderOpts.serverToolType) != null ? String(partProviderOpts.serverToolType) : void 0;
+          if (serverToolCallId && serverToolType) {
+            const serverThoughtSignature = (partProviderOpts == null ? void 0 : partProviderOpts.thoughtSignature) != null ? String(partProviderOpts.thoughtSignature) : void 0;
+            if (contents.length > 0) {
+              const lastContent = contents[contents.length - 1];
+              if (lastContent.role === "model") {
+                lastContent.parts.push({
+                  toolResponse: {
+                    toolType: serverToolType,
+                    response: part.output.type === "json" ? part.output.value : {},
+                    id: serverToolCallId
+                  },
+                  thoughtSignature: serverThoughtSignature
+                });
+                continue;
+              }
+            }
+          }
           const output = part.output;
           if (output.type === "content") {
-            for (const contentPart of output.value) {
-              switch (contentPart.type) {
-                case "text":
-                  parts.push({
-                    functionResponse: {
-                      name: part.toolName,
-                      response: {
-                        name: part.toolName,
-                        content: contentPart.text
-                      }
-                    }
-                  });
-                  break;
-                case "image-data":
-                  parts.push(
-                    {
-                      inlineData: {
-                        mimeType: contentPart.mediaType,
-                        data: contentPart.data
-                      }
-                    },
-                    {
-                      text: "Tool executed successfully and returned this image as a response"
-                    }
-                  );
-                  break;
-                default:
-                  parts.push({ text: JSON.stringify(contentPart) });
-                  break;
-              }
+            if (supportsFunctionResponseParts) {
+              appendToolResultParts(parts, part.toolName, output.value);
+            } else {
+              appendLegacyToolResultParts(parts, part.toolName, output.value);
             }
           } else {
             parts.push({
@@ -546,7 +807,7 @@ function convertToGoogleGenerativeAIMessages(prompt, options) {
                 name: part.toolName,
                 response: {
                   name: part.toolName,
-                  content: output.type === "execution-denied" ? (_c = output.reason) != null ? _c : "Tool execution denied." : output.value
+                  content: output.type === "execution-denied" ? (_d = output.reason) != null ? _d : "Tool call execution denied." : output.value
                 }
               }
             });
@@ -575,40 +836,43 @@ function getModelPath(modelId) {
   return modelId.includes("/") ? modelId : `models/${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(),
+// src/google-language-model-options.ts
+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.
        *
        * This is useful when the JSON Schema contains elements that are
        * not supported by the OpenAPI schema version that
-       * Google Generative AI uses. You can use this to disable
+       * Google 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",
@@ -616,7 +880,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",
@@ -626,7 +890,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",
@@ -639,19 +903,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",
@@ -662,8 +926,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",
@@ -679,7 +943,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.
@@ -687,24 +951,47 @@ 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()
+      }).optional(),
+      /**
+       * Optional. When set to true, function call arguments will be streamed
+       * incrementally via partialArgs in streaming responses. Only supported
+       * on the Vertex AI API (not the Gemini API) and only for Gemini 3+
+       * models.
+       *
+       * @default false
+       *
+       * https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/function-calling#streaming-fc
+       */
+      streamFunctionCallArguments: z4.boolean().optional(),
+      /**
+       * Optional. The service tier to use for the request.
+       */
+      serviceTier: z4.enum(["standard", "flex", "priority"]).optional()
     })
   )
 );
+var VertexServiceTierMap = {
+  standard: "SERVICE_TIER_STANDARD",
+  flex: "SERVICE_TIER_FLEX",
+  priority: "SERVICE_TIER_PRIORITY"
+};
 
 // src/google-prepare-tools.ts
-var import_provider3 = require("@ai-sdk/provider");
+import {
+  UnsupportedFunctionalityError as UnsupportedFunctionalityError2
+} from "@ai-sdk/provider";
 function prepareTools({
   tools,
   toolChoice,
-  modelId
+  modelId,
+  isVertexProvider = false
 }) {
-  var _a;
+  var _a, _b;
   tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   const isLatest = [
@@ -713,13 +1000,14 @@ function prepareTools({
     "gemini-pro-latest"
   ].some((id) => id === modelId);
   const isGemini2orNewer = modelId.includes("gemini-2") || modelId.includes("gemini-3") || modelId.includes("nano-banana") || isLatest;
+  const isGemini3orNewer = modelId.includes("gemini-3");
   const supportsFileSearch = modelId.includes("gemini-2.5") || modelId.includes("gemini-3");
   if (tools == null) {
     return { tools: void 0, toolConfig: void 0, toolWarnings };
   }
   const hasFunctionTools = tools.some((tool) => tool.type === "function");
   const hasProviderTools = tools.some((tool) => tool.type === "provider");
-  if (hasFunctionTools && hasProviderTools) {
+  if (hasFunctionTools && hasProviderTools && !isGemini3orNewer) {
     toolWarnings.push({
       type: "unsupported",
       feature: `combination of function and provider-defined tools`
@@ -770,7 +1058,7 @@ function prepareTools({
             toolWarnings.push({
               type: "unsupported",
               feature: `provider-defined tool ${tool.id}`,
-              details: "The code execution tools is not supported with other Gemini models than Gemini 2."
+              details: "The code execution tool is not supported with other Gemini models than Gemini 2."
             });
           }
           break;
@@ -824,6 +1112,47 @@ function prepareTools({
           break;
       }
     });
+    if (hasFunctionTools && isGemini3orNewer && googleTools2.length > 0) {
+      const functionDeclarations2 = [];
+      for (const tool of tools) {
+        if (tool.type === "function") {
+          functionDeclarations2.push({
+            name: tool.name,
+            description: (_a = tool.description) != null ? _a : "",
+            parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema)
+          });
+        }
+      }
+      const combinedToolConfig = {
+        functionCallingConfig: { mode: "VALIDATED" },
+        ...!isVertexProvider && {
+          includeServerSideToolInvocations: true
+        }
+      };
+      if (toolChoice != null) {
+        switch (toolChoice.type) {
+          case "auto":
+            break;
+          case "none":
+            combinedToolConfig.functionCallingConfig = { mode: "NONE" };
+            break;
+          case "required":
+            combinedToolConfig.functionCallingConfig = { mode: "ANY" };
+            break;
+          case "tool":
+            combinedToolConfig.functionCallingConfig = {
+              mode: "ANY",
+              allowedFunctionNames: [toolChoice.toolName]
+            };
+            break;
+        }
+      }
+      return {
+        tools: [...googleTools2, { functionDeclarations: functionDeclarations2 }],
+        toolConfig: combinedToolConfig,
+        toolWarnings
+      };
+    }
     return {
       tools: googleTools2.length > 0 ? googleTools2 : void 0,
       toolConfig: void 0,
@@ -837,7 +1166,7 @@ function prepareTools({
       case "function":
         functionDeclarations.push({
           name: tool.name,
-          description: (_a = tool.description) != null ? _a : "",
+          description: (_b = tool.description) != null ? _b : "",
           parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema)
         });
         if (tool.strict === true) {
@@ -900,15 +1229,238 @@ function prepareTools({
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider3.UnsupportedFunctionalityError({
+      throw new UnsupportedFunctionalityError2({
         functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
   }
 }
 
-// src/map-google-generative-ai-finish-reason.ts
-function mapGoogleGenerativeAIFinishReason({
+// src/google-json-accumulator.ts
+var GoogleJSONAccumulator = class {
+  constructor() {
+    this.accumulatedArgs = {};
+    this.jsonText = "";
+    /**
+     * Stack representing the currently "open" containers in the JSON output.
+     * Entry 0 is always the root `{` object once the first value is written.
+     */
+    this.pathStack = [];
+    /**
+     * Whether a string value is currently "open" (willContinue was true),
+     * meaning the closing quote has not yet been emitted.
+     */
+    this.stringOpen = false;
+  }
+  /**
+   * Input: [{jsonPath:"$.brightness",numberValue:50}]
+   * Output: { currentJSON:{brightness:50}, textDelta:'{"brightness":50' }
+   */
+  processPartialArgs(partialArgs) {
+    let delta = "";
+    for (const arg of partialArgs) {
+      const rawPath = arg.jsonPath.replace(/^\$\./, "");
+      if (!rawPath) continue;
+      const segments = parsePath(rawPath);
+      const existingValue = getNestedValue(this.accumulatedArgs, segments);
+      const isStringContinuation = arg.stringValue != null && existingValue !== void 0;
+      if (isStringContinuation) {
+        const escaped = JSON.stringify(arg.stringValue).slice(1, -1);
+        setNestedValue(
+          this.accumulatedArgs,
+          segments,
+          existingValue + arg.stringValue
+        );
+        delta += escaped;
+        continue;
+      }
+      const resolved = resolvePartialArgValue(arg);
+      if (resolved == null) continue;
+      setNestedValue(this.accumulatedArgs, segments, resolved.value);
+      delta += this.emitNavigationTo(segments, arg, resolved.json);
+    }
+    this.jsonText += delta;
+    return {
+      currentJSON: this.accumulatedArgs,
+      textDelta: delta
+    };
+  }
+  /**
+   * Input: jsonText='{"brightness":50', accumulatedArgs={brightness:50}
+   * Output: { finalJSON:'{"brightness":50}', closingDelta:'}' }
+   */
+  finalize() {
+    const finalArgs = JSON.stringify(this.accumulatedArgs);
+    const closingDelta = finalArgs.slice(this.jsonText.length);
+    return { finalJSON: finalArgs, closingDelta };
+  }
+  /**
+   * Input: pathStack=[] (first call) or pathStack=[root,...] (subsequent calls)
+   * Output: '{' (first call) or '' (subsequent calls)
+   */
+  ensureRoot() {
+    if (this.pathStack.length === 0) {
+      this.pathStack.push({ segment: "", isArray: false, childCount: 0 });
+      return "{";
+    }
+    return "";
+  }
+  /**
+   * Emits the JSON text fragment needed to navigate from the current open
+   * path to the new leaf at `targetSegments`, then writes the value.
+   *
+   * Input: targetSegments=["recipe","name"], arg={jsonPath:"$.recipe.name",stringValue:"Lasagna"}, valueJson='"Lasagna"'
+   * Output: '{"recipe":{"name":"Lasagna"'
+   */
+  emitNavigationTo(targetSegments, arg, valueJson) {
+    let fragment = "";
+    if (this.stringOpen) {
+      fragment += '"';
+      this.stringOpen = false;
+    }
+    fragment += this.ensureRoot();
+    const targetContainerSegments = targetSegments.slice(0, -1);
+    const leafSegment = targetSegments[targetSegments.length - 1];
+    const commonDepth = this.findCommonStackDepth(targetContainerSegments);
+    fragment += this.closeDownTo(commonDepth);
+    fragment += this.openDownTo(targetContainerSegments, leafSegment);
+    fragment += this.emitLeaf(leafSegment, arg, valueJson);
+    return fragment;
+  }
+  /**
+   * Returns the stack depth to preserve when navigating to a new target
+   * container path. Always >= 1 (the root is never popped).
+   *
+   * Input: stack=[root,"recipe","ingredients",0], target=["recipe","ingredients",1]
+   * Output: 3 (keep root+"recipe"+"ingredients")
+   */
+  findCommonStackDepth(targetContainer) {
+    const maxDepth = Math.min(
+      this.pathStack.length - 1,
+      targetContainer.length
+    );
+    let common = 0;
+    for (let i = 0; i < maxDepth; i++) {
+      if (this.pathStack[i + 1].segment === targetContainer[i]) {
+        common++;
+      } else {
+        break;
+      }
+    }
+    return common + 1;
+  }
+  /**
+   * Closes containers from the current stack depth back down to `targetDepth`.
+   *
+   * Input: this.pathStack=[root,"recipe","ingredients",0], targetDepth=3
+   * Output: '}'
+   */
+  closeDownTo(targetDepth) {
+    let fragment = "";
+    while (this.pathStack.length > targetDepth) {
+      const entry = this.pathStack.pop();
+      fragment += entry.isArray ? "]" : "}";
+    }
+    return fragment;
+  }
+  /**
+   * Opens containers from the current stack depth down to the full target
+   * container path, emitting opening `{`, `[`, keys, and commas as needed.
+   * `leafSegment` is used to determine if the innermost container is an array.
+   *
+   * Input: this.pathStack=[root], targetContainer=["recipe","ingredients"], leafSegment=0
+   * Output: '"recipe":{"ingredients":['
+   */
+  openDownTo(targetContainer, leafSegment) {
+    let fragment = "";
+    const startIdx = this.pathStack.length - 1;
+    for (let i = startIdx; i < targetContainer.length; i++) {
+      const seg = targetContainer[i];
+      const parentEntry = this.pathStack[this.pathStack.length - 1];
+      if (parentEntry.childCount > 0) {
+        fragment += ",";
+      }
+      parentEntry.childCount++;
+      if (typeof seg === "string") {
+        fragment += `${JSON.stringify(seg)}:`;
+      }
+      const childSeg = i + 1 < targetContainer.length ? targetContainer[i + 1] : leafSegment;
+      const isArray = typeof childSeg === "number";
+      fragment += isArray ? "[" : "{";
+      this.pathStack.push({ segment: seg, isArray, childCount: 0 });
+    }
+    return fragment;
+  }
+  /**
+   * Emits the comma, key, and value for a leaf entry in the current container.
+   *
+   * Input: leafSegment="name", arg={stringValue:"Lasagna"}, valueJson='"Lasagna"'
+   * Output: '"name":"Lasagna"' (or ',"name":"Lasagna"' if container.childCount > 0)
+   */
+  emitLeaf(leafSegment, arg, valueJson) {
+    let fragment = "";
+    const container = this.pathStack[this.pathStack.length - 1];
+    if (container.childCount > 0) {
+      fragment += ",";
+    }
+    container.childCount++;
+    if (typeof leafSegment === "string") {
+      fragment += `${JSON.stringify(leafSegment)}:`;
+    }
+    if (arg.stringValue != null && arg.willContinue) {
+      fragment += valueJson.slice(0, -1);
+      this.stringOpen = true;
+    } else {
+      fragment += valueJson;
+    }
+    return fragment;
+  }
+};
+function parsePath(rawPath) {
+  const segments = [];
+  for (const part of rawPath.split(".")) {
+    const bracketIdx = part.indexOf("[");
+    if (bracketIdx === -1) {
+      segments.push(part);
+    } else {
+      if (bracketIdx > 0) segments.push(part.slice(0, bracketIdx));
+      for (const m of part.matchAll(/\[(\d+)\]/g)) {
+        segments.push(parseInt(m[1], 10));
+      }
+    }
+  }
+  return segments;
+}
+function getNestedValue(obj, segments) {
+  let current = obj;
+  for (const seg of segments) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[seg];
+  }
+  return current;
+}
+function setNestedValue(obj, segments, value) {
+  let current = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    const nextSeg = segments[i + 1];
+    if (current[seg] == null) {
+      current[seg] = typeof nextSeg === "number" ? [] : {};
+    }
+    current = current[seg];
+  }
+  current[segments[segments.length - 1]] = value;
+}
+function resolvePartialArgValue(arg) {
+  var _a, _b;
+  const value = (_b = (_a = arg.stringValue) != null ? _a : arg.numberValue) != null ? _b : arg.boolValue;
+  if (value != null) return { value, json: JSON.stringify(value) };
+  if ("nullValue" in arg) return { value: null, json: "null" };
+  return void 0;
+}
+
+// src/map-google-finish-reason.ts
+function mapGoogleFinishReason({
   finishReason,
   hasToolCalls
 }) {
@@ -933,14 +1485,23 @@ function mapGoogleGenerativeAIFinishReason({
   }
 }
 
-// src/google-generative-ai-language-model.ts
-var GoogleGenerativeAILanguageModel = class {
+// src/google-language-model.ts
+var GoogleLanguageModel = class _GoogleLanguageModel {
   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 _GoogleLanguageModel(options.modelId, options.config);
   }
   get provider() {
     return this.config.provider;
@@ -962,36 +1523,54 @@ var GoogleGenerativeAILanguageModel = class {
     seed,
     tools,
     toolChoice,
+    reasoning,
     providerOptions
-  }) {
-    var _a;
+  }, { isStreaming = false } = {}) {
+    var _a, _b;
     const warnings = [];
-    const providerOptionsName = this.config.provider.includes("vertex") ? "vertex" : "google";
-    let googleOptions = await (0, import_provider_utils6.parseProviderOptions)({
-      provider: providerOptionsName,
-      providerOptions,
-      schema: googleLanguageModelOptions
-    });
-    if (googleOptions == null && providerOptionsName !== "google") {
-      googleOptions = await (0, import_provider_utils6.parseProviderOptions)({
+    const providerOptionsNames = this.config.provider.includes("vertex") ? ["googleVertex", "vertex"] : ["google"];
+    let googleOptions;
+    for (const name of providerOptionsNames) {
+      googleOptions = await parseProviderOptions2({
+        provider: name,
+        providerOptions,
+        schema: googleLanguageModelOptions
+      });
+      if (googleOptions != null) break;
+    }
+    if (googleOptions == null && !providerOptionsNames.includes("google")) {
+      googleOptions = await parseProviderOptions2({
         provider: "google",
         providerOptions,
         schema: googleLanguageModelOptions
       });
     }
+    const isVertexProvider = this.config.provider.startsWith("google.vertex.");
     if ((tools == null ? void 0 : tools.some(
       (tool) => tool.type === "provider" && tool.id === "google.vertex_rag_store"
-    )) && !this.config.provider.startsWith("google.vertex.")) {
+    )) && !isVertexProvider) {
       warnings.push({
         type: "other",
         message: `The 'vertex_rag_store' tool is only supported with the Google Vertex provider and might not be supported or could behave unexpectedly with the current Google provider (${this.config.provider}).`
       });
     }
+    if ((googleOptions == null ? void 0 : googleOptions.streamFunctionCallArguments) && !isVertexProvider) {
+      warnings.push({
+        type: "other",
+        message: `'streamFunctionCallArguments' is only supported on the Vertex AI API and will be ignored with the current Google provider (${this.config.provider}). See https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/function-calling#streaming-fc`
+      });
+    }
+    let sanitizedServiceTier = googleOptions == null ? void 0 : googleOptions.serviceTier;
+    if ((googleOptions == null ? void 0 : googleOptions.serviceTier) && isVertexProvider) {
+      sanitizedServiceTier = VertexServiceTierMap[googleOptions.serviceTier];
+    }
     const isGemmaModel = this.modelId.toLowerCase().startsWith("gemma-");
-    const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(
-      prompt,
-      { isGemmaModel, providerOptionsName }
-    );
+    const supportsFunctionResponseParts = this.modelId.startsWith("gemini-3");
+    const { contents, systemInstruction } = convertToGoogleMessages(prompt, {
+      isGemmaModel,
+      providerOptionsNames,
+      supportsFunctionResponseParts
+    });
     const {
       tools: googleTools2,
       toolConfig: googleToolConfig,
@@ -999,8 +1578,28 @@ var GoogleGenerativeAILanguageModel = class {
     } = prepareTools({
       tools,
       toolChoice,
-      modelId: this.modelId
+      modelId: this.modelId,
+      isVertexProvider
+    });
+    const resolvedThinking = resolveThinkingConfig({
+      reasoning,
+      modelId: this.modelId,
+      warnings
     });
+    const thinkingConfig = (googleOptions == null ? void 0 : googleOptions.thinkingConfig) || resolvedThinking ? { ...resolvedThinking, ...googleOptions == null ? void 0 : googleOptions.thinkingConfig } : void 0;
+    const streamFunctionCallArguments = isStreaming && isVertexProvider ? (_a = googleOptions == null ? void 0 : googleOptions.streamFunctionCallArguments) != null ? _a : false : void 0;
+    const toolConfig = googleToolConfig || streamFunctionCallArguments || (googleOptions == null ? void 0 : googleOptions.retrievalConfig) ? {
+      ...googleToolConfig,
+      ...streamFunctionCallArguments && {
+        functionCallingConfig: {
+          ...googleToolConfig == null ? void 0 : googleToolConfig.functionCallingConfig,
+          streamFunctionCallArguments: true
+        }
+      },
+      ...(googleOptions == null ? void 0 : googleOptions.retrievalConfig) && {
+        retrievalConfig: googleOptions.retrievalConfig
+      }
+    } : void 0;
     return {
       args: {
         generationConfig: {
@@ -1018,13 +1617,13 @@ var GoogleGenerativeAILanguageModel = class {
           responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
           // so this is needed as an escape hatch:
           // TODO convert into provider option
-          ((_a = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _a : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
+          ((_b = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _b : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
           ...(googleOptions == null ? void 0 : googleOptions.audioTimestamp) && {
             audioTimestamp: googleOptions.audioTimestamp
           },
           // provider options:
           responseModalities: googleOptions == null ? void 0 : googleOptions.responseModalities,
-          thinkingConfig: googleOptions == null ? void 0 : googleOptions.thinkingConfig,
+          thinkingConfig,
           ...(googleOptions == null ? void 0 : googleOptions.mediaResolution) && {
             mediaResolution: googleOptions.mediaResolution
           },
@@ -1036,36 +1635,37 @@ var GoogleGenerativeAILanguageModel = class {
         systemInstruction: isGemmaModel ? void 0 : systemInstruction,
         safetySettings: googleOptions == null ? void 0 : googleOptions.safetySettings,
         tools: googleTools2,
-        toolConfig: (googleOptions == null ? void 0 : googleOptions.retrievalConfig) ? {
-          ...googleToolConfig,
-          retrievalConfig: googleOptions.retrievalConfig
-        } : googleToolConfig,
+        toolConfig,
         cachedContent: googleOptions == null ? void 0 : googleOptions.cachedContent,
-        labels: googleOptions == null ? void 0 : googleOptions.labels
+        labels: googleOptions == null ? void 0 : googleOptions.labels,
+        serviceTier: sanitizedServiceTier
       },
       warnings: [...warnings, ...toolWarnings],
-      providerOptionsName
+      providerOptionsNames
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
-    const { args, warnings, providerOptionsName } = await this.getArgs(options);
-    const mergedHeaders = (0, import_provider_utils6.combineHeaders)(
-      await (0, import_provider_utils6.resolve)(this.config.headers),
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+    const { args, warnings, providerOptionsNames } = await this.getArgs(options);
+    const wrapProviderMetadata = (payload) => Object.fromEntries(
+      providerOptionsNames.map((name) => [name, payload])
+    );
+    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
     });
@@ -1074,6 +1674,7 @@ var GoogleGenerativeAILanguageModel = class {
     const parts = (_b = (_a = candidate.content) == null ? void 0 : _a.parts) != null ? _b : [];
     const usageMetadata = response.usageMetadata;
     let lastCodeExecutionToolCallId;
+    let lastServerToolCallId;
     for (const part of parts) {
       if ("executableCode" in part && ((_c = part.executableCode) == null ? void 0 : _c.code)) {
         const toolCallId = this.config.generateId();
@@ -1098,11 +1699,9 @@ var GoogleGenerativeAILanguageModel = class {
         });
         lastCodeExecutionToolCallId = void 0;
       } else if ("text" in part && part.text != null) {
-        const thoughtSignatureMetadata = part.thoughtSignature ? {
-          [providerOptionsName]: {
-            thoughtSignature: part.thoughtSignature
-          }
-        } : void 0;
+        const thoughtSignatureMetadata = part.thoughtSignature ? wrapProviderMetadata({
+          thoughtSignature: part.thoughtSignature
+        }) : void 0;
         if (part.text.length === 0) {
           if (thoughtSignatureMetadata != null && content.length > 0) {
             const lastContent = content[content.length - 1];
@@ -1115,65 +1714,95 @@ var GoogleGenerativeAILanguageModel = class {
             providerMetadata: thoughtSignatureMetadata
           });
         }
-      } else if ("functionCall" in part) {
+      } else if ("functionCall" in part && part.functionCall.name != null && part.functionCall.args != null) {
         content.push({
           type: "tool-call",
           toolCallId: this.config.generateId(),
           toolName: part.functionCall.name,
           input: JSON.stringify(part.functionCall.args),
-          providerMetadata: part.thoughtSignature ? {
-            [providerOptionsName]: {
-              thoughtSignature: part.thoughtSignature
-            }
-          } : void 0
+          providerMetadata: part.thoughtSignature ? wrapProviderMetadata({
+            thoughtSignature: part.thoughtSignature
+          }) : void 0
         });
       } else if ("inlineData" in part) {
         const hasThought = part.thought === true;
         const hasThoughtSignature = !!part.thoughtSignature;
         content.push({
-          type: "file",
-          data: part.inlineData.data,
+          type: hasThought ? "reasoning-file" : "file",
+          data: { type: "data", data: part.inlineData.data },
           mediaType: part.inlineData.mimeType,
-          providerMetadata: hasThought || hasThoughtSignature ? {
-            [providerOptionsName]: {
-              ...hasThought ? { thought: true } : {},
-              ...hasThoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
-            }
-          } : void 0
+          providerMetadata: hasThoughtSignature ? wrapProviderMetadata({
+            thoughtSignature: part.thoughtSignature
+          }) : void 0
         });
+      } else if ("toolCall" in part && part.toolCall) {
+        const toolCallId = (_e = part.toolCall.id) != null ? _e : this.config.generateId();
+        lastServerToolCallId = toolCallId;
+        content.push({
+          type: "tool-call",
+          toolCallId,
+          toolName: `server:${part.toolCall.toolType}`,
+          input: JSON.stringify((_f = part.toolCall.args) != null ? _f : {}),
+          providerExecuted: true,
+          dynamic: true,
+          providerMetadata: part.thoughtSignature ? wrapProviderMetadata({
+            thoughtSignature: part.thoughtSignature,
+            serverToolCallId: toolCallId,
+            serverToolType: part.toolCall.toolType
+          }) : wrapProviderMetadata({
+            serverToolCallId: toolCallId,
+            serverToolType: part.toolCall.toolType
+          })
+        });
+      } else if ("toolResponse" in part && part.toolResponse) {
+        const responseToolCallId = (_g = lastServerToolCallId != null ? lastServerToolCallId : part.toolResponse.id) != null ? _g : this.config.generateId();
+        content.push({
+          type: "tool-result",
+          toolCallId: responseToolCallId,
+          toolName: `server:${part.toolResponse.toolType}`,
+          result: (_h = part.toolResponse.response) != null ? _h : {},
+          providerMetadata: part.thoughtSignature ? wrapProviderMetadata({
+            thoughtSignature: part.thoughtSignature,
+            serverToolCallId: responseToolCallId,
+            serverToolType: part.toolResponse.toolType
+          }) : wrapProviderMetadata({
+            serverToolCallId: responseToolCallId,
+            serverToolType: part.toolResponse.toolType
+          })
+        });
+        lastServerToolCallId = void 0;
       }
     }
-    const sources = (_e = extractSources({
+    const sources = (_i = extractSources({
       groundingMetadata: candidate.groundingMetadata,
       generateId: this.config.generateId
-    })) != null ? _e : [];
+    })) != null ? _i : [];
     for (const source of sources) {
       content.push(source);
     }
     return {
       content,
       finishReason: {
-        unified: mapGoogleGenerativeAIFinishReason({
+        unified: mapGoogleFinishReason({
           finishReason: candidate.finishReason,
           // Only count client-executed tool calls for finish reason determination.
           hasToolCalls: content.some(
             (part) => part.type === "tool-call" && !part.providerExecuted
           )
         }),
-        raw: (_f = candidate.finishReason) != null ? _f : void 0
+        raw: (_j = candidate.finishReason) != null ? _j : void 0
       },
-      usage: convertGoogleGenerativeAIUsage(usageMetadata),
+      usage: convertGoogleUsage(usageMetadata),
       warnings,
-      providerMetadata: {
-        [providerOptionsName]: {
-          promptFeedback: (_g = response.promptFeedback) != null ? _g : null,
-          groundingMetadata: (_h = candidate.groundingMetadata) != null ? _h : null,
-          urlContextMetadata: (_i = candidate.urlContextMetadata) != null ? _i : null,
-          safetyRatings: (_j = candidate.safetyRatings) != null ? _j : null,
-          usageMetadata: usageMetadata != null ? usageMetadata : null,
-          finishMessage: (_k = candidate.finishMessage) != null ? _k : null
-        }
-      },
+      providerMetadata: wrapProviderMetadata({
+        promptFeedback: (_k = response.promptFeedback) != null ? _k : null,
+        groundingMetadata: (_l = candidate.groundingMetadata) != null ? _l : null,
+        urlContextMetadata: (_m = candidate.urlContextMetadata) != null ? _m : null,
+        safetyRatings: (_n = candidate.safetyRatings) != null ? _n : null,
+        usageMetadata: usageMetadata != null ? usageMetadata : null,
+        finishMessage: (_o = candidate.finishMessage) != null ? _o : null,
+        serviceTier: (_p = response.serviceTier) != null ? _p : null
+      }),
       request: { body: args },
       response: {
         // TODO timestamp, model id, id
@@ -1183,19 +1812,25 @@ var GoogleGenerativeAILanguageModel = class {
     };
   }
   async doStream(options) {
-    const { args, warnings, providerOptionsName } = await this.getArgs(options);
-    const headers = (0, import_provider_utils6.combineHeaders)(
-      await (0, import_provider_utils6.resolve)(this.config.headers),
+    const { args, warnings, providerOptionsNames } = await this.getArgs(
+      options,
+      { isStreaming: true }
+    );
+    const wrapProviderMetadata = (payload) => Object.fromEntries(
+      providerOptionsNames.map((name) => [name, payload])
+    );
+    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
     });
@@ -1207,6 +1842,7 @@ var GoogleGenerativeAILanguageModel = class {
     let providerMetadata = void 0;
     let lastGroundingMetadata = null;
     let lastUrlContextMetadata = null;
+    let serviceTier = null;
     const generateId3 = this.config.generateId;
     let hasToolCalls = false;
     let currentTextBlockId = null;
@@ -1214,6 +1850,8 @@ var GoogleGenerativeAILanguageModel = class {
     let blockCounter = 0;
     const emittedSourceUrls = /* @__PURE__ */ new Set();
     let lastCodeExecutionToolCallId;
+    let lastServerToolCallId;
+    const activeStreamingToolCalls = [];
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -1221,7 +1859,7 @@ var GoogleGenerativeAILanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -1234,6 +1872,9 @@ var GoogleGenerativeAILanguageModel = class {
             if (usageMetadata != null) {
               usage = usageMetadata;
             }
+            if (value.serviceTier != null) {
+              serviceTier = value.serviceTier;
+            }
             const candidate = (_a = value.candidates) == null ? void 0 : _a[0];
             if (candidate == null) {
               return;
@@ -1285,11 +1926,9 @@ var GoogleGenerativeAILanguageModel = class {
                     lastCodeExecutionToolCallId = void 0;
                   }
                 } else if ("text" in part && part.text != null) {
-                  const thoughtSignatureMetadata = part.thoughtSignature ? {
-                    [providerOptionsName]: {
-                      thoughtSignature: part.thoughtSignature
-                    }
-                  } : void 0;
+                  const thoughtSignatureMetadata = part.thoughtSignature ? wrapProviderMetadata({
+                    thoughtSignature: part.thoughtSignature
+                  }) : void 0;
                   if (part.text.length === 0) {
                     if (thoughtSignatureMetadata != null && currentTextBlockId !== null) {
                       controller.enqueue({
@@ -1361,50 +2000,151 @@ var GoogleGenerativeAILanguageModel = class {
                   }
                   const hasThought = part.thought === true;
                   const hasThoughtSignature = !!part.thoughtSignature;
-                  const fileMeta = hasThought || hasThoughtSignature ? {
-                    [providerOptionsName]: {
-                      ...hasThought ? { thought: true } : {},
-                      ...hasThoughtSignature ? { thoughtSignature: part.thoughtSignature } : {}
-                    }
-                  } : void 0;
+                  const fileMeta = hasThoughtSignature ? wrapProviderMetadata({
+                    thoughtSignature: part.thoughtSignature
+                  }) : void 0;
                   controller.enqueue({
-                    type: "file",
+                    type: hasThought ? "reasoning-file" : "file",
                     mediaType: part.inlineData.mimeType,
-                    data: part.inlineData.data,
+                    data: { type: "data", data: part.inlineData.data },
                     providerMetadata: fileMeta
                   });
+                } else if ("toolCall" in part && part.toolCall) {
+                  const toolCallId = (_e = part.toolCall.id) != null ? _e : generateId3();
+                  lastServerToolCallId = toolCallId;
+                  const serverMeta = wrapProviderMetadata({
+                    ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {},
+                    serverToolCallId: toolCallId,
+                    serverToolType: part.toolCall.toolType
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId,
+                    toolName: `server:${part.toolCall.toolType}`,
+                    input: JSON.stringify((_f = part.toolCall.args) != null ? _f : {}),
+                    providerExecuted: true,
+                    dynamic: true,
+                    providerMetadata: serverMeta
+                  });
+                } else if ("toolResponse" in part && part.toolResponse) {
+                  const responseToolCallId = (_g = lastServerToolCallId != null ? lastServerToolCallId : part.toolResponse.id) != null ? _g : generateId3();
+                  const serverMeta = wrapProviderMetadata({
+                    ...part.thoughtSignature ? { thoughtSignature: part.thoughtSignature } : {},
+                    serverToolCallId: responseToolCallId,
+                    serverToolType: part.toolResponse.toolType
+                  });
+                  controller.enqueue({
+                    type: "tool-result",
+                    toolCallId: responseToolCallId,
+                    toolName: `server:${part.toolResponse.toolType}`,
+                    result: (_h = part.toolResponse.response) != null ? _h : {},
+                    providerMetadata: serverMeta
+                  });
+                  lastServerToolCallId = void 0;
                 }
               }
-              const toolCallDeltas = getToolCallsFromParts({
-                parts: content.parts,
-                generateId: generateId3,
-                providerOptionsName
-              });
-              if (toolCallDeltas != null) {
-                for (const toolCall of toolCallDeltas) {
+              for (const part of parts) {
+                if (!("functionCall" in part)) continue;
+                const providerMeta = part.thoughtSignature ? wrapProviderMetadata({
+                  thoughtSignature: part.thoughtSignature
+                }) : void 0;
+                const isStreamingChunk = part.functionCall.partialArgs != null || part.functionCall.name != null && part.functionCall.willContinue === true;
+                const isTerminalChunk = part.functionCall.name == null && part.functionCall.args == null && part.functionCall.partialArgs == null && part.functionCall.willContinue == null;
+                const isCompleteCall = part.functionCall.name != null && part.functionCall.args != null && part.functionCall.partialArgs == null;
+                if (isStreamingChunk) {
+                  if (part.functionCall.name != null && part.functionCall.willContinue === true) {
+                    const toolCallId = generateId3();
+                    const accumulator = new GoogleJSONAccumulator();
+                    activeStreamingToolCalls.push({
+                      toolCallId,
+                      toolName: part.functionCall.name,
+                      accumulator,
+                      providerMetadata: providerMeta
+                    });
+                    controller.enqueue({
+                      type: "tool-input-start",
+                      id: toolCallId,
+                      toolName: part.functionCall.name,
+                      providerMetadata: providerMeta
+                    });
+                    if (part.functionCall.partialArgs != null) {
+                      const { textDelta } = accumulator.processPartialArgs(
+                        part.functionCall.partialArgs
+                      );
+                      if (textDelta.length > 0) {
+                        controller.enqueue({
+                          type: "tool-input-delta",
+                          id: toolCallId,
+                          delta: textDelta,
+                          providerMetadata: providerMeta
+                        });
+                      }
+                    }
+                  } else if (part.functionCall.partialArgs != null && activeStreamingToolCalls.length > 0) {
+                    const active = activeStreamingToolCalls[activeStreamingToolCalls.length - 1];
+                    const { textDelta } = active.accumulator.processPartialArgs(
+                      part.functionCall.partialArgs
+                    );
+                    if (textDelta.length > 0) {
+                      controller.enqueue({
+                        type: "tool-input-delta",
+                        id: active.toolCallId,
+                        delta: textDelta,
+                        providerMetadata: providerMeta
+                      });
+                    }
+                  }
+                } else if (isTerminalChunk && activeStreamingToolCalls.length > 0) {
+                  const active = activeStreamingToolCalls.pop();
+                  const { finalJSON, closingDelta } = active.accumulator.finalize();
+                  if (closingDelta.length > 0) {
+                    controller.enqueue({
+                      type: "tool-input-delta",
+                      id: active.toolCallId,
+                      delta: closingDelta,
+                      providerMetadata: active.providerMetadata
+                    });
+                  }
+                  controller.enqueue({
+                    type: "tool-input-end",
+                    id: active.toolCallId,
+                    providerMetadata: active.providerMetadata
+                  });
+                  controller.enqueue({
+                    type: "tool-call",
+                    toolCallId: active.toolCallId,
+                    toolName: active.toolName,
+                    input: finalJSON,
+                    providerMetadata: active.providerMetadata
+                  });
+                  hasToolCalls = true;
+                } else if (isCompleteCall) {
+                  const toolCallId = generateId3();
+                  const toolName = part.functionCall.name;
+                  const args2 = typeof part.functionCall.args === "string" ? part.functionCall.args : JSON.stringify((_i = part.functionCall.args) != null ? _i : {});
                   controller.enqueue({
                     type: "tool-input-start",
-                    id: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    providerMetadata: toolCall.providerMetadata
+                    id: toolCallId,
+                    toolName,
+                    providerMetadata: providerMeta
                   });
                   controller.enqueue({
                     type: "tool-input-delta",
-                    id: toolCall.toolCallId,
-                    delta: toolCall.args,
-                    providerMetadata: toolCall.providerMetadata
+                    id: toolCallId,
+                    delta: args2,
+                    providerMetadata: providerMeta
                   });
                   controller.enqueue({
                     type: "tool-input-end",
-                    id: toolCall.toolCallId,
-                    providerMetadata: toolCall.providerMetadata
+                    id: toolCallId,
+                    providerMetadata: providerMeta
                   });
                   controller.enqueue({
                     type: "tool-call",
-                    toolCallId: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    input: toolCall.args,
-                    providerMetadata: toolCall.providerMetadata
+                    toolCallId,
+                    toolName,
+                    input: args2,
+                    providerMetadata: providerMeta
                   });
                   hasToolCalls = true;
                 }
@@ -1412,22 +2152,21 @@ var GoogleGenerativeAILanguageModel = class {
             }
             if (candidate.finishReason != null) {
               finishReason = {
-                unified: mapGoogleGenerativeAIFinishReason({
+                unified: mapGoogleFinishReason({
                   finishReason: candidate.finishReason,
                   hasToolCalls
                 }),
                 raw: candidate.finishReason
               };
-              providerMetadata = {
-                [providerOptionsName]: {
-                  promptFeedback: (_e = value.promptFeedback) != null ? _e : null,
-                  groundingMetadata: lastGroundingMetadata,
-                  urlContextMetadata: lastUrlContextMetadata,
-                  safetyRatings: (_f = candidate.safetyRatings) != null ? _f : null,
-                  usageMetadata: usageMetadata != null ? usageMetadata : null,
-                  finishMessage: (_g = candidate.finishMessage) != null ? _g : null
-                }
-              };
+              providerMetadata = wrapProviderMetadata({
+                promptFeedback: (_j = value.promptFeedback) != null ? _j : null,
+                groundingMetadata: lastGroundingMetadata,
+                urlContextMetadata: lastUrlContextMetadata,
+                safetyRatings: (_k = candidate.safetyRatings) != null ? _k : null,
+                usageMetadata: usageMetadata != null ? usageMetadata : null,
+                finishMessage: (_l = candidate.finishMessage) != null ? _l : null,
+                serviceTier
+              });
             }
           },
           flush(controller) {
@@ -1446,7 +2185,7 @@ var GoogleGenerativeAILanguageModel = class {
             controller.enqueue({
               type: "finish",
               finishReason,
-              usage: convertGoogleGenerativeAIUsage(usage),
+              usage: convertGoogleUsage(usage),
               providerMetadata
             });
           }
@@ -1457,25 +2196,74 @@ var GoogleGenerativeAILanguageModel = class {
     };
   }
 };
-function getToolCallsFromParts({
-  parts,
-  generateId: generateId3,
-  providerOptionsName
+function isGemini3Model(modelId) {
+  return /gemini-3[\.\-]/i.test(modelId) || /gemini-3$/i.test(modelId);
+}
+function getMaxOutputTokensForGemini25Model() {
+  return 65536;
+}
+function getMaxThinkingTokensForGemini25Model(modelId) {
+  const id = modelId.toLowerCase();
+  if (id.includes("2.5-pro") || id.includes("gemini-3-pro-image")) {
+    return 32768;
+  }
+  return 24576;
+}
+function resolveThinkingConfig({
+  reasoning,
+  modelId,
+  warnings
 }) {
-  const functionCallParts = parts == null ? void 0 : parts.filter(
-    (part) => "functionCall" in part
-  );
-  return functionCallParts == null || functionCallParts.length === 0 ? void 0 : functionCallParts.map((part) => ({
-    type: "tool-call",
-    toolCallId: generateId3(),
-    toolName: part.functionCall.name,
-    args: JSON.stringify(part.functionCall.args),
-    providerMetadata: part.thoughtSignature ? {
-      [providerOptionsName]: {
-        thoughtSignature: part.thoughtSignature
-      }
-    } : void 0
-  }));
+  if (!isCustomReasoning(reasoning)) {
+    return void 0;
+  }
+  if (isGemini3Model(modelId) && !modelId.includes("gemini-3-pro-image")) {
+    return resolveGemini3ThinkingConfig({ reasoning, warnings });
+  }
+  return resolveGemini25ThinkingConfig({ reasoning, modelId, warnings });
+}
+function resolveGemini3ThinkingConfig({
+  reasoning,
+  warnings
+}) {
+  if (reasoning === "none") {
+    return { thinkingLevel: "minimal" };
+  }
+  const thinkingLevel = mapReasoningToProviderEffort({
+    reasoning,
+    effortMap: {
+      minimal: "minimal",
+      low: "low",
+      medium: "medium",
+      high: "high",
+      xhigh: "high"
+    },
+    warnings
+  });
+  if (thinkingLevel == null) {
+    return void 0;
+  }
+  return { thinkingLevel };
+}
+function resolveGemini25ThinkingConfig({
+  reasoning,
+  modelId,
+  warnings
+}) {
+  if (reasoning === "none") {
+    return { thinkingBudget: 0 };
+  }
+  const thinkingBudget = mapReasoningToProviderBudget({
+    reasoning,
+    maxOutputTokens: getMaxOutputTokensForGemini25Model(),
+    maxReasoningBudget: getMaxThinkingTokensForGemini25Model(modelId),
+    minReasoningBudget: 0,
+    warnings
+  });
+  if (thinkingBudget == null) {
+    return void 0;
+  }
+  return { thinkingBudget };
 }
 function extractSources({
   groundingMetadata,
@@ -1571,256 +2359,312 @@ 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 getContentSchema = () => import_v45.z.object({
-  parts: import_v45.z.array(
-    import_v45.z.union([
+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 = () => 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(),
-          args: import_v45.z.unknown()
+      z5.object({
+        functionCall: z5.object({
+          name: z5.string().nullish(),
+          args: z5.unknown().nullish(),
+          partialArgs: z5.array(partialArgSchema).nullish(),
+          willContinue: z5.boolean().nullish()
+        }),
+        thoughtSignature: z5.string().nullish()
+      }),
+      z5.object({
+        inlineData: z5.object({
+          mimeType: z5.string(),
+          data: z5.string()
+        }),
+        thought: z5.boolean().nullish(),
+        thoughtSignature: z5.string().nullish()
+      }),
+      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({
-        inlineData: import_v45.z.object({
-          mimeType: import_v45.z.string(),
-          data: import_v45.z.string()
+      z5.object({
+        toolResponse: z5.object({
+          toolType: z5.string(),
+          response: z5.unknown().nullish(),
+          id: z5.string()
         }),
-        thought: import_v45.z.boolean().nullish(),
-        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 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 tokenDetailsSchema = z5.array(
+  z5.object({
+    modality: z5.string(),
+    tokenCount: z5.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()
-      }).nullish()
+      promptFeedback: z5.object({
+        blockReason: z5.string().nullish(),
+        safetyRatings: z5.array(getSafetyRatingSchema()).nullish()
+      }).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()
-      }).nullish()
+      promptFeedback: z5.object({
+        blockReason: z5.string().nullish(),
+        safetyRatings: z5.array(getSafetyRatingSchema()).nullish()
+      }).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 { createProviderExecutedToolFactory } from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var codeExecution = createProviderExecutedToolFactory({
   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 {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory2,
+  lazySchema as lazySchema6,
+  zodSchema as zodSchema6
+} from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod/v4";
+var enterpriseWebSearch = createProviderExecutedToolFactory2({
   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({}))),
+  outputSchema: 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 {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory3,
+  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 fileSearch = (0, import_provider_utils9.createProviderToolFactory)({
+var fileSearch = createProviderExecutedToolFactory3({
   id: "google.file_search",
-  inputSchema: fileSearchArgsSchema
+  inputSchema: lazySchema7(() => zodSchema7(z8.object({}))),
+  outputSchema: lazySchema7(() => zodSchema7(z8.object({})))
 });
 
 // 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 {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory4,
+  lazySchema as lazySchema8,
+  zodSchema as zodSchema8
+} from "@ai-sdk/provider-utils";
+import { z as z9 } from "zod/v4";
+var googleMaps = createProviderExecutedToolFactory4({
   id: "google.google_maps",
-  inputSchema: (0, import_provider_utils10.lazySchema)(() => (0, import_provider_utils10.zodSchema)(import_v49.z.object({})))
+  inputSchema: lazySchema8(() => zodSchema8(z9.object({}))),
+  outputSchema: 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 {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory5,
+  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 googleSearch = (0, import_provider_utils11.createProviderToolFactory)(
-  {
-    id: "google.google_search",
-    inputSchema: googleSearchToolArgsSchema
-  }
-);
+var googleSearch = createProviderExecutedToolFactory5({
+  id: "google.google_search",
+  inputSchema: lazySchema9(() => zodSchema9(z10.object({}))),
+  outputSchema: lazySchema9(() => zodSchema9(z10.object({})))
+});
 
 // 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 {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory6,
+  lazySchema as lazySchema10,
+  zodSchema as zodSchema10
+} from "@ai-sdk/provider-utils";
+import { z as z11 } from "zod/v4";
+var urlContext = createProviderExecutedToolFactory6({
   id: "google.url_context",
-  inputSchema: (0, import_provider_utils12.lazySchema)(() => (0, import_provider_utils12.zodSchema)(import_v411.z.object({})))
+  inputSchema: lazySchema10(() => zodSchema10(z11.object({}))),
+  outputSchema: 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 {
+  createProviderExecutedToolFactory as createProviderExecutedToolFactory7,
+  lazySchema as lazySchema11,
+  zodSchema as zodSchema11
+} from "@ai-sdk/provider-utils";
+import { z as z12 } from "zod/v4";
+var vertexRagStore = createProviderExecutedToolFactory7({
   id: "google.vertex_rag_store",
-  inputSchema: import_v412.z.object({
-    ragCorpus: import_v412.z.string(),
-    topK: import_v412.z.number().optional()
-  })
+  inputSchema: lazySchema11(() => zodSchema11(z12.object({}))),
+  outputSchema: lazySchema11(() => zodSchema11(z12.object({})))
 });
 
 // src/google-tools.ts
@@ -1883,16 +2727,55 @@ var googleTools = {
   vertexRagStore
 };
 
-// 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 {
+// src/google-image-model.ts
+import {
+  combineHeaders as combineHeaders3,
+  convertToBase64 as convertToBase642,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  generateId as defaultGenerateId,
+  lazySchema as lazySchema13,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3,
+  resolve as resolve3,
+  serializeModelOptions as serializeModelOptions3,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE3,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE3,
+  zodSchema as zodSchema13
+} from "@ai-sdk/provider-utils";
+import { z as z14 } from "zod/v4";
+
+// src/google-image-model-options.ts
+import {
+  lazySchema as lazySchema12,
+  zodSchema as zodSchema12
+} from "@ai-sdk/provider-utils";
+import { z as z13 } from "zod/v4";
+var googleImageModelOptionsSchema = lazySchema12(
+  () => zodSchema12(
+    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-image-model.ts
+var GoogleImageModel = class _GoogleImageModel {
   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 _GoogleImageModel(options.modelId, {}, options.config);
+  }
   get maxImagesPerCall() {
     if (this.settings.maxImagesPerCall != null) {
       return this.settings.maxImagesPerCall;
@@ -1928,12 +2811,12 @@ var GoogleGenerativeAIImageModel = class {
     const warnings = [];
     if (files != null && files.length > 0) {
       throw new Error(
-        "Google Generative AI does not support image editing with Imagen models. Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities."
+        "Google Gemini API does not support image editing with Imagen models. Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities."
       );
     }
     if (mask != null) {
       throw new Error(
-        "Google Generative AI does not support image editing with masks. Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities."
+        "Google Gemini API does not support image editing with masks. Use Google Vertex AI (@ai-sdk/google-vertex) for image editing capabilities."
       );
     }
     if (size != null) {
@@ -1950,7 +2833,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
@@ -1969,12 +2852,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,
@@ -2040,13 +2926,16 @@ var GoogleGenerativeAIImageModel = class {
         if (file.type === "url") {
           userContent.push({
             type: "file",
-            data: new URL(file.url),
+            data: { type: "url", url: new URL(file.url) },
             mediaType: "image/*"
           });
         } else {
           userContent.push({
             type: "file",
-            data: typeof file.data === "string" ? file.data : new Uint8Array(file.data),
+            data: {
+              type: "data",
+              data: typeof file.data === "string" ? file.data : new Uint8Array(file.data)
+            },
             mediaType: file.mediaType
           });
         }
@@ -2055,12 +2944,12 @@ var GoogleGenerativeAIImageModel = class {
     const languageModelPrompt = [
       { role: "user", content: userContent }
     ];
-    const languageModel = new GoogleGenerativeAILanguageModel(this.modelId, {
+    const languageModel = new GoogleLanguageModel(this.modelId, {
       provider: this.config.provider,
       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,
@@ -2080,8 +2969,8 @@ var GoogleGenerativeAIImageModel = class {
     const currentDate = (_f = (_e = (_d = this.config._internal) == null ? void 0 : _d.currentDate) == null ? void 0 : _e.call(_d)) != null ? _f : /* @__PURE__ */ new Date();
     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));
+      if (part.type === "file" && part.mediaType.startsWith("image/") && part.data.type === "data") {
+        images.push(convertToBase642(part.data.data));
       }
     }
     return {
@@ -2108,27 +2997,215 @@ 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 = lazySchema13(
+  () => zodSchema13(
+    z14.object({
+      predictions: z14.array(z14.object({ bytesBase64Encoded: z14.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()
+
+// src/google-files.ts
+import {
+  AISDKError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders4,
+  convertInlineFileDataToUint8Array,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  delay,
+  lazySchema as lazySchema14,
+  parseProviderOptions as parseProviderOptions4,
+  zodSchema as zodSchema14,
+  getFromApi
+} from "@ai-sdk/provider-utils";
+import { z as z15 } from "zod/v4";
+var GoogleFiles = class {
+  constructor(config) {
+    this.config = config;
+    this.specificationVersion = "v4";
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async uploadFile(options) {
+    var _a, _b, _c, _d;
+    const googleOptions = await parseProviderOptions4({
+      provider: "google",
+      providerOptions: options.providerOptions,
+      schema: googleFilesUploadOptionsSchema
+    });
+    const resolvedHeaders = this.config.headers();
+    const fetchFn = (_a = this.config.fetch) != null ? _a : globalThis.fetch;
+    const warnings = [];
+    if (options.filename != null) {
+      warnings.push({ type: "unsupported", feature: "filename" });
+    }
+    const fileBytes = convertInlineFileDataToUint8Array(options.data);
+    const mediaType = options.mediaType;
+    const displayName = googleOptions == null ? void 0 : googleOptions.displayName;
+    const baseOrigin = this.config.baseURL.replace(/\/v1beta$/, "");
+    const initResponse = await fetchFn(`${baseOrigin}/upload/v1beta/files`, {
+      method: "POST",
+      headers: {
+        ...resolvedHeaders,
+        "X-Goog-Upload-Protocol": "resumable",
+        "X-Goog-Upload-Command": "start",
+        "X-Goog-Upload-Header-Content-Length": String(fileBytes.length),
+        "X-Goog-Upload-Header-Content-Type": mediaType,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        file: {
+          ...displayName != null ? { display_name: displayName } : {}
+        }
+      })
+    });
+    if (!initResponse.ok) {
+      const errorBody = await initResponse.text();
+      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 AISDKError({
+        name: "GOOGLE_FILES_UPLOAD_ERROR",
+        message: "No upload URL returned from initiation request"
+      });
+    }
+    const uploadResponse = await fetchFn(uploadUrl, {
+      method: "POST",
+      headers: {
+        "Content-Length": String(fileBytes.length),
+        "X-Goog-Upload-Offset": "0",
+        "X-Goog-Upload-Command": "upload, finalize"
+      },
+      body: fileBytes
+    });
+    if (!uploadResponse.ok) {
+      const errorBody = await uploadResponse.text();
+      throw new AISDKError({
+        name: "GOOGLE_FILES_UPLOAD_ERROR",
+        message: `Failed to upload file data: ${uploadResponse.status} ${errorBody}`
+      });
+    }
+    const uploadResult = await uploadResponse.json();
+    let file = uploadResult.file;
+    const pollIntervalMs = (_b = googleOptions == null ? void 0 : googleOptions.pollIntervalMs) != null ? _b : 2e3;
+    const pollTimeoutMs = (_c = googleOptions == null ? void 0 : googleOptions.pollTimeoutMs) != null ? _c : 3e5;
+    const startTime = Date.now();
+    while (file.state === "PROCESSING") {
+      if (Date.now() - startTime > pollTimeoutMs) {
+        throw new AISDKError({
+          name: "GOOGLE_FILES_UPLOAD_TIMEOUT",
+          message: `File processing timed out after ${pollTimeoutMs}ms`
+        });
+      }
+      await delay(pollIntervalMs);
+      const { value: fileStatus } = await getFromApi({
+        url: `${this.config.baseURL}/${file.name}`,
+        headers: combineHeaders4(resolvedHeaders),
+        successfulResponseHandler: createJsonResponseHandler4(
+          googleFileResponseSchema
+        ),
+        failedResponseHandler: googleFailedResponseHandler,
+        fetch: this.config.fetch
+      });
+      file = fileStatus;
+    }
+    if (file.state === "FAILED") {
+      throw new AISDKError({
+        name: "GOOGLE_FILES_UPLOAD_FAILED",
+        message: `File processing failed for ${file.name}`
+      });
+    }
+    return {
+      warnings,
+      providerReference: { google: file.uri },
+      mediaType: (_d = file.mimeType) != null ? _d : options.mediaType,
+      providerMetadata: {
+        google: {
+          name: file.name,
+          displayName: file.displayName,
+          mimeType: file.mimeType,
+          sizeBytes: file.sizeBytes,
+          state: file.state,
+          uri: file.uri,
+          ...file.createTime != null ? { createTime: file.createTime } : {},
+          ...file.updateTime != null ? { updateTime: file.updateTime } : {},
+          ...file.expirationTime != null ? { expirationTime: file.expirationTime } : {},
+          ...file.sha256Hash != null ? { sha256Hash: file.sha256Hash } : {}
+        }
+      }
+    };
+  }
+};
+var googleFileResponseSchema = lazySchema14(
+  () => zodSchema14(
+    z15.object({
+      name: z15.string(),
+      displayName: z15.string().nullish(),
+      mimeType: z15.string(),
+      sizeBytes: z15.string().nullish(),
+      createTime: z15.string().nullish(),
+      updateTime: z15.string().nullish(),
+      expirationTime: z15.string().nullish(),
+      sha256Hash: z15.string().nullish(),
+      uri: z15.string(),
+      state: z15.string()
     })
   )
 );
+var googleFilesUploadOptionsSchema = lazySchema14(
+  () => zodSchema14(
+    z15.object({
+      displayName: z15.string().nullish(),
+      pollIntervalMs: z15.number().positive().nullish(),
+      pollTimeoutMs: z15.number().positive().nullish()
+    }).passthrough()
+  )
+);
+
+// src/google-video-model.ts
+import {
+  AISDKError as AISDKError2
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders5,
+  convertUint8ArrayToBase64,
+  createJsonResponseHandler as createJsonResponseHandler5,
+  delay as delay2,
+  getFromApi as getFromApi2,
+  parseProviderOptions as parseProviderOptions5,
+  postJsonToApi as postJsonToApi4,
+  resolve as resolve4
+} from "@ai-sdk/provider-utils";
+import { z as z17 } from "zod/v4";
+
+// src/google-video-model-options.ts
+import { lazySchema as lazySchema15, zodSchema as zodSchema15 } from "@ai-sdk/provider-utils";
+import { z as z16 } from "zod/v4";
+var googleVideoModelOptionsSchema = lazySchema15(
+  () => zodSchema15(
+    z16.object({
+      pollIntervalMs: z16.number().positive().nullish(),
+      pollTimeoutMs: z16.number().positive().nullish(),
+      personGeneration: z16.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
+      negativePrompt: z16.string().nullish(),
+      referenceImages: z16.array(
+        z16.object({
+          bytesBase64Encoded: z16.string().nullish(),
+          gcsUri: z16.string().nullish()
+        })
+      ).nullish()
+    }).passthrough()
+  )
+);
 
-// src/google-generative-ai-video-model.ts
-var import_provider4 = require("@ai-sdk/provider");
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
-var import_v414 = require("zod/v4");
-var GoogleGenerativeAIVideoModel = class {
+// src/google-video-model.ts
+var GoogleVideoModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
@@ -2144,7 +3221,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_utils15.parseProviderOptions)({
+    const googleOptions = await parseProviderOptions5({
       provider: "google",
       providerOptions: options.providerOptions,
       schema: googleVideoModelOptionsSchema
@@ -2162,7 +3239,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_utils15.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",
@@ -2228,17 +3305,17 @@ var GoogleGenerativeAIVideoModel = class {
         }
       }
     }
-    const { value: operation } = await (0, import_provider_utils15.postJsonToApi)({
+    const { value: operation } = await postJsonToApi4({
       url: `${this.config.baseURL}/models/${this.modelId}:predictLongRunning`,
-      headers: (0, import_provider_utils15.combineHeaders)(
-        await (0, import_provider_utils15.resolve)(this.config.headers),
+      headers: combineHeaders5(
+        await resolve4(this.config.headers),
         options.headers
       ),
       body: {
         instances,
         parameters
       },
-      successfulResponseHandler: (0, import_provider_utils15.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler5(
         googleOperationSchema
       ),
       failedResponseHandler: googleFailedResponseHandler,
@@ -2247,7 +3324,7 @@ var GoogleGenerativeAIVideoModel = class {
     });
     const operationName = operation.name;
     if (!operationName) {
-      throw new import_provider4.AISDKError({
+      throw new AISDKError2({
         name: "GOOGLE_VIDEO_GENERATION_ERROR",
         message: "No operation name returned from API"
       });
@@ -2259,25 +3336,25 @@ var GoogleGenerativeAIVideoModel = class {
     let responseHeaders;
     while (!finalOperation.done) {
       if (Date.now() - startTime > pollTimeoutMs) {
-        throw new import_provider4.AISDKError({
+        throw new AISDKError2({
           name: "GOOGLE_VIDEO_GENERATION_TIMEOUT",
           message: `Video generation timed out after ${pollTimeoutMs}ms`
         });
       }
-      await (0, import_provider_utils15.delay)(pollIntervalMs);
+      await delay2(pollIntervalMs);
       if ((_f = options.abortSignal) == null ? void 0 : _f.aborted) {
-        throw new import_provider4.AISDKError({
+        throw new AISDKError2({
           name: "GOOGLE_VIDEO_GENERATION_ABORTED",
           message: "Video generation request was aborted"
         });
       }
-      const { value: statusOperation, responseHeaders: pollHeaders } = await (0, import_provider_utils15.getFromApi)({
+      const { value: statusOperation, responseHeaders: pollHeaders } = await getFromApi2({
         url: `${this.config.baseURL}/${operationName}`,
-        headers: (0, import_provider_utils15.combineHeaders)(
-          await (0, import_provider_utils15.resolve)(this.config.headers),
+        headers: combineHeaders5(
+          await resolve4(this.config.headers),
           options.headers
         ),
-        successfulResponseHandler: (0, import_provider_utils15.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler5(
           googleOperationSchema
         ),
         failedResponseHandler: googleFailedResponseHandler,
@@ -2288,21 +3365,21 @@ var GoogleGenerativeAIVideoModel = class {
       responseHeaders = pollHeaders;
     }
     if (finalOperation.error) {
-      throw new import_provider4.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_provider4.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_utils15.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) {
@@ -2318,7 +3395,7 @@ var GoogleGenerativeAIVideoModel = class {
       }
     }
     if (videos.length === 0) {
-      throw new import_provider4.AISDKError({
+      throw new AISDKError2({
         name: "GOOGLE_VIDEO_GENERATION_ERROR",
         message: "No valid videos in response"
       });
@@ -2339,51 +3416,35 @@ var GoogleGenerativeAIVideoModel = class {
     };
   }
 };
-var googleOperationSchema = import_v414.z.object({
-  name: import_v414.z.string().nullish(),
-  done: import_v414.z.boolean().nullish(),
-  error: import_v414.z.object({
-    code: import_v414.z.number().nullish(),
-    message: import_v414.z.string(),
-    status: import_v414.z.string().nullish()
+var googleOperationSchema = z17.object({
+  name: z17.string().nullish(),
+  done: z17.boolean().nullish(),
+  error: z17.object({
+    code: z17.number().nullish(),
+    message: z17.string(),
+    status: z17.string().nullish()
   }).nullish(),
-  response: import_v414.z.object({
-    generateVideoResponse: import_v414.z.object({
-      generatedSamples: import_v414.z.array(
-        import_v414.z.object({
-          video: import_v414.z.object({
-            uri: import_v414.z.string().nullish()
+  response: z17.object({
+    generateVideoResponse: z17.object({
+      generatedSamples: z17.array(
+        z17.object({
+          video: z17.object({
+            uri: z17.string().nullish()
           }).nullish()
         })
       ).nullish()
     }).nullish()
   }).nullish()
 });
-var googleVideoModelOptionsSchema = (0, import_provider_utils15.lazySchema)(
-  () => (0, import_provider_utils15.zodSchema)(
-    import_v414.z.object({
-      pollIntervalMs: import_v414.z.number().positive().nullish(),
-      pollTimeoutMs: import_v414.z.number().positive().nullish(),
-      personGeneration: import_v414.z.enum(["dont_allow", "allow_adult", "allow_all"]).nullish(),
-      negativePrompt: import_v414.z.string().nullish(),
-      referenceImages: import_v414.z.array(
-        import_v414.z.object({
-          bytesBase64Encoded: import_v414.z.string().nullish(),
-          gcsUri: import_v414.z.string().nullish()
-        })
-      ).nullish()
-    }).passthrough()
-  )
-);
 
 // src/google-provider.ts
-function createGoogleGenerativeAI(options = {}) {
+function createGoogle(options = {}) {
   var _a, _b;
-  const baseURL = (_a = (0, import_provider_utils16.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_utils16.withUserAgentSuffix)(
+  const getHeaders = () => withUserAgentSuffix(
     {
-      "x-goog-api-key": (0, import_provider_utils16.loadApiKey)({
+      "x-goog-api-key": loadApiKey({
         apiKey: options.apiKey,
         environmentVariableName: "GOOGLE_GENERATIVE_AI_API_KEY",
         description: "Google Generative AI"
@@ -2394,11 +3455,11 @@ function createGoogleGenerativeAI(options = {}) {
   );
   const createChatModel = (modelId) => {
     var _a2;
-    return new GoogleGenerativeAILanguageModel(modelId, {
+    return new GoogleLanguageModel(modelId, {
       provider: providerName,
       baseURL,
       headers: getHeaders,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils16.generateId,
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId2,
       supportedUrls: () => ({
         "*": [
           // Google Generative Language "files" endpoint
@@ -2414,13 +3475,19 @@ function createGoogleGenerativeAI(options = {}) {
       fetch: options.fetch
     });
   };
-  const createEmbeddingModel = (modelId) => new GoogleGenerativeAIEmbeddingModel(modelId, {
+  const createEmbeddingModel = (modelId) => new GoogleEmbeddingModel(modelId, {
+    provider: providerName,
+    baseURL,
+    headers: getHeaders,
+    fetch: options.fetch
+  });
+  const createImageModel = (modelId, settings = {}) => new GoogleImageModel(modelId, settings, {
     provider: providerName,
     baseURL,
     headers: getHeaders,
     fetch: options.fetch
   });
-  const createImageModel = (modelId, settings = {}) => new GoogleGenerativeAIImageModel(modelId, settings, {
+  const createFiles = () => new GoogleFiles({
     provider: providerName,
     baseURL,
     headers: getHeaders,
@@ -2428,12 +3495,12 @@ function createGoogleGenerativeAI(options = {}) {
   });
   const createVideoModel = (modelId) => {
     var _a2;
-    return new GoogleGenerativeAIVideoModel(modelId, {
+    return new GoogleVideoModel(modelId, {
       provider: providerName,
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
-      generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils16.generateId
+      generateId: (_a2 = options.generateId) != null ? _a2 : generateId2
     });
   };
   const provider = function(modelId) {
@@ -2456,14 +3523,15 @@ function createGoogleGenerativeAI(options = {}) {
   provider.imageModel = createImageModel;
   provider.video = createVideoModel;
   provider.videoModel = createVideoModel;
+  provider.files = createFiles;
   provider.tools = googleTools;
   return provider;
 }
-var google = createGoogleGenerativeAI();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+var google = createGoogle();
+export {
   VERSION,
-  createGoogleGenerativeAI,
+  createGoogle,
+  createGoogle as createGoogleGenerativeAI,
   google
-});
+};
 //# sourceMappingURL=index.js.map