@ai-sdk/google 1.2.17 → 2.0.0-alpha.1

package/dist/index.js

@@ -26,15 +26,136 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/google-provider.ts
+var import_provider4 = require("@ai-sdk/provider");
 var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
-// src/google-generative-ai-language-model.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+// src/google-generative-ai-embedding-model.ts
+var import_provider = require("@ai-sdk/provider");
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_zod3 = require("zod");
+
+// src/google-error.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_zod = require("zod");
+var googleErrorDataSchema = import_zod.z.object({
+  error: import_zod.z.object({
+    code: import_zod.z.number().nullable(),
+    message: import_zod.z.string(),
+    status: import_zod.z.string()
+  })
+});
+var googleFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+  errorSchema: googleErrorDataSchema,
+  errorToMessage: (data) => data.error.message
+});
+
+// src/google-generative-ai-embedding-options.ts
 var import_zod2 = require("zod");
+var googleGenerativeAIEmbeddingProviderOptions = import_zod2.z.object({
+  /**
+   * Optional. Optional reduced dimension for the output embedding.
+   * If set, excessive values in the output embedding are truncated from the end.
+   */
+  outputDimensionality: import_zod2.z.number().optional(),
+  /**
+   * Optional. Specifies the task type for generating embeddings.
+   * Supported task types:
+   * - SEMANTIC_SIMILARITY: Optimized for text similarity.
+   * - CLASSIFICATION: Optimized for text classification.
+   * - CLUSTERING: Optimized for clustering texts based on similarity.
+   * - RETRIEVAL_DOCUMENT: Optimized for document retrieval.
+   * - RETRIEVAL_QUERY: Optimized for query-based retrieval.
+   * - QUESTION_ANSWERING: Optimized for answering questions.
+   * - FACT_VERIFICATION: Optimized for verifying factual information.
+   * - CODE_RETRIEVAL_QUERY: Optimized for retrieving code blocks based on natural language queries.
+   */
+  taskType: import_zod2.z.enum([
+    "SEMANTIC_SIMILARITY",
+    "CLASSIFICATION",
+    "CLUSTERING",
+    "RETRIEVAL_DOCUMENT",
+    "RETRIEVAL_QUERY",
+    "QUESTION_ANSWERING",
+    "FACT_VERIFICATION",
+    "CODE_RETRIEVAL_QUERY"
+  ]).optional()
+});
+
+// src/google-generative-ai-embedding-model.ts
+var GoogleGenerativeAIEmbeddingModel = class {
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
+    this.maxEmbeddingsPerCall = 2048;
+    this.supportsParallelCalls = true;
+    this.modelId = modelId;
+    this.config = config;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async doEmbed({
+    values,
+    headers,
+    abortSignal,
+    providerOptions
+  }) {
+    const googleOptions = await (0, import_provider_utils2.parseProviderOptions)({
+      provider: "google",
+      providerOptions,
+      schema: googleGenerativeAIEmbeddingProviderOptions
+    });
+    if (values.length > this.maxEmbeddingsPerCall) {
+      throw new import_provider.TooManyEmbeddingValuesForCallError({
+        provider: this.provider,
+        modelId: this.modelId,
+        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
+        values
+      });
+    }
+    const mergedHeaders = (0, import_provider_utils2.combineHeaders)(
+      await (0, import_provider_utils2.resolve)(this.config.headers),
+      headers
+    );
+    const {
+      responseHeaders,
+      value: response,
+      rawValue
+    } = await (0, import_provider_utils2.postJsonToApi)({
+      url: `${this.config.baseURL}/models/${this.modelId}:batchEmbedContents`,
+      headers: mergedHeaders,
+      body: {
+        requests: values.map((value) => ({
+          model: `models/${this.modelId}`,
+          content: { role: "user", parts: [{ text: value }] },
+          outputDimensionality: googleOptions == null ? void 0 : googleOptions.outputDimensionality,
+          taskType: googleOptions == null ? void 0 : googleOptions.taskType
+        }))
+      },
+      failedResponseHandler: googleFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+        googleGenerativeAITextEmbeddingResponseSchema
+      ),
+      abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      embeddings: response.embeddings.map((item) => item.values),
+      usage: void 0,
+      response: { headers: responseHeaders, body: rawValue }
+    };
+  }
+};
+var googleGenerativeAITextEmbeddingResponseSchema = import_zod3.z.object({
+  embeddings: import_zod3.z.array(import_zod3.z.object({ values: import_zod3.z.array(import_zod3.z.number()) }))
+});
+
+// src/google-generative-ai-language-model.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_zod5 = require("zod");
 
 // src/convert-json-schema-to-openapi-schema.ts
 function convertJSONSchemaToOpenAPISchema(jsonSchema) {
-  if (isEmptyObjectSchema(jsonSchema)) {
+  if (jsonSchema == null || isEmptyObjectSchema(jsonSchema)) {
     return void 0;
   }
   if (typeof jsonSchema === "boolean") {
@@ -130,10 +251,9 @@ function isEmptyObjectSchema(jsonSchema) {
 }
 
 // src/convert-to-google-generative-ai-messages.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_provider2 = require("@ai-sdk/provider");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 function convertToGoogleGenerativeAIMessages(prompt) {
-  var _a, _b;
   const systemInstructionParts = [];
   const contents = [];
   let systemMessagesAllowed = true;
@@ -141,7 +261,7 @@ function convertToGoogleGenerativeAIMessages(prompt) {
     switch (role) {
       case "system": {
         if (!systemMessagesAllowed) {
-          throw new import_provider.UnsupportedFunctionalityError({
+          throw new import_provider2.UnsupportedFunctionalityError({
             functionality: "system messages are only supported at the beginning of the conversation"
           });
         }
@@ -157,33 +277,18 @@ function convertToGoogleGenerativeAIMessages(prompt) {
               parts.push({ text: part.text });
               break;
             }
-            case "image": {
-              parts.push(
-                part.image instanceof URL ? {
-                  fileData: {
-                    mimeType: (_a = part.mimeType) != null ? _a : "image/jpeg",
-                    fileUri: part.image.toString()
-                  }
-                } : {
-                  inlineData: {
-                    mimeType: (_b = part.mimeType) != null ? _b : "image/jpeg",
-                    data: (0, import_provider_utils.convertUint8ArrayToBase64)(part.image)
-                  }
-                }
-              );
-              break;
-            }
             case "file": {
+              const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType;
               parts.push(
                 part.data instanceof URL ? {
                   fileData: {
-                    mimeType: part.mimeType,
+                    mimeType: mediaType,
                     fileUri: part.data.toString()
                   }
                 } : {
                   inlineData: {
-                    mimeType: part.mimeType,
-                    data: part.data
+                    mimeType: mediaType,
+                    data: (0, import_provider_utils3.convertToBase64)(part.data)
                   }
                 }
               );
@@ -204,20 +309,20 @@ function convertToGoogleGenerativeAIMessages(prompt) {
                 return part.text.length === 0 ? void 0 : { text: part.text };
               }
               case "file": {
-                if (part.mimeType !== "image/png") {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                if (part.mediaType !== "image/png") {
+                  throw new import_provider2.UnsupportedFunctionalityError({
                     functionality: "Only PNG images are supported in assistant messages"
                   });
                 }
                 if (part.data instanceof URL) {
-                  throw new import_provider.UnsupportedFunctionalityError({
+                  throw new import_provider2.UnsupportedFunctionalityError({
                     functionality: "File data URLs in assistant messages are not supported"
                   });
                 }
                 return {
                   inlineData: {
-                    mimeType: part.mimeType,
-                    data: part.data
+                    mimeType: part.mediaType,
+                    data: (0, import_provider_utils3.convertToBase64)(part.data)
                   }
                 };
               }
@@ -263,33 +368,110 @@ function getModelPath(modelId) {
   return modelId.includes("/") ? modelId : `models/${modelId}`;
 }
 
-// src/google-error.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod = require("zod");
-var googleErrorDataSchema = import_zod.z.object({
-  error: import_zod.z.object({
-    code: import_zod.z.number().nullable(),
-    message: import_zod.z.string(),
-    status: import_zod.z.string()
-  })
+// src/google-generative-ai-options.ts
+var import_zod4 = require("zod");
+var dynamicRetrievalConfig = import_zod4.z.object({
+  /**
+   * The mode of the predictor to be used in dynamic retrieval.
+   */
+  mode: import_zod4.z.enum(["MODE_UNSPECIFIED", "MODE_DYNAMIC"]).optional(),
+  /**
+   * The threshold to be used in dynamic retrieval. If not set, a system default
+   * value is used.
+   */
+  dynamicThreshold: import_zod4.z.number().optional()
 });
-var googleFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
-  errorSchema: googleErrorDataSchema,
-  errorToMessage: (data) => data.error.message
+var googleGenerativeAIProviderOptions = import_zod4.z.object({
+  responseModalities: import_zod4.z.array(import_zod4.z.enum(["TEXT", "IMAGE"])).optional(),
+  thinkingConfig: import_zod4.z.object({
+    thinkingBudget: import_zod4.z.number().optional()
+  }).optional(),
+  /**
+  Optional.
+  The name of the cached content used as context to serve the prediction.
+  Format: cachedContents/{cachedContent}
+     */
+  cachedContent: import_zod4.z.string().optional(),
+  /**
+   * Optional. Enable structured output. Default is true.
+   *
+   * This is useful when the JSON Schema contains elements that are
+   * not supported by the OpenAPI schema version that
+   * Google Generative AI uses. You can use this to disable
+   * structured outputs if you need to.
+   */
+  structuredOutputs: import_zod4.z.boolean().optional(),
+  /**
+  Optional. A list of unique safety settings for blocking unsafe content.
+   */
+  safetySettings: import_zod4.z.array(
+    import_zod4.z.object({
+      category: import_zod4.z.enum([
+        "HARM_CATEGORY_UNSPECIFIED",
+        "HARM_CATEGORY_HATE_SPEECH",
+        "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "HARM_CATEGORY_HARASSMENT",
+        "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "HARM_CATEGORY_CIVIC_INTEGRITY"
+      ]),
+      threshold: import_zod4.z.enum([
+        "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+        "BLOCK_LOW_AND_ABOVE",
+        "BLOCK_MEDIUM_AND_ABOVE",
+        "BLOCK_ONLY_HIGH",
+        "BLOCK_NONE",
+        "OFF"
+      ])
+    })
+  ).optional(),
+  threshold: import_zod4.z.enum([
+    "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+    "BLOCK_LOW_AND_ABOVE",
+    "BLOCK_MEDIUM_AND_ABOVE",
+    "BLOCK_ONLY_HIGH",
+    "BLOCK_NONE",
+    "OFF"
+  ]).optional(),
+  /**
+   * Optional. Enables timestamp understanding for audio-only files.
+   *
+   * https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
+   */
+  audioTimestamp: import_zod4.z.boolean().optional(),
+  /**
+  Optional. When enabled, the model will use Google search to ground the response.
+  
+  @see https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/overview
+   */
+  useSearchGrounding: import_zod4.z.boolean().optional(),
+  /**
+  Optional. Specifies the dynamic retrieval configuration.
+  
+  @note Dynamic retrieval is only compatible with Gemini 1.5 Flash.
+  
+  @see https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/ground-with-google-search#dynamic-retrieval
+   */
+  dynamicRetrievalConfig: dynamicRetrievalConfig.optional()
 });
 
 // src/google-prepare-tools.ts
-var import_provider2 = require("@ai-sdk/provider");
-function prepareTools(mode, useSearchGrounding, dynamicRetrievalConfig, modelId) {
-  var _a, _b;
-  const tools = ((_a = mode.tools) == null ? void 0 : _a.length) ? mode.tools : void 0;
+var import_provider3 = require("@ai-sdk/provider");
+function prepareTools({
+  tools,
+  toolChoice,
+  useSearchGrounding,
+  dynamicRetrievalConfig: dynamicRetrievalConfig2,
+  modelId
+}) {
+  var _a;
+  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
   const toolWarnings = [];
   const isGemini2 = modelId.includes("gemini-2");
   const supportsDynamicRetrieval = modelId.includes("gemini-1.5-flash") && !modelId.includes("-8b");
   if (useSearchGrounding) {
     return {
       tools: isGemini2 ? { googleSearch: {} } : {
-        googleSearchRetrieval: !supportsDynamicRetrieval || !dynamicRetrievalConfig ? {} : { dynamicRetrievalConfig }
+        googleSearchRetrieval: !supportsDynamicRetrieval || !dynamicRetrievalConfig2 ? {} : { dynamicRetrievalConfig: dynamicRetrievalConfig2 }
       },
       toolConfig: void 0,
       toolWarnings
@@ -305,12 +487,11 @@ function prepareTools(mode, useSearchGrounding, dynamicRetrievalConfig, modelId)
     } else {
       functionDeclarations.push({
         name: tool.name,
-        description: (_b = tool.description) != null ? _b : "",
+        description: (_a = tool.description) != null ? _a : "",
         parameters: convertJSONSchemaToOpenAPISchema(tool.parameters)
       });
     }
   }
-  const toolChoice = mode.toolChoice;
   if (toolChoice == null) {
     return {
       tools: { functionDeclarations },
@@ -351,8 +532,8 @@ function prepareTools(mode, useSearchGrounding, dynamicRetrievalConfig, modelId)
       };
     default: {
       const _exhaustiveCheck = type;
-      throw new import_provider2.UnsupportedFunctionalityError({
-        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+      throw new import_provider3.UnsupportedFunctionalityError({
+        functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
   }
@@ -387,25 +568,21 @@ function mapGoogleGenerativeAIFinishReason({
 
 // src/google-generative-ai-language-model.ts
 var GoogleGenerativeAILanguageModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
-    this.defaultObjectGenerationMode = "json";
-    this.supportsImageUrls = false;
+  constructor(modelId, config) {
+    this.specificationVersion = "v2";
     this.modelId = modelId;
-    this.settings = settings;
     this.config = config;
   }
-  get supportsStructuredOutputs() {
-    var _a;
-    return (_a = this.settings.structuredOutputs) != null ? _a : true;
-  }
   get provider() {
     return this.config.provider;
   }
+  get supportedUrls() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.config).supportedUrls) == null ? void 0 : _b.call(_a)) != null ? _c : {};
+  }
   async getArgs({
-    mode,
     prompt,
-    maxTokens,
+    maxOutputTokens,
     temperature,
     topP,
     topK,
@@ -414,195 +591,168 @@ var GoogleGenerativeAILanguageModel = class {
     stopSequences,
     responseFormat,
     seed,
-    providerMetadata
+    tools,
+    toolChoice,
+    providerOptions
   }) {
     var _a, _b;
-    const type = mode.type;
     const warnings = [];
-    const googleOptions = (0, import_provider_utils3.parseProviderOptions)({
+    const googleOptions = await (0, import_provider_utils4.parseProviderOptions)({
       provider: "google",
-      providerOptions: providerMetadata,
-      schema: googleGenerativeAIProviderOptionsSchema
+      providerOptions,
+      schema: googleGenerativeAIProviderOptions
     });
-    const generationConfig = {
-      // standardized settings:
-      maxOutputTokens: maxTokens,
-      temperature,
-      topK,
-      topP,
-      frequencyPenalty,
-      presencePenalty,
-      stopSequences,
-      seed,
-      // response format:
-      responseMimeType: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? "application/json" : void 0,
-      responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
-      // so this is needed as an escape hatch:
-      this.supportsStructuredOutputs ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
-      ...this.settings.audioTimestamp && {
-        audioTimestamp: this.settings.audioTimestamp
-      },
-      // provider options:
-      responseModalities: googleOptions == null ? void 0 : googleOptions.responseModalities,
-      thinkingConfig: googleOptions == null ? void 0 : googleOptions.thinkingConfig
-    };
     const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(prompt);
-    switch (type) {
-      case "regular": {
-        const { tools, toolConfig, toolWarnings } = prepareTools(
-          mode,
-          (_a = this.settings.useSearchGrounding) != null ? _a : false,
-          this.settings.dynamicRetrievalConfig,
-          this.modelId
-        );
-        return {
-          args: {
-            generationConfig,
-            contents,
-            systemInstruction,
-            safetySettings: this.settings.safetySettings,
-            tools,
-            toolConfig,
-            cachedContent: this.settings.cachedContent
-          },
-          warnings: [...warnings, ...toolWarnings]
-        };
-      }
-      case "object-json": {
-        return {
-          args: {
-            generationConfig: {
-              ...generationConfig,
-              responseMimeType: "application/json",
-              responseSchema: mode.schema != null && // Google GenAI does not support all OpenAPI Schema features,
-              // so this is needed as an escape hatch:
-              this.supportsStructuredOutputs ? convertJSONSchemaToOpenAPISchema(mode.schema) : void 0
-            },
-            contents,
-            systemInstruction,
-            safetySettings: this.settings.safetySettings,
-            cachedContent: this.settings.cachedContent
-          },
-          warnings
-        };
-      }
-      case "object-tool": {
-        return {
-          args: {
-            generationConfig,
-            contents,
-            tools: {
-              functionDeclarations: [
-                {
-                  name: mode.tool.name,
-                  description: (_b = mode.tool.description) != null ? _b : "",
-                  parameters: convertJSONSchemaToOpenAPISchema(
-                    mode.tool.parameters
-                  )
-                }
-              ]
-            },
-            toolConfig: { functionCallingConfig: { mode: "ANY" } },
-            safetySettings: this.settings.safetySettings,
-            cachedContent: this.settings.cachedContent
+    const {
+      tools: googleTools,
+      toolConfig: googleToolConfig,
+      toolWarnings
+    } = prepareTools({
+      tools,
+      toolChoice,
+      useSearchGrounding: (_a = googleOptions == null ? void 0 : googleOptions.useSearchGrounding) != null ? _a : false,
+      dynamicRetrievalConfig: googleOptions == null ? void 0 : googleOptions.dynamicRetrievalConfig,
+      modelId: this.modelId
+    });
+    return {
+      args: {
+        generationConfig: {
+          // standardized settings:
+          maxOutputTokens,
+          temperature,
+          topK,
+          topP,
+          frequencyPenalty,
+          presencePenalty,
+          stopSequences,
+          seed,
+          // response format:
+          responseMimeType: (responseFormat == null ? void 0 : responseFormat.type) === "json" ? "application/json" : void 0,
+          responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
+          // so this is needed as an escape hatch:
+          // TODO convert into provider option
+          ((_b = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _b : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
+          ...(googleOptions == null ? void 0 : googleOptions.audioTimestamp) && {
+            audioTimestamp: googleOptions.audioTimestamp
           },
-          warnings
-        };
-      }
-      default: {
-        const _exhaustiveCheck = type;
-        throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
-      }
-    }
-  }
-  supportsUrl(url) {
-    return this.config.isSupportedUrl(url);
+          // provider options:
+          responseModalities: googleOptions == null ? void 0 : googleOptions.responseModalities,
+          thinkingConfig: googleOptions == null ? void 0 : googleOptions.thinkingConfig
+        },
+        contents,
+        systemInstruction,
+        safetySettings: googleOptions == null ? void 0 : googleOptions.safetySettings,
+        tools: googleTools,
+        toolConfig: googleToolConfig,
+        cachedContent: googleOptions == null ? void 0 : googleOptions.cachedContent
+      },
+      warnings: [...warnings, ...toolWarnings]
+    };
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
-    const mergedHeaders = (0, import_provider_utils3.combineHeaders)(
-      await (0, import_provider_utils3.resolve)(this.config.headers),
+    const mergedHeaders = (0, import_provider_utils4.combineHeaders)(
+      await (0, import_provider_utils4.resolve)(this.config.headers),
       options.headers
     );
     const {
       responseHeaders,
       value: response,
       rawValue: rawResponse
-    } = await (0, import_provider_utils3.postJsonToApi)({
+    } = await (0, import_provider_utils4.postJsonToApi)({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:generateContent`,
       headers: mergedHeaders,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(responseSchema),
+      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(responseSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { contents: rawPrompt, ...rawSettings } = args;
     const candidate = response.candidates[0];
-    const parts = candidate.content == null || typeof candidate.content !== "object" || !("parts" in candidate.content) ? [] : candidate.content.parts;
-    const toolCalls = getToolCallsFromParts({
-      parts,
+    const content = [];
+    const parts = candidate.content == null || typeof candidate.content !== "object" || !("parts" in candidate.content) ? [] : (_a = candidate.content.parts) != null ? _a : [];
+    for (const part of parts) {
+      if ("text" in part && part.text.length > 0) {
+        content.push({ type: "text", text: part.text });
+      } else if ("functionCall" in part) {
+        content.push({
+          type: "tool-call",
+          toolCallType: "function",
+          toolCallId: this.config.generateId(),
+          toolName: part.functionCall.name,
+          args: JSON.stringify(part.functionCall.args)
+        });
+      } else if ("inlineData" in part) {
+        content.push({
+          type: "file",
+          data: part.inlineData.data,
+          mediaType: part.inlineData.mimeType
+        });
+      }
+    }
+    const sources = (_b = extractSources({
+      groundingMetadata: candidate.groundingMetadata,
       generateId: this.config.generateId
-    });
+    })) != null ? _b : [];
+    for (const source of sources) {
+      content.push(source);
+    }
     const usageMetadata = response.usageMetadata;
     return {
-      text: getTextFromParts(parts),
-      files: (_a = getInlineDataParts(parts)) == null ? void 0 : _a.map((part) => ({
-        data: part.inlineData.data,
-        mimeType: part.inlineData.mimeType
-      })),
-      toolCalls,
+      content,
       finishReason: mapGoogleGenerativeAIFinishReason({
         finishReason: candidate.finishReason,
-        hasToolCalls: toolCalls != null && toolCalls.length > 0
+        hasToolCalls: content.some((part) => part.type === "tool-call")
       }),
       usage: {
-        promptTokens: (_b = usageMetadata == null ? void 0 : usageMetadata.promptTokenCount) != null ? _b : NaN,
-        completionTokens: (_c = usageMetadata == null ? void 0 : usageMetadata.candidatesTokenCount) != null ? _c : NaN
+        inputTokens: (_c = usageMetadata == null ? void 0 : usageMetadata.promptTokenCount) != null ? _c : void 0,
+        outputTokens: (_d = usageMetadata == null ? void 0 : usageMetadata.candidatesTokenCount) != null ? _d : void 0,
+        totalTokens: (_e = usageMetadata == null ? void 0 : usageMetadata.totalTokenCount) != null ? _e : void 0,
+        reasoningTokens: (_f = usageMetadata == null ? void 0 : usageMetadata.thoughtsTokenCount) != null ? _f : void 0,
+        cachedInputTokens: (_g = usageMetadata == null ? void 0 : usageMetadata.cachedContentTokenCount) != null ? _g : void 0
       },
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders, body: rawResponse },
       warnings,
       providerMetadata: {
         google: {
-          groundingMetadata: (_d = candidate.groundingMetadata) != null ? _d : null,
-          safetyRatings: (_e = candidate.safetyRatings) != null ? _e : null
+          groundingMetadata: (_h = candidate.groundingMetadata) != null ? _h : null,
+          safetyRatings: (_i = candidate.safetyRatings) != null ? _i : null
         }
       },
-      sources: extractSources({
-        groundingMetadata: candidate.groundingMetadata,
-        generateId: this.config.generateId
-      }),
-      request: { body }
+      request: { body },
+      response: {
+        // TODO timestamp, model id, id
+        headers: responseHeaders,
+        body: rawResponse
+      }
     };
   }
   async doStream(options) {
     const { args, warnings } = await this.getArgs(options);
     const body = JSON.stringify(args);
-    const headers = (0, import_provider_utils3.combineHeaders)(
-      await (0, import_provider_utils3.resolve)(this.config.headers),
+    const headers = (0, import_provider_utils4.combineHeaders)(
+      await (0, import_provider_utils4.resolve)(this.config.headers),
       options.headers
     );
-    const { responseHeaders, value: response } = await (0, import_provider_utils3.postJsonToApi)({
+    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
       url: `${this.config.baseURL}/${getModelPath(
         this.modelId
       )}:streamGenerateContent?alt=sse`,
       headers,
       body: args,
       failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils3.createEventSourceResponseHandler)(chunkSchema),
+      successfulResponseHandler: (0, import_provider_utils4.createEventSourceResponseHandler)(chunkSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { contents: rawPrompt, ...rawSettings } = args;
     let finishReason = "unknown";
-    let usage = {
-      promptTokens: Number.NaN,
-      completionTokens: Number.NaN
+    const usage = {
+      inputTokens: void 0,
+      outputTokens: void 0,
+      totalTokens: void 0
     };
     let providerMetadata = void 0;
     const generateId2 = this.config.generateId;
@@ -610,8 +760,11 @@ var GoogleGenerativeAILanguageModel = class {
     return {
       stream: response.pipeThrough(
         new TransformStream({
+          start(controller) {
+            controller.enqueue({ type: "stream-start", warnings });
+          },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i;
             if (!chunk.success) {
               controller.enqueue({ type: "error", error: chunk.error });
               return;
@@ -619,12 +772,13 @@ var GoogleGenerativeAILanguageModel = class {
             const value = chunk.value;
             const usageMetadata = value.usageMetadata;
             if (usageMetadata != null) {
-              usage = {
-                promptTokens: (_a = usageMetadata.promptTokenCount) != null ? _a : NaN,
-                completionTokens: (_b = usageMetadata.candidatesTokenCount) != null ? _b : NaN
-              };
+              usage.inputTokens = (_a = usageMetadata.promptTokenCount) != null ? _a : void 0;
+              usage.outputTokens = (_b = usageMetadata.candidatesTokenCount) != null ? _b : void 0;
+              usage.totalTokens = (_c = usageMetadata.totalTokenCount) != null ? _c : void 0;
+              usage.reasoningTokens = (_d = usageMetadata.thoughtsTokenCount) != null ? _d : void 0;
+              usage.cachedInputTokens = (_e = usageMetadata.cachedContentTokenCount) != null ? _e : void 0;
             }
-            const candidate = (_c = value.candidates) == null ? void 0 : _c[0];
+            const candidate = (_f = value.candidates) == null ? void 0 : _f[0];
             if (candidate == null) {
               return;
             }
@@ -632,17 +786,14 @@ var GoogleGenerativeAILanguageModel = class {
             if (content != null) {
               const deltaText = getTextFromParts(content.parts);
               if (deltaText != null) {
-                controller.enqueue({
-                  type: "text-delta",
-                  textDelta: deltaText
-                });
+                controller.enqueue(deltaText);
               }
               const inlineDataParts = getInlineDataParts(content.parts);
               if (inlineDataParts != null) {
                 for (const part of inlineDataParts) {
                   controller.enqueue({
                     type: "file",
-                    mimeType: part.inlineData.mimeType,
+                    mediaType: part.inlineData.mimeType,
                     data: part.inlineData.data
                   });
                 }
@@ -676,17 +827,17 @@ var GoogleGenerativeAILanguageModel = class {
                 finishReason: candidate.finishReason,
                 hasToolCalls
               });
-              const sources = (_d = extractSources({
+              const sources = (_g = extractSources({
                 groundingMetadata: candidate.groundingMetadata,
                 generateId: generateId2
-              })) != null ? _d : [];
+              })) != null ? _g : [];
               for (const source of sources) {
-                controller.enqueue({ type: "source", source });
+                controller.enqueue(source);
               }
               providerMetadata = {
                 google: {
-                  groundingMetadata: (_e = candidate.groundingMetadata) != null ? _e : null,
-                  safetyRatings: (_f = candidate.safetyRatings) != null ? _f : null
+                  groundingMetadata: (_h = candidate.groundingMetadata) != null ? _h : null,
+                  safetyRatings: (_i = candidate.safetyRatings) != null ? _i : null
                 }
               };
             }
@@ -701,9 +852,7 @@ var GoogleGenerativeAILanguageModel = class {
           }
         })
       ),
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
-      warnings,
+      response: { headers: responseHeaders },
       request: { body }
     };
   }
@@ -716,6 +865,7 @@ function getToolCallsFromParts({
     (part) => "functionCall" in part
   );
   return functionCallParts == null || functionCallParts.length === 0 ? void 0 : functionCallParts.map((part) => ({
+    type: "tool-call",
     toolCallType: "function",
     toolCallId: generateId2(),
     toolName: part.functionCall.name,
@@ -724,7 +874,10 @@ function getToolCallsFromParts({
 }
 function getTextFromParts(parts) {
   const textParts = parts == null ? void 0 : parts.filter((part) => "text" in part);
-  return textParts == null || textParts.length === 0 ? void 0 : textParts.map((part) => part.text).join("");
+  return textParts == null || textParts.length === 0 ? void 0 : {
+    type: "text",
+    text: textParts.map((part) => part.text).join("")
+  };
 }
 function getInlineDataParts(parts) {
   return parts == null ? void 0 : parts.filter(
@@ -739,180 +892,103 @@ function extractSources({
   return (_a = groundingMetadata == null ? void 0 : groundingMetadata.groundingChunks) == null ? void 0 : _a.filter(
     (chunk) => chunk.web != null
   ).map((chunk) => ({
+    type: "source",
     sourceType: "url",
     id: generateId2(),
     url: chunk.web.uri,
     title: chunk.web.title
   }));
 }
-var contentSchema = import_zod2.z.object({
-  role: import_zod2.z.string(),
-  parts: import_zod2.z.array(
-    import_zod2.z.union([
-      import_zod2.z.object({
-        text: import_zod2.z.string()
+var contentSchema = import_zod5.z.object({
+  role: import_zod5.z.string(),
+  parts: import_zod5.z.array(
+    import_zod5.z.union([
+      import_zod5.z.object({
+        text: import_zod5.z.string()
       }),
-      import_zod2.z.object({
-        functionCall: import_zod2.z.object({
-          name: import_zod2.z.string(),
-          args: import_zod2.z.unknown()
+      import_zod5.z.object({
+        functionCall: import_zod5.z.object({
+          name: import_zod5.z.string(),
+          args: import_zod5.z.unknown()
         })
       }),
-      import_zod2.z.object({
-        inlineData: import_zod2.z.object({
-          mimeType: import_zod2.z.string(),
-          data: import_zod2.z.string()
+      import_zod5.z.object({
+        inlineData: import_zod5.z.object({
+          mimeType: import_zod5.z.string(),
+          data: import_zod5.z.string()
         })
       })
     ])
   ).nullish()
 });
-var groundingChunkSchema = import_zod2.z.object({
-  web: import_zod2.z.object({ uri: import_zod2.z.string(), title: import_zod2.z.string() }).nullish(),
-  retrievedContext: import_zod2.z.object({ uri: import_zod2.z.string(), title: import_zod2.z.string() }).nullish()
+var groundingChunkSchema = import_zod5.z.object({
+  web: import_zod5.z.object({ uri: import_zod5.z.string(), title: import_zod5.z.string() }).nullish(),
+  retrievedContext: import_zod5.z.object({ uri: import_zod5.z.string(), title: import_zod5.z.string() }).nullish()
 });
-var groundingMetadataSchema = import_zod2.z.object({
-  webSearchQueries: import_zod2.z.array(import_zod2.z.string()).nullish(),
-  retrievalQueries: import_zod2.z.array(import_zod2.z.string()).nullish(),
-  searchEntryPoint: import_zod2.z.object({ renderedContent: import_zod2.z.string() }).nullish(),
-  groundingChunks: import_zod2.z.array(groundingChunkSchema).nullish(),
-  groundingSupports: import_zod2.z.array(
-    import_zod2.z.object({
-      segment: import_zod2.z.object({
-        startIndex: import_zod2.z.number().nullish(),
-        endIndex: import_zod2.z.number().nullish(),
-        text: import_zod2.z.string().nullish()
+var groundingMetadataSchema = import_zod5.z.object({
+  webSearchQueries: import_zod5.z.array(import_zod5.z.string()).nullish(),
+  retrievalQueries: import_zod5.z.array(import_zod5.z.string()).nullish(),
+  searchEntryPoint: import_zod5.z.object({ renderedContent: import_zod5.z.string() }).nullish(),
+  groundingChunks: import_zod5.z.array(groundingChunkSchema).nullish(),
+  groundingSupports: import_zod5.z.array(
+    import_zod5.z.object({
+      segment: import_zod5.z.object({
+        startIndex: import_zod5.z.number().nullish(),
+        endIndex: import_zod5.z.number().nullish(),
+        text: import_zod5.z.string().nullish()
       }),
-      segment_text: import_zod2.z.string().nullish(),
-      groundingChunkIndices: import_zod2.z.array(import_zod2.z.number()).nullish(),
-      supportChunkIndices: import_zod2.z.array(import_zod2.z.number()).nullish(),
-      confidenceScores: import_zod2.z.array(import_zod2.z.number()).nullish(),
-      confidenceScore: import_zod2.z.array(import_zod2.z.number()).nullish()
+      segment_text: import_zod5.z.string().nullish(),
+      groundingChunkIndices: import_zod5.z.array(import_zod5.z.number()).nullish(),
+      supportChunkIndices: import_zod5.z.array(import_zod5.z.number()).nullish(),
+      confidenceScores: import_zod5.z.array(import_zod5.z.number()).nullish(),
+      confidenceScore: import_zod5.z.array(import_zod5.z.number()).nullish()
     })
   ).nullish(),
-  retrievalMetadata: import_zod2.z.union([
-    import_zod2.z.object({
-      webDynamicRetrievalScore: import_zod2.z.number()
+  retrievalMetadata: import_zod5.z.union([
+    import_zod5.z.object({
+      webDynamicRetrievalScore: import_zod5.z.number()
     }),
-    import_zod2.z.object({})
+    import_zod5.z.object({})
   ]).nullish()
 });
-var safetyRatingSchema = import_zod2.z.object({
-  category: import_zod2.z.string().nullish(),
-  probability: import_zod2.z.string().nullish(),
-  probabilityScore: import_zod2.z.number().nullish(),
-  severity: import_zod2.z.string().nullish(),
-  severityScore: import_zod2.z.number().nullish(),
-  blocked: import_zod2.z.boolean().nullish()
+var safetyRatingSchema = import_zod5.z.object({
+  category: import_zod5.z.string().nullish(),
+  probability: import_zod5.z.string().nullish(),
+  probabilityScore: import_zod5.z.number().nullish(),
+  severity: import_zod5.z.string().nullish(),
+  severityScore: import_zod5.z.number().nullish(),
+  blocked: import_zod5.z.boolean().nullish()
 });
-var responseSchema = import_zod2.z.object({
-  candidates: import_zod2.z.array(
-    import_zod2.z.object({
-      content: contentSchema.nullish().or(import_zod2.z.object({}).strict()),
-      finishReason: import_zod2.z.string().nullish(),
-      safetyRatings: import_zod2.z.array(safetyRatingSchema).nullish(),
+var usageSchema = import_zod5.z.object({
+  cachedContentTokenCount: import_zod5.z.number().nullish(),
+  thoughtsTokenCount: import_zod5.z.number().nullish(),
+  promptTokenCount: import_zod5.z.number().nullish(),
+  candidatesTokenCount: import_zod5.z.number().nullish(),
+  totalTokenCount: import_zod5.z.number().nullish()
+});
+var responseSchema = import_zod5.z.object({
+  candidates: import_zod5.z.array(
+    import_zod5.z.object({
+      content: contentSchema.nullish().or(import_zod5.z.object({}).strict()),
+      finishReason: import_zod5.z.string().nullish(),
+      safetyRatings: import_zod5.z.array(safetyRatingSchema).nullish(),
       groundingMetadata: groundingMetadataSchema.nullish()
     })
   ),
-  usageMetadata: import_zod2.z.object({
-    promptTokenCount: import_zod2.z.number().nullish(),
-    candidatesTokenCount: import_zod2.z.number().nullish(),
-    totalTokenCount: import_zod2.z.number().nullish()
-  }).nullish()
+  usageMetadata: usageSchema.nullish()
 });
-var chunkSchema = import_zod2.z.object({
-  candidates: import_zod2.z.array(
-    import_zod2.z.object({
+var chunkSchema = import_zod5.z.object({
+  candidates: import_zod5.z.array(
+    import_zod5.z.object({
       content: contentSchema.nullish(),
-      finishReason: import_zod2.z.string().nullish(),
-      safetyRatings: import_zod2.z.array(safetyRatingSchema).nullish(),
+      finishReason: import_zod5.z.string().nullish(),
+      safetyRatings: import_zod5.z.array(safetyRatingSchema).nullish(),
       groundingMetadata: groundingMetadataSchema.nullish()
     })
   ).nullish(),
-  usageMetadata: import_zod2.z.object({
-    promptTokenCount: import_zod2.z.number().nullish(),
-    candidatesTokenCount: import_zod2.z.number().nullish(),
-    totalTokenCount: import_zod2.z.number().nullish()
-  }).nullish()
-});
-var googleGenerativeAIProviderOptionsSchema = import_zod2.z.object({
-  responseModalities: import_zod2.z.array(import_zod2.z.enum(["TEXT", "IMAGE"])).nullish(),
-  thinkingConfig: import_zod2.z.object({
-    thinkingBudget: import_zod2.z.number().nullish()
-  }).nullish()
-});
-
-// src/google-generative-ai-embedding-model.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_zod3 = require("zod");
-var GoogleGenerativeAIEmbeddingModel = class {
-  constructor(modelId, settings, config) {
-    this.specificationVersion = "v1";
-    this.modelId = modelId;
-    this.settings = settings;
-    this.config = config;
-  }
-  get provider() {
-    return this.config.provider;
-  }
-  get maxEmbeddingsPerCall() {
-    return 2048;
-  }
-  get supportsParallelCalls() {
-    return true;
-  }
-  async doEmbed({
-    values,
-    headers,
-    abortSignal
-  }) {
-    if (values.length > this.maxEmbeddingsPerCall) {
-      throw new import_provider3.TooManyEmbeddingValuesForCallError({
-        provider: this.provider,
-        modelId: this.modelId,
-        maxEmbeddingsPerCall: this.maxEmbeddingsPerCall,
-        values
-      });
-    }
-    const mergedHeaders = (0, import_provider_utils4.combineHeaders)(
-      await (0, import_provider_utils4.resolve)(this.config.headers),
-      headers
-    );
-    const { responseHeaders, value: response } = await (0, import_provider_utils4.postJsonToApi)({
-      url: `${this.config.baseURL}/models/${this.modelId}:batchEmbedContents`,
-      headers: mergedHeaders,
-      body: {
-        requests: values.map((value) => ({
-          model: `models/${this.modelId}`,
-          content: { role: "user", parts: [{ text: value }] },
-          outputDimensionality: this.settings.outputDimensionality,
-          taskType: this.settings.taskType
-        }))
-      },
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
-        googleGenerativeAITextEmbeddingResponseSchema
-      ),
-      abortSignal,
-      fetch: this.config.fetch
-    });
-    return {
-      embeddings: response.embeddings.map((item) => item.values),
-      usage: void 0,
-      rawResponse: { headers: responseHeaders }
-    };
-  }
-};
-var googleGenerativeAITextEmbeddingResponseSchema = import_zod3.z.object({
-  embeddings: import_zod3.z.array(import_zod3.z.object({ values: import_zod3.z.array(import_zod3.z.number()) }))
+  usageMetadata: usageSchema.nullish()
 });
 
-// src/google-supported-file-url.ts
-function isSupportedFileUrl(url) {
-  return url.toString().startsWith("https://generativelanguage.googleapis.com/v1beta/files/");
-}
-
 // src/google-provider.ts
 function createGoogleGenerativeAI(options = {}) {
   var _a;
@@ -925,30 +1001,35 @@ function createGoogleGenerativeAI(options = {}) {
     }),
     ...options.headers
   });
-  const createChatModel = (modelId, settings = {}) => {
+  const createChatModel = (modelId) => {
     var _a2;
-    return new GoogleGenerativeAILanguageModel(modelId, settings, {
+    return new GoogleGenerativeAILanguageModel(modelId, {
       provider: "google.generative-ai",
       baseURL,
       headers: getHeaders,
       generateId: (_a2 = options.generateId) != null ? _a2 : import_provider_utils5.generateId,
-      isSupportedUrl: isSupportedFileUrl,
+      supportedUrls: () => ({
+        "*": [
+          // HTTP URLs:
+          /^https?:\/\/.*$/
+        ]
+      }),
       fetch: options.fetch
     });
   };
-  const createEmbeddingModel = (modelId, settings = {}) => new GoogleGenerativeAIEmbeddingModel(modelId, settings, {
+  const createEmbeddingModel = (modelId) => new GoogleGenerativeAIEmbeddingModel(modelId, {
     provider: "google.generative-ai",
     baseURL,
     headers: getHeaders,
     fetch: options.fetch
   });
-  const provider = function(modelId, settings) {
+  const provider = function(modelId) {
     if (new.target) {
       throw new Error(
         "The Google Generative AI model function cannot be called with the new keyword."
       );
     }
-    return createChatModel(modelId, settings);
+    return createChatModel(modelId);
   };
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
@@ -956,6 +1037,9 @@ function createGoogleGenerativeAI(options = {}) {
   provider.embedding = createEmbeddingModel;
   provider.textEmbedding = createEmbeddingModel;
   provider.textEmbeddingModel = createEmbeddingModel;
+  provider.imageModel = (modelId) => {
+    throw new import_provider4.NoSuchModelError({ modelId, modelType: "imageModel" });
+  };
   return provider;
 }
 var google = createGoogleGenerativeAI();