@ai-sdk/google 3.0.37 → 3.0.39

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

@@ -564,11 +564,36 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
                     });
                   }
                 } else if ('inlineData' in part) {
+                  // End any active text or reasoning block before starting file output.
+                  // Relevant for multimodal output models.
+                  if (currentTextBlockId !== null) {
+                    controller.enqueue({
+                      type: 'text-end',
+                      id: currentTextBlockId,
+                    });
+                    currentTextBlockId = null;
+                  }
+                  if (currentReasoningBlockId !== null) {
+                    controller.enqueue({
+                      type: 'reasoning-end',
+                      id: currentReasoningBlockId,
+                    });
+                    currentReasoningBlockId = null;
+                  }
+
                   // Process file parts inline to preserve order with text
+                  const thoughtSignatureMetadata = part.thoughtSignature
+                    ? {
+                        [providerOptionsName]: {
+                          thoughtSignature: part.thoughtSignature,
+                        },
+                      }
+                    : undefined;
                   controller.enqueue({
                     type: 'file',
                     mediaType: part.inlineData.mimeType,
                     data: part.inlineData.data,
+                    providerMetadata: thoughtSignatureMetadata,
                   });
                 }
               }
@@ -729,6 +754,17 @@ function extractSources({
         url: chunk.web.uri,
         title: chunk.web.title ?? undefined,
       });
+    } else if (chunk.image != null) {
+      // Handle image chunks as image sources
+      sources.push({
+        type: 'source',
+        sourceType: 'url',
+        id: generateId(),
+        // Google requires attribution to the source URI, not the actual image URI.
+        // TODO: add another type in v7 to allow both the image and source URL to be included separately
+        url: chunk.image.sourceUri,
+        title: chunk.image.title ?? undefined,
+      });
     } else if (chunk.retrievedContext != null) {
       // Handle retrievedContext chunks from RAG operations
       const uri = chunk.retrievedContext.uri;
@@ -808,6 +844,7 @@ function extractSources({
 export const getGroundingMetadataSchema = () =>
   z.object({
     webSearchQueries: z.array(z.string()).nullish(),
+    imageSearchQueries: z.array(z.string()).nullish(),
     retrievalQueries: z.array(z.string()).nullish(),
     searchEntryPoint: z.object({ renderedContent: z.string() }).nullish(),
     groundingChunks: z
@@ -816,6 +853,14 @@ export const getGroundingMetadataSchema = () =>
           web: z
             .object({ uri: z.string(), title: z.string().nullish() })
             .nullish(),
+          image: z
+            .object({
+              sourceUri: z.string(),
+              imageUri: z.string(),
+              title: z.string().nullish(),
+              domain: z.string().nullish(),
+            })
+            .nullish(),
           retrievedContext: z
             .object({
               uri: z.string().nullish(),

package/src/google-prepare-tools.ts

@@ -50,9 +50,10 @@ export function prepareTools({
     ] as const satisfies GoogleGenerativeAIModelId[]
   ).some(id => id === modelId);
   const isGemini2orNewer =
-    modelId.includes('gemini-2') || modelId.includes('gemini-3') || isLatest;
-  const supportsDynamicRetrieval =
-    modelId.includes('gemini-1.5-flash') && !modelId.includes('-8b');
+    modelId.includes('gemini-2') ||
+    modelId.includes('gemini-3') ||
+    modelId.includes('nano-banana') ||
+    isLatest;
   const supportsFileSearch =
     modelId.includes('gemini-2.5') || modelId.includes('gemini-3');
 
@@ -79,24 +80,13 @@ export function prepareTools({
       switch (tool.id) {
         case 'google.google_search':
           if (isGemini2orNewer) {
-            googleTools.push({ googleSearch: {} });
-          } else if (supportsDynamicRetrieval) {
-            // For non-Gemini-2 models that don't support dynamic retrieval, use basic googleSearchRetrieval
-            googleTools.push({
-              googleSearchRetrieval: {
-                dynamicRetrievalConfig: {
-                  mode: tool.args.mode as
-                    | 'MODE_DYNAMIC'
-                    | 'MODE_UNSPECIFIED'
-                    | undefined,
-                  dynamicThreshold: tool.args.dynamicThreshold as
-                    | number
-                    | undefined,
-                },
-              },
-            });
+            googleTools.push({ googleSearch: { ...tool.args } });
           } else {
-            googleTools.push({ googleSearchRetrieval: {} });
+            toolWarnings.push({
+              type: 'unsupported',
+              feature: `provider-defined tool ${tool.id}`,
+              details: 'Google Search requires Gemini 2.0 or newer.',
+            });
           }
           break;
         case 'google.enterprise_web_search':

package/src/tool/google-search.ts

@@ -9,32 +9,35 @@ 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
 
-export const googleSearch = createProviderToolFactory<
-  {},
-  {
-    /**
-     * The mode of the predictor to be used in dynamic retrieval. The following modes are supported:
-     *  - MODE_DYNAMIC: Run retrieval only when system decides it is necessary
-     *  - MODE_UNSPECIFIED: Always trigger retrieval
-     * @default MODE_UNSPECIFIED
-     */
-    mode?: 'MODE_DYNAMIC' | 'MODE_UNSPECIFIED';
+const googleSearchToolArgsBaseSchema = z
+  .object({
+    searchTypes: z
+      .object({
+        webSearch: z.object({}).optional(),
+        imageSearch: z.object({}).optional(),
+      })
+      .optional(),
+
+    timeRangeFilter: z
+      .object({
+        startTime: z.string(),
+        endTime: z.string(),
+      })
+      .optional(),
+  })
+  .passthrough();
+
+export type GoogleSearchToolArgs = z.infer<
+  typeof googleSearchToolArgsBaseSchema
+>;
 
-    /**
-     * The threshold to be used in dynamic retrieval (if not set, a system default value is used).
-     */
-    dynamicThreshold?: number;
-  }
->({
-  id: 'google.google_search',
-  inputSchema: lazySchema(() =>
-    zodSchema(
-      z.object({
-        mode: z
-          .enum(['MODE_DYNAMIC', 'MODE_UNSPECIFIED'])
-          .default('MODE_UNSPECIFIED'),
-        dynamicThreshold: z.number().default(1),
-      }),
-    ),
-  ),
-});
+const googleSearchToolArgsSchema = lazySchema(() =>
+  zodSchema(googleSearchToolArgsBaseSchema),
+);
+
+export const googleSearch = createProviderToolFactory<{}, GoogleSearchToolArgs>(
+  {
+    id: 'google.google_search',
+    inputSchema: googleSearchToolArgsSchema,
+  },
+);