@ai-sdk/google 3.0.78 → 3.0.80

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "3.0.78",
+  "version": "3.0.80",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

package/src/convert-to-google-generative-ai-messages.ts

@@ -1,6 +1,7 @@
 import {
   UnsupportedFunctionalityError,
   type LanguageModelV3Prompt,
+  type SharedV3Warning,
 } from '@ai-sdk/provider';
 import { convertToBase64 } from '@ai-sdk/provider-utils';
 import type {
@@ -10,6 +11,48 @@ import type {
   GoogleGenerativeAIPrompt,
 } from './google-generative-ai-prompt';
 
+/**
+ * Sentinel value Google documents for replaying functionCall parts whose
+ * original thoughtSignature is not available to the client.
+ *
+ * Gemini 3 models reject `functionCall` parts that lack a `thoughtSignature`
+ * with HTTP 400 "Function call is missing a thought_signature in functionCall
+ * parts." Sending this sentinel string in place of the missing signature
+ * makes Gemini skip the validator and continue the turn.
+ *
+ * See https://ai.google.dev/gemini-api/docs/thought-signatures.
+ */
+export const SKIP_THOUGHT_SIGNATURE_VALIDATOR =
+  'skip_thought_signature_validator';
+
+type GoogleProviderOptions = {
+  thought?: unknown;
+  thoughtSignature?: unknown;
+  serverToolCallId?: unknown;
+  serverToolType?: unknown;
+};
+
+function getGoogleProviderOptions(
+  providerOptions: Record<string, GoogleProviderOptions> | undefined,
+  providerOptionsName: string,
+): GoogleProviderOptions | undefined {
+  const namespaces = [
+    providerOptionsName,
+    'google',
+    'googleVertex',
+    'vertex',
+  ].filter((namespace, index, allNamespaces) => {
+    return allNamespaces.indexOf(namespace) === index;
+  });
+
+  for (const namespace of namespaces) {
+    const options = providerOptions?.[namespace];
+    if (options != null) {
+      return options;
+    }
+  }
+}
+
 const dataUrlRegex = /^data:([^;,]+);base64,(.+)$/s;
 
 function parseBase64DataUrl(
@@ -168,17 +211,41 @@ export function convertToGoogleGenerativeAIMessages(
   prompt: LanguageModelV3Prompt,
   options?: {
     isGemmaModel?: boolean;
+    /**
+     * Whether the target model is in the Gemini 3 family. Gemini 3 enforces a
+     * `thoughtSignature` on every replayed `functionCall` part; when one is
+     * missing we inject the documented `skip_thought_signature_validator`
+     * sentinel and emit a warning via `onWarning` so the developer can find
+     * and fix the upstream serialization that lost the signature.
+     */
+    isGemini3Model?: boolean;
     providerOptionsName?: string;
     supportsFunctionResponseParts?: boolean;
+    /**
+     * Called once for the request when a Gemini 3 `functionCall` part is
+     * about to be sent without a `thoughtSignature` and the sentinel is
+     * injected.
+     */
+    onWarning?: (warning: SharedV3Warning) => void;
   },
 ): GoogleGenerativeAIPrompt {
   const systemInstructionParts: Array<{ text: string }> = [];
   const contents: Array<GoogleGenerativeAIContent> = [];
   let systemMessagesAllowed = true;
   const isGemmaModel = options?.isGemmaModel ?? false;
+  const isGemini3Model = options?.isGemini3Model ?? false;
   const providerOptionsName = options?.providerOptionsName ?? 'google';
   const supportsFunctionResponseParts =
     options?.supportsFunctionResponseParts ?? true;
+  const onWarning = options?.onWarning;
+
+  let sentinelInjected = false;
+  const missingSignatureToolNames: string[] = [];
+  const injectSkipSignature = (toolName: string) => {
+    missingSignatureToolNames.push(toolName);
+    sentinelInjected = true;
+    return SKIP_THOUGHT_SIGNATURE_VALIDATOR;
+  };
 
   for (const { role, content } of prompt) {
     switch (role) {
@@ -243,11 +310,10 @@ export function convertToGoogleGenerativeAIMessages(
           role: 'model',
           parts: content
             .map(part => {
-              const providerOpts =
-                part.providerOptions?.[providerOptionsName] ??
-                (providerOptionsName !== 'google'
-                  ? part.providerOptions?.google
-                  : part.providerOptions?.vertex);
+              const providerOpts = getGoogleProviderOptions(
+                part.providerOptions,
+                providerOptionsName,
+              );
               const thoughtSignature =
                 providerOpts?.thoughtSignature != null
                   ? String(providerOpts.thoughtSignature)
@@ -303,6 +369,16 @@ export function convertToGoogleGenerativeAIMessages(
                       ? String(providerOpts.serverToolType)
                       : undefined;
 
+                  // For Gemini 3, every replayed functionCall part must carry a
+                  // thoughtSignature or the API returns HTTP 400. If the upstream
+                  // serialization layer dropped the signature, inject the
+                  // documented sentinel so the request still succeeds.
+                  const effectiveThoughtSignature =
+                    thoughtSignature ??
+                    (isGemini3Model
+                      ? injectSkipSignature(part.toolName)
+                      : undefined);
+
                   if (serverToolCallId && serverToolType) {
                     return {
                       toolCall: {
@@ -313,7 +389,7 @@ export function convertToGoogleGenerativeAIMessages(
                             : part.input,
                         id: serverToolCallId,
                       },
-                      thoughtSignature,
+                      thoughtSignature: effectiveThoughtSignature,
                     };
                   }
 
@@ -325,7 +401,7 @@ export function convertToGoogleGenerativeAIMessages(
                       name: part.toolName,
                       args: part.input,
                     },
-                    thoughtSignature,
+                    thoughtSignature: effectiveThoughtSignature,
                   };
                 }
 
@@ -371,11 +447,10 @@ export function convertToGoogleGenerativeAIMessages(
             continue;
           }
 
-          const partProviderOpts =
-            part.providerOptions?.[providerOptionsName] ??
-            (providerOptionsName !== 'google'
-              ? part.providerOptions?.google
-              : part.providerOptions?.vertex);
+          const partProviderOpts = getGoogleProviderOptions(
+            part.providerOptions,
+            providerOptionsName,
+          );
           const serverToolCallId =
             partProviderOpts?.serverToolCallId != null
               ? String(partProviderOpts.serverToolCallId)
@@ -465,6 +540,23 @@ export function convertToGoogleGenerativeAIMessages(
     contents[0].parts.unshift({ text: systemText + '\n\n' });
   }
 
+  if (sentinelInjected && onWarning != null) {
+    const uniqueToolNames = Array.from(new Set(missingSignatureToolNames));
+    onWarning({
+      type: 'other',
+      message:
+        `Replayed ${missingSignatureToolNames.length} \`functionCall\` part(s) ` +
+        `for a Gemini 3 model without a \`thoughtSignature\` ` +
+        `(tools: ${uniqueToolNames.map(name => `\`${name}\``).join(', ')}). ` +
+        `Injected the documented \`skip_thought_signature_validator\` sentinel ` +
+        `to keep the request from failing with HTTP 400. ` +
+        `The likely cause is application code that drops ` +
+        '`providerOptions.google.thoughtSignature` when persisting or ' +
+        'serializing assistant tool-call messages. ' +
+        'See https://ai.google.dev/gemini-api/docs/thought-signatures.',
+    });
+  }
+
   return {
     systemInstruction:
       systemInstructionParts.length > 0 && !isGemmaModel

package/src/google-generative-ai-image-model.ts

@@ -14,8 +14,8 @@ import {
   resolve,
   zodSchema,
   type FetchFunction,
-  type Resolvable,
   type InferSchema,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 import { googleFailedResponseHandler } from './google-error';
@@ -25,6 +25,7 @@ import type {
 } from './google-generative-ai-image-settings';
 import { GoogleGenerativeAILanguageModel } from './google-generative-ai-language-model';
 import type { GoogleLanguageModelOptions } from './google-generative-ai-options';
+import { googleSearchToolArgsBaseSchema } from './tool/google-search';
 
 interface GoogleGenerativeAIImageModelConfig {
   provider: string;
@@ -139,7 +140,17 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
     }
 
     if (googleOptions) {
-      Object.assign(parameters, googleOptions);
+      const { googleSearch: imagenGoogleSearch, ...imagenOptions } =
+        googleOptions;
+      if (imagenGoogleSearch != null) {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'googleSearch',
+          details:
+            'Google Search grounding is only supported on Gemini image models.',
+        });
+      }
+      Object.assign(parameters, imagenOptions);
     }
 
     const body = {
@@ -257,6 +268,18 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
       { role: 'user', content: userContent },
     ];
 
+    // Parse image-model-specific provider options so we can map them onto
+    // the underlying language-model call. `googleSearch` is the dedicated
+    // escape hatch for grounding (generateImage has no `tools` parameter).
+    const googleImageOptions = await parseProviderOptions({
+      provider: 'google',
+      providerOptions,
+      schema: googleImageModelOptionsSchema,
+    });
+
+    const { googleSearch: _strippedGoogleSearch, ...passthroughGoogleOptions } =
+      providerOptions?.google ?? {};
+
     // Instantiate language model
     const languageModel = new GoogleGenerativeAILanguageModel(this.modelId, {
       provider: this.config.provider,
@@ -280,12 +303,23 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
                 >['aspectRatio'],
               }
             : undefined,
-          ...((providerOptions?.google as Omit<
+          ...(passthroughGoogleOptions as Omit<
             GoogleLanguageModelOptions,
             'responseModalities' | 'imageConfig'
-          >) ?? {}),
+          >),
         } satisfies GoogleLanguageModelOptions,
       },
+      tools:
+        googleImageOptions?.googleSearch != null
+          ? [
+              {
+                type: 'provider',
+                id: 'google.google_search',
+                name: 'google_search',
+                args: googleImageOptions.googleSearch,
+              },
+            ]
+          : undefined,
       headers,
       abortSignal,
     });
@@ -300,11 +334,17 @@ export class GoogleGenerativeAIImageModel implements ImageModelV3 {
       }
     }
 
+    const languageModelGoogleMetadata =
+      (result.providerMetadata?.google as
+        | Record<string, unknown>
+        | undefined) ?? {};
+
     return {
       images,
       warnings,
       providerMetadata: {
         google: {
+          ...languageModelGoogleMetadata,
           images: images.map(() => ({})),
         },
       },
@@ -350,6 +390,17 @@ const googleImageModelOptionsSchema = lazySchema(() =>
         .enum(['dont_allow', 'allow_adult', 'allow_all'])
         .nullish(),
       aspectRatio: z.enum(['1:1', '3:4', '4:3', '9:16', '16:9']).nullish(),
+
+      /**
+       * Enable Google Search grounding for Gemini image models. The value is
+       * forwarded as the args of the `google.tools.googleSearch` provider
+       * tool on the underlying language-model call. Pass `{}` for defaults.
+       *
+       * `generateImage` does not accept a `tools` parameter, so this is the
+       * dedicated escape hatch for grounding image generation the same way
+       * `generateText` does.
+       */
+      googleSearch: googleSearchToolArgsBaseSchema.optional(),
     }),
   ),
 );

package/src/google-generative-ai-language-model.ts

@@ -193,14 +193,17 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
       : googleOptions?.serviceTier;
 
     const isGemmaModel = this.modelId.toLowerCase().startsWith('gemma-');
-    const supportsFunctionResponseParts = this.modelId.startsWith('gemini-3');
+    const isGemini3Model = /^gemini-3[.-]/.test(this.modelId);
+    const supportsFunctionResponseParts = isGemini3Model;
 
     const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(
       prompt,
       {
         isGemmaModel,
+        isGemini3Model,
         providerOptionsName,
         supportsFunctionResponseParts,
+        onWarning: warning => warnings.push(warning),
       },
     );
 

package/src/tool/google-search.ts

@@ -9,7 +9,7 @@ import { z } from 'zod/v4';
 // https://ai.google.dev/api/generate-content#GroundingSupport
 // https://cloud.google.com/vertex-ai/generative-ai/docs/grounding/grounding-with-google-search
 
-const googleSearchToolArgsBaseSchema = z
+export const googleSearchToolArgsBaseSchema = z
   .object({
     searchTypes: z
       .object({