@ai-sdk/google 1.2.19 → 2.0.0-alpha.10

package/{internal/dist → dist/internal}/index.js

@@ -28,11 +28,11 @@ module.exports = __toCommonJS(internal_exports);
 
 // src/google-generative-ai-language-model.ts
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
+var import_zod3 = 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") {
@@ -131,7 +131,6 @@ function isEmptyObjectSchema(jsonSchema) {
 var import_provider = require("@ai-sdk/provider");
 var import_provider_utils = require("@ai-sdk/provider-utils");
 function convertToGoogleGenerativeAIMessages(prompt) {
-  var _a, _b;
   const systemInstructionParts = [];
   const contents = [];
   let systemMessagesAllowed = true;
@@ -155,33 +154,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_utils.convertToBase64)(part.data)
                   }
                 }
               );
@@ -202,7 +186,7 @@ function convertToGoogleGenerativeAIMessages(prompt) {
                 return part.text.length === 0 ? void 0 : { text: part.text };
               }
               case "file": {
-                if (part.mimeType !== "image/png") {
+                if (part.mediaType !== "image/png") {
                   throw new import_provider.UnsupportedFunctionalityError({
                     functionality: "Only PNG images are supported in assistant messages"
                   });
@@ -214,8 +198,8 @@ function convertToGoogleGenerativeAIMessages(prompt) {
                 }
                 return {
                   inlineData: {
-                    mimeType: part.mimeType,
-                    data: part.data
+                    mimeType: part.mediaType,
+                    data: (0, import_provider_utils.convertToBase64)(part.data)
                   }
                 };
               }
@@ -276,18 +260,111 @@ var googleFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResp
   errorToMessage: (data) => data.error.message
 });
 
+// src/google-generative-ai-options.ts
+var import_zod2 = require("zod");
+var dynamicRetrievalConfig = import_zod2.z.object({
+  /**
+   * The mode of the predictor to be used in dynamic retrieval.
+   */
+  mode: import_zod2.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_zod2.z.number().optional()
+});
+var googleGenerativeAIProviderOptions = import_zod2.z.object({
+  responseModalities: import_zod2.z.array(import_zod2.z.enum(["TEXT", "IMAGE"])).optional(),
+  thinkingConfig: import_zod2.z.object({
+    thinkingBudget: import_zod2.z.number().optional(),
+    includeThoughts: import_zod2.z.boolean().optional()
+  }).optional(),
+  /**
+  Optional.
+  The name of the cached content used as context to serve the prediction.
+  Format: cachedContents/{cachedContent}
+     */
+  cachedContent: import_zod2.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_zod2.z.boolean().optional(),
+  /**
+  Optional. A list of unique safety settings for blocking unsafe content.
+   */
+  safetySettings: import_zod2.z.array(
+    import_zod2.z.object({
+      category: import_zod2.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_zod2.z.enum([
+        "HARM_BLOCK_THRESHOLD_UNSPECIFIED",
+        "BLOCK_LOW_AND_ABOVE",
+        "BLOCK_MEDIUM_AND_ABOVE",
+        "BLOCK_ONLY_HIGH",
+        "BLOCK_NONE",
+        "OFF"
+      ])
+    })
+  ).optional(),
+  threshold: import_zod2.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_zod2.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_zod2.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;
+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
@@ -303,12 +380,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 },
@@ -350,7 +426,7 @@ function prepareTools(mode, useSearchGrounding, dynamicRetrievalConfig, modelId)
     default: {
       const _exhaustiveCheck = type;
       throw new import_provider2.UnsupportedFunctionalityError({
-        functionality: `Unsupported tool choice type: ${_exhaustiveCheck}`
+        functionality: `tool choice type: ${_exhaustiveCheck}`
       });
     }
   }
@@ -385,25 +461,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,
@@ -412,15 +484,16 @@ var GoogleGenerativeAILanguageModel = class {
     stopSequences,
     responseFormat,
     seed,
-    providerMetadata
+    tools,
+    toolChoice,
+    providerOptions
   }) {
     var _a, _b, _c;
-    const type = mode.type;
     const warnings = [];
-    const googleOptions = (0, import_provider_utils3.parseProviderOptions)({
+    const googleOptions = await (0, import_provider_utils3.parseProviderOptions)({
       provider: "google",
-      providerOptions: providerMetadata,
-      schema: googleGenerativeAIProviderOptionsSchema
+      providerOptions,
+      schema: googleGenerativeAIProviderOptions
     });
     if (((_a = googleOptions == null ? void 0 : googleOptions.thinkingConfig) == null ? void 0 : _a.includeThoughts) === true && !this.config.provider.startsWith("google.vertex.")) {
       warnings.push({
@@ -428,102 +501,55 @@ var GoogleGenerativeAILanguageModel = class {
         message: `The 'includeThoughts' option 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}).`
       });
     }
-    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,
-          (_b = this.settings.useSearchGrounding) != null ? _b : 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: (_c = mode.tool.description) != null ? _c : "",
-                  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: (_b = googleOptions == null ? void 0 : googleOptions.useSearchGrounding) != null ? _b : 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
+          ((_c = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _c : 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)(
@@ -545,45 +571,66 @@ var GoogleGenerativeAILanguageModel = class {
       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,
-      // Use candidateParts
-      generateId: this.config.generateId
-    });
+    const content = [];
+    const parts = candidate.content == null || typeof candidate.content !== "object" || !("parts" in candidate.content) ? [] : (_a = candidate.content.parts) != null ? _a : [];
     const usageMetadata = response.usageMetadata;
+    for (const part of parts) {
+      if ("text" in part && part.text != null && part.text.length > 0) {
+        if (part.thought === true) {
+          content.push({ type: "reasoning", text: part.text });
+        } else {
+          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);
+    }
     return {
-      text: getTextFromParts(parts),
-      reasoning: getReasoningDetailsFromParts(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) {
@@ -604,11 +651,11 @@ var GoogleGenerativeAILanguageModel = class {
       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 generateId = this.config.generateId;
@@ -616,8 +663,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, _j;
             if (!chunk.success) {
               controller.enqueue({ type: "error", error: chunk.error });
               return;
@@ -625,33 +675,26 @@ 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;
             }
             const content = candidate.content;
             if (content != null) {
-              const deltaText = getTextFromParts(content.parts);
-              if (deltaText != null) {
-                controller.enqueue({
-                  type: "text-delta",
-                  textDelta: deltaText
-                });
-              }
-              const reasoningDeltaText = getReasoningDetailsFromParts(
-                content.parts
-              );
-              if (reasoningDeltaText != null) {
-                for (const part of reasoningDeltaText) {
-                  controller.enqueue({
-                    type: "reasoning",
-                    textDelta: part.text
-                  });
+              const parts = (_g = content.parts) != null ? _g : [];
+              for (const part of parts) {
+                if ("text" in part && part.text != null && part.text.length > 0) {
+                  if (part.thought === true) {
+                    controller.enqueue({ type: "reasoning", text: part.text });
+                  } else {
+                    controller.enqueue({ type: "text", text: part.text });
+                  }
                 }
               }
               const inlineDataParts = getInlineDataParts(content.parts);
@@ -659,7 +702,7 @@ var GoogleGenerativeAILanguageModel = class {
                 for (const part of inlineDataParts) {
                   controller.enqueue({
                     type: "file",
-                    mimeType: part.inlineData.mimeType,
+                    mediaType: part.inlineData.mimeType,
                     data: part.inlineData.data
                   });
                 }
@@ -693,17 +736,17 @@ var GoogleGenerativeAILanguageModel = class {
                 finishReason: candidate.finishReason,
                 hasToolCalls
               });
-              const sources = (_d = extractSources({
+              const sources = (_h = extractSources({
                 groundingMetadata: candidate.groundingMetadata,
                 generateId
-              })) != null ? _d : [];
+              })) != null ? _h : [];
               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: (_i = candidate.groundingMetadata) != null ? _i : null,
+                  safetyRatings: (_j = candidate.safetyRatings) != null ? _j : null
                 }
               };
             }
@@ -718,9 +761,7 @@ var GoogleGenerativeAILanguageModel = class {
           }
         })
       ),
-      rawCall: { rawPrompt, rawSettings },
-      rawResponse: { headers: responseHeaders },
-      warnings,
+      response: { headers: responseHeaders },
       request: { body }
     };
   }
@@ -733,24 +774,13 @@ function getToolCallsFromParts({
     (part) => "functionCall" in part
   );
   return functionCallParts == null || functionCallParts.length === 0 ? void 0 : functionCallParts.map((part) => ({
+    type: "tool-call",
     toolCallType: "function",
     toolCallId: generateId(),
     toolName: part.functionCall.name,
     args: JSON.stringify(part.functionCall.args)
   }));
 }
-function getTextFromParts(parts) {
-  const textParts = parts == null ? void 0 : parts.filter(
-    (part) => "text" in part && part.thought !== true
-  );
-  return textParts == null || textParts.length === 0 ? void 0 : textParts.map((part) => part.text).join("");
-}
-function getReasoningDetailsFromParts(parts) {
-  const reasoningParts = parts == null ? void 0 : parts.filter(
-    (part) => "text" in part && part.thought === true && part.text != null
-  );
-  return reasoningParts == null || reasoningParts.length === 0 ? void 0 : reasoningParts.map((part) => ({ type: "text", text: part.text }));
-}
 function getInlineDataParts(parts) {
   return parts == null ? void 0 : parts.filter(
     (part) => "inlineData" in part
@@ -764,109 +794,102 @@ 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: generateId(),
     url: chunk.web.uri,
     title: chunk.web.title
   }));
 }
-var contentSchema = import_zod2.z.object({
-  parts: import_zod2.z.array(
-    import_zod2.z.union([
+var contentSchema = import_zod3.z.object({
+  parts: import_zod3.z.array(
+    import_zod3.z.union([
       // note: order matters since text can be fully empty
-      import_zod2.z.object({
-        functionCall: import_zod2.z.object({
-          name: import_zod2.z.string(),
-          args: import_zod2.z.unknown()
+      import_zod3.z.object({
+        functionCall: import_zod3.z.object({
+          name: import_zod3.z.string(),
+          args: import_zod3.z.unknown()
         })
       }),
-      import_zod2.z.object({
-        inlineData: import_zod2.z.object({
-          mimeType: import_zod2.z.string(),
-          data: import_zod2.z.string()
+      import_zod3.z.object({
+        inlineData: import_zod3.z.object({
+          mimeType: import_zod3.z.string(),
+          data: import_zod3.z.string()
         })
       }),
-      import_zod2.z.object({
-        text: import_zod2.z.string().nullish(),
-        thought: import_zod2.z.boolean().nullish()
+      import_zod3.z.object({
+        text: import_zod3.z.string().nullish(),
+        thought: import_zod3.z.boolean().nullish()
       })
     ])
   ).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_zod3.z.object({
+  web: import_zod3.z.object({ uri: import_zod3.z.string(), title: import_zod3.z.string() }).nullish(),
+  retrievedContext: import_zod3.z.object({ uri: import_zod3.z.string(), title: import_zod3.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_zod3.z.object({
+  webSearchQueries: import_zod3.z.array(import_zod3.z.string()).nullish(),
+  retrievalQueries: import_zod3.z.array(import_zod3.z.string()).nullish(),
+  searchEntryPoint: import_zod3.z.object({ renderedContent: import_zod3.z.string() }).nullish(),
+  groundingChunks: import_zod3.z.array(groundingChunkSchema).nullish(),
+  groundingSupports: import_zod3.z.array(
+    import_zod3.z.object({
+      segment: import_zod3.z.object({
+        startIndex: import_zod3.z.number().nullish(),
+        endIndex: import_zod3.z.number().nullish(),
+        text: import_zod3.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_zod3.z.string().nullish(),
+      groundingChunkIndices: import_zod3.z.array(import_zod3.z.number()).nullish(),
+      supportChunkIndices: import_zod3.z.array(import_zod3.z.number()).nullish(),
+      confidenceScores: import_zod3.z.array(import_zod3.z.number()).nullish(),
+      confidenceScore: import_zod3.z.array(import_zod3.z.number()).nullish()
     })
   ).nullish(),
-  retrievalMetadata: import_zod2.z.union([
-    import_zod2.z.object({
-      webDynamicRetrievalScore: import_zod2.z.number()
+  retrievalMetadata: import_zod3.z.union([
+    import_zod3.z.object({
+      webDynamicRetrievalScore: import_zod3.z.number()
     }),
-    import_zod2.z.object({})
+    import_zod3.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_zod3.z.object({
+  category: import_zod3.z.string().nullish(),
+  probability: import_zod3.z.string().nullish(),
+  probabilityScore: import_zod3.z.number().nullish(),
+  severity: import_zod3.z.string().nullish(),
+  severityScore: import_zod3.z.number().nullish(),
+  blocked: import_zod3.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_zod3.z.object({
+  cachedContentTokenCount: import_zod3.z.number().nullish(),
+  thoughtsTokenCount: import_zod3.z.number().nullish(),
+  promptTokenCount: import_zod3.z.number().nullish(),
+  candidatesTokenCount: import_zod3.z.number().nullish(),
+  totalTokenCount: import_zod3.z.number().nullish()
+});
+var responseSchema = import_zod3.z.object({
+  candidates: import_zod3.z.array(
+    import_zod3.z.object({
+      content: contentSchema.nullish().or(import_zod3.z.object({}).strict()),
+      finishReason: import_zod3.z.string().nullish(),
+      safetyRatings: import_zod3.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_zod3.z.object({
+  candidates: import_zod3.z.array(
+    import_zod3.z.object({
       content: contentSchema.nullish(),
-      finishReason: import_zod2.z.string().nullish(),
-      safetyRatings: import_zod2.z.array(safetyRatingSchema).nullish(),
+      finishReason: import_zod3.z.string().nullish(),
+      safetyRatings: import_zod3.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(),
-    includeThoughts: import_zod2.z.boolean().nullish()
-  }).nullish()
+  usageMetadata: usageSchema.nullish()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {