@ai-sdk/google 4.0.0-beta.8 → 4.0.0-beta.82

package/src/google-prepare-tools.ts

@@ -1,19 +1,21 @@
 import {
-  LanguageModelV3CallOptions,
-  SharedV3Warning,
   UnsupportedFunctionalityError,
+  type LanguageModelV4CallOptions,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import { convertJSONSchemaToOpenAPISchema } from './convert-json-schema-to-openapi-schema';
-import { GoogleGenerativeAIModelId } from './google-generative-ai-options';
+import type { GoogleModelId } from './google-language-model-options';
 
 export function prepareTools({
   tools,
   toolChoice,
   modelId,
+  isVertexProvider = false,
 }: {
-  tools: LanguageModelV3CallOptions['tools'];
-  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
-  modelId: GoogleGenerativeAIModelId;
+  tools: LanguageModelV4CallOptions['tools'];
+  toolChoice?: LanguageModelV4CallOptions['toolChoice'];
+  modelId: GoogleModelId;
+  isVertexProvider?: boolean;
 }): {
   tools:
     | Array<
@@ -30,30 +32,33 @@ export function prepareTools({
   toolConfig:
     | undefined
     | {
-        functionCallingConfig: {
+        functionCallingConfig?: {
           mode: 'AUTO' | 'NONE' | 'ANY' | 'VALIDATED';
           allowedFunctionNames?: string[];
+          streamFunctionCallArguments?: boolean;
         };
+        includeServerSideToolInvocations?: boolean;
       };
-  toolWarnings: SharedV3Warning[];
+  toolWarnings: SharedV4Warning[];
 } {
   // when the tools array is empty, change it to undefined to prevent errors:
   tools = tools?.length ? tools : undefined;
 
-  const toolWarnings: SharedV3Warning[] = [];
+  const toolWarnings: SharedV4Warning[] = [];
 
   const isLatest = (
     [
       'gemini-flash-latest',
       'gemini-flash-lite-latest',
       'gemini-pro-latest',
-    ] as const satisfies GoogleGenerativeAIModelId[]
+    ] as const satisfies GoogleModelId[]
   ).some(id => id === modelId);
   const isGemini2orNewer =
     modelId.includes('gemini-2') ||
     modelId.includes('gemini-3') ||
     modelId.includes('nano-banana') ||
     isLatest;
+  const isGemini3orNewer = modelId.includes('gemini-3');
   const supportsFileSearch =
     modelId.includes('gemini-2.5') || modelId.includes('gemini-3');
 
@@ -65,7 +70,7 @@ export function prepareTools({
   const hasFunctionTools = tools.some(tool => tool.type === 'function');
   const hasProviderTools = tools.some(tool => tool.type === 'provider');
 
-  if (hasFunctionTools && hasProviderTools) {
+  if (hasFunctionTools && hasProviderTools && !isGemini3orNewer) {
     toolWarnings.push({
       type: 'unsupported',
       feature: `combination of function and provider-defined tools`,
@@ -120,7 +125,7 @@ export function prepareTools({
               type: 'unsupported',
               feature: `provider-defined tool ${tool.id}`,
               details:
-                'The code execution tools is not supported with other Gemini models than Gemini 2.',
+                'The code execution tool is not supported with other Gemini models than Gemini 2.',
             });
           }
           break;
@@ -178,6 +183,61 @@ export function prepareTools({
       }
     });
 
+    if (hasFunctionTools && isGemini3orNewer && googleTools.length > 0) {
+      const functionDeclarations: Array<{
+        name: string;
+        description: string;
+        parameters: unknown;
+      }> = [];
+      for (const tool of tools) {
+        if (tool.type === 'function') {
+          functionDeclarations.push({
+            name: tool.name,
+            description: tool.description ?? '',
+            parameters: convertJSONSchemaToOpenAPISchema(tool.inputSchema),
+          });
+        }
+      }
+
+      const combinedToolConfig: {
+        functionCallingConfig: {
+          mode: 'VALIDATED' | 'ANY' | 'NONE';
+          allowedFunctionNames?: string[];
+        };
+        includeServerSideToolInvocations?: true;
+      } = {
+        functionCallingConfig: { mode: 'VALIDATED' },
+        ...(!isVertexProvider && {
+          includeServerSideToolInvocations: true,
+        }),
+      };
+
+      if (toolChoice != null) {
+        switch (toolChoice.type) {
+          case 'auto':
+            break;
+          case 'none':
+            combinedToolConfig.functionCallingConfig = { mode: 'NONE' };
+            break;
+          case 'required':
+            combinedToolConfig.functionCallingConfig = { mode: 'ANY' };
+            break;
+          case 'tool':
+            combinedToolConfig.functionCallingConfig = {
+              mode: 'ANY',
+              allowedFunctionNames: [toolChoice.toolName],
+            };
+            break;
+        }
+      }
+
+      return {
+        tools: [...googleTools, { functionDeclarations }],
+        toolConfig: combinedToolConfig,
+        toolWarnings,
+      };
+    }
+
     return {
       tools: googleTools.length > 0 ? googleTools : undefined,
       toolConfig: undefined,

package/src/google-prompt.ts

@@ -0,0 +1,86 @@
+import type {
+  GroundingMetadataSchema,
+  PromptFeedbackSchema,
+  SafetyRatingSchema,
+  UrlContextMetadataSchema,
+  UsageMetadataSchema,
+} from './google-language-model';
+
+export type GooglePrompt = {
+  systemInstruction?: GoogleSystemInstruction;
+  contents: Array<GoogleContent>;
+};
+
+export type GoogleSystemInstruction = {
+  parts: Array<{ text: string }>;
+};
+
+export type GoogleContent = {
+  role: 'user' | 'model';
+  parts: Array<GoogleContentPart>;
+};
+
+export type GoogleContentPart =
+  | { text: string; thought?: boolean; thoughtSignature?: string }
+  | {
+      inlineData: { mimeType: string; data: string };
+      thought?: boolean;
+      thoughtSignature?: string;
+    }
+  | {
+      functionCall: { id?: string; name: string; args: unknown };
+      thoughtSignature?: string;
+    }
+  | {
+      functionResponse: {
+        id?: string;
+        name: string;
+        response: unknown;
+        parts?: Array<GoogleFunctionResponsePart>;
+      };
+    }
+  | {
+      fileData: { mimeType: string; fileUri: string };
+      thought?: boolean;
+      thoughtSignature?: string;
+    }
+  | {
+      toolCall: {
+        toolType: string;
+        args?: unknown;
+        id: string;
+      };
+      thoughtSignature?: string;
+    }
+  | {
+      toolResponse: {
+        toolType: string;
+        response?: unknown;
+        id: string;
+      };
+      thoughtSignature?: string;
+    };
+
+export type GoogleFunctionResponsePart = {
+  inlineData: { mimeType: string; data: string };
+};
+
+export type GoogleGroundingMetadata = GroundingMetadataSchema;
+
+export type GoogleUrlContextMetadata = UrlContextMetadataSchema;
+
+export type GoogleSafetyRating = SafetyRatingSchema;
+
+export type GooglePromptFeedback = PromptFeedbackSchema;
+
+export type GoogleUsageMetadata = UsageMetadataSchema;
+
+export interface GoogleProviderMetadata {
+  promptFeedback: GooglePromptFeedback | null;
+  groundingMetadata: GoogleGroundingMetadata | null;
+  urlContextMetadata: GoogleUrlContextMetadata | null;
+  safetyRatings: GoogleSafetyRating[] | null;
+  usageMetadata: GoogleUsageMetadata | null;
+  finishMessage: string | null;
+  serviceTier: string | null;
+}

package/src/google-provider.ts

@@ -1,90 +1,129 @@
-import {
-  EmbeddingModelV3,
-  Experimental_VideoModelV3,
-  ImageModelV3,
-  LanguageModelV3,
-  ProviderV3,
+import type {
+  EmbeddingModelV4,
+  Experimental_VideoModelV4,
+  FilesV4,
+  ImageModelV4,
+  LanguageModelV4,
+  ProviderV4,
+  Experimental_RealtimeFactoryV4 as RealtimeFactoryV4,
+  Experimental_RealtimeFactoryV4GetTokenOptions as RealtimeFactoryV4GetTokenOptions,
+  SpeechModelV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
   generateId,
   loadApiKey,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { VERSION } from './version';
-import { GoogleGenerativeAIEmbeddingModel } from './google-generative-ai-embedding-model';
-import { GoogleGenerativeAIEmbeddingModelId } from './google-generative-ai-embedding-options';
-import { GoogleGenerativeAILanguageModel } from './google-generative-ai-language-model';
-import { GoogleGenerativeAIModelId } from './google-generative-ai-options';
+import { GoogleEmbeddingModel } from './google-embedding-model';
+import type { GoogleEmbeddingModelId } from './google-embedding-model-options';
+import { GoogleLanguageModel } from './google-language-model';
+import type { GoogleModelId } from './google-language-model-options';
 import { googleTools } from './google-tools';
 
+import type {
+  GoogleImageSettings,
+  GoogleImageModelId,
+} from './google-image-settings';
+import { GoogleImageModel } from './google-image-model';
+import { GoogleFiles } from './google-files';
+import { GoogleVideoModel } from './google-video-model';
+import type { GoogleVideoModelId } from './google-video-settings';
+import { GoogleSpeechModel } from './google-speech-model';
+import type { GoogleSpeechModelId } from './google-speech-model-options';
 import {
-  GoogleGenerativeAIImageSettings,
-  GoogleGenerativeAIImageModelId,
-} from './google-generative-ai-image-settings';
-import { GoogleGenerativeAIImageModel } from './google-generative-ai-image-model';
-import { GoogleGenerativeAIVideoModel } from './google-generative-ai-video-model';
-import { GoogleGenerativeAIVideoModelId } from './google-generative-ai-video-settings';
+  GoogleInteractionsLanguageModel,
+  type GoogleInteractionsModelInput,
+} from './interactions/google-interactions-language-model';
+import type { GoogleInteractionsModelId } from './interactions/google-interactions-language-model-options';
+import type { GoogleInteractionsAgentName } from './interactions/google-interactions-agent';
+import { GoogleRealtimeModel } from './realtime/google-realtime-model';
 
-export interface GoogleGenerativeAIProvider extends ProviderV3 {
-  (modelId: GoogleGenerativeAIModelId): LanguageModelV3;
+export interface GoogleProvider extends ProviderV4 {
+  (modelId: GoogleModelId): LanguageModelV4;
 
-  languageModel(modelId: GoogleGenerativeAIModelId): LanguageModelV3;
+  languageModel(modelId: GoogleModelId): LanguageModelV4;
 
-  chat(modelId: GoogleGenerativeAIModelId): LanguageModelV3;
+  chat(modelId: GoogleModelId): LanguageModelV4;
 
   /**
    * Creates a model for image generation.
    */
   image(
-    modelId: GoogleGenerativeAIImageModelId,
-    settings?: GoogleGenerativeAIImageSettings,
-  ): ImageModelV3;
+    modelId: GoogleImageModelId,
+    settings?: GoogleImageSettings,
+  ): ImageModelV4;
 
   /**
    * @deprecated Use `chat()` instead.
    */
-  generativeAI(modelId: GoogleGenerativeAIModelId): LanguageModelV3;
+  generativeAI(modelId: GoogleModelId): LanguageModelV4;
 
   /**
    * Creates a model for text embeddings.
    */
-  embedding(modelId: GoogleGenerativeAIEmbeddingModelId): EmbeddingModelV3;
+  embedding(modelId: GoogleEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * Creates a model for text embeddings.
    */
-  embeddingModel(modelId: GoogleGenerativeAIEmbeddingModelId): EmbeddingModelV3;
+  embeddingModel(modelId: GoogleEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * @deprecated Use `embedding` instead.
    */
-  textEmbedding(modelId: GoogleGenerativeAIEmbeddingModelId): EmbeddingModelV3;
+  textEmbedding(modelId: GoogleEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * @deprecated Use `embeddingModel` instead.
    */
-  textEmbeddingModel(
-    modelId: GoogleGenerativeAIEmbeddingModelId,
-  ): EmbeddingModelV3;
+  textEmbeddingModel(modelId: GoogleEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * Creates a model for video generation.
    */
-  video(modelId: GoogleGenerativeAIVideoModelId): Experimental_VideoModelV3;
+  video(modelId: GoogleVideoModelId): Experimental_VideoModelV4;
 
   /**
    * Creates a model for video generation.
    */
-  videoModel(
-    modelId: GoogleGenerativeAIVideoModelId,
-  ): Experimental_VideoModelV3;
+  videoModel(modelId: GoogleVideoModelId): Experimental_VideoModelV4;
+
+  /**
+   * Creates a model for speech generation (text-to-speech).
+   */
+  speech(modelId: GoogleSpeechModelId): SpeechModelV4;
+
+  /**
+   * Creates a model for speech generation (text-to-speech).
+   */
+  speechModel(modelId: GoogleSpeechModelId): SpeechModelV4;
+
+  files(): FilesV4;
+
+  /**
+   * Creates a language model targeting the Gemini Interactions API
+   * (`POST /v1beta/interactions`). Pass:
+   *   - a model ID (string),
+   *   - `{ agent: <name> }` to use a known Gemini agent preset, or
+   *   - `{ managedAgent: <name> }` to use a user-defined agent created via
+   *     the `/v1beta/agents` endpoint.
+   */
+  interactions(
+    modelIdOrAgent:
+      | GoogleInteractionsModelId
+      | { agent: GoogleInteractionsAgentName }
+      | { managedAgent: string },
+  ): LanguageModelV4;
+
+  experimental_realtime: RealtimeFactoryV4;
 
   tools: typeof googleTools;
 }
 
-export interface GoogleGenerativeAIProviderSettings {
+export interface GoogleProviderSettings {
   /**
    * Use a different URL prefix for API calls, e.g. to use proxy servers.
    * The default prefix is `https://generativelanguage.googleapis.com/v1beta`.
@@ -121,11 +160,11 @@ export interface GoogleGenerativeAIProviderSettings {
 }
 
 /**
- * Create a Google Generative AI provider instance.
+ * Create a Google provider instance.
  */
-export function createGoogleGenerativeAI(
-  options: GoogleGenerativeAIProviderSettings = {},
-): GoogleGenerativeAIProvider {
+export function createGoogle(
+  options: GoogleProviderSettings = {},
+): GoogleProvider {
   const baseURL =
     withoutTrailingSlash(options.baseURL) ??
     'https://generativelanguage.googleapis.com/v1beta';
@@ -145,8 +184,8 @@ export function createGoogleGenerativeAI(
       `ai-sdk/google/${VERSION}`,
     );
 
-  const createChatModel = (modelId: GoogleGenerativeAIModelId) =>
-    new GoogleGenerativeAILanguageModel(modelId, {
+  const createChatModel = (modelId: GoogleModelId) =>
+    new GoogleLanguageModel(modelId, {
       provider: providerName,
       baseURL,
       headers: getHeaders,
@@ -166,8 +205,8 @@ export function createGoogleGenerativeAI(
       fetch: options.fetch,
     });
 
-  const createEmbeddingModel = (modelId: GoogleGenerativeAIEmbeddingModelId) =>
-    new GoogleGenerativeAIEmbeddingModel(modelId, {
+  const createEmbeddingModel = (modelId: GoogleEmbeddingModelId) =>
+    new GoogleEmbeddingModel(modelId, {
       provider: providerName,
       baseURL,
       headers: getHeaders,
@@ -175,18 +214,26 @@ export function createGoogleGenerativeAI(
     });
 
   const createImageModel = (
-    modelId: GoogleGenerativeAIImageModelId,
-    settings: GoogleGenerativeAIImageSettings = {},
+    modelId: GoogleImageModelId,
+    settings: GoogleImageSettings = {},
   ) =>
-    new GoogleGenerativeAIImageModel(modelId, settings, {
+    new GoogleImageModel(modelId, settings, {
+      provider: providerName,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const createFiles = () =>
+    new GoogleFiles({
       provider: providerName,
       baseURL,
       headers: getHeaders,
       fetch: options.fetch,
     });
 
-  const createVideoModel = (modelId: GoogleGenerativeAIVideoModelId) =>
-    new GoogleGenerativeAIVideoModel(modelId, {
+  const createVideoModel = (modelId: GoogleVideoModelId) =>
+    new GoogleVideoModel(modelId, {
       provider: providerName,
       baseURL,
       headers: getHeaders,
@@ -194,7 +241,59 @@ export function createGoogleGenerativeAI(
       generateId: options.generateId ?? generateId,
     });
 
-  const provider = function (modelId: GoogleGenerativeAIModelId) {
+  const createRealtimeModel = (modelId: string) =>
+    new GoogleRealtimeModel(modelId, {
+      provider: `${providerName}.realtime`,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const createSpeechModel = (modelId: GoogleSpeechModelId) =>
+    new GoogleSpeechModel(modelId, {
+      provider: `${providerName}.speech`,
+      baseURL,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const experimentalRealtimeFactory = Object.assign(
+    (modelId: string) => createRealtimeModel(modelId),
+    {
+      getToken: async (tokenOptions: RealtimeFactoryV4GetTokenOptions) => {
+        const model = createRealtimeModel(tokenOptions.model);
+        const secret = await model.doCreateClientSecret({
+          sessionConfig: tokenOptions.sessionConfig,
+          expiresAfterSeconds: tokenOptions.expiresAfterSeconds,
+        });
+
+        return {
+          token: secret.token,
+          url: secret.url,
+          expiresAt: secret.expiresAt,
+        };
+      },
+    },
+  ) as RealtimeFactoryV4;
+
+  const createInteractionsModel = (
+    modelIdOrAgent:
+      | GoogleInteractionsModelId
+      | { agent: GoogleInteractionsAgentName }
+      | { managedAgent: string },
+  ) =>
+    new GoogleInteractionsLanguageModel(
+      modelIdOrAgent as GoogleInteractionsModelInput,
+      {
+        provider: `${providerName}.interactions`,
+        baseURL,
+        headers: getHeaders,
+        generateId: options.generateId ?? generateId,
+        fetch: options.fetch,
+      },
+    );
+
+  const provider = function (modelId: GoogleModelId) {
     if (new.target) {
       throw new Error(
         'The Google Generative AI model function cannot be called with the new keyword.',
@@ -204,7 +303,7 @@ export function createGoogleGenerativeAI(
     return createChatModel(modelId);
   };
 
-  provider.specificationVersion = 'v3' as const;
+  provider.specificationVersion = 'v4' as const;
   provider.languageModel = createChatModel;
   provider.chat = createChatModel;
   provider.generativeAI = createChatModel;
@@ -216,12 +315,17 @@ export function createGoogleGenerativeAI(
   provider.imageModel = createImageModel;
   provider.video = createVideoModel;
   provider.videoModel = createVideoModel;
+  provider.experimental_realtime = experimentalRealtimeFactory;
+  provider.files = createFiles;
+  provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
+  provider.interactions = createInteractionsModel;
   provider.tools = googleTools;
 
-  return provider as GoogleGenerativeAIProvider;
+  return provider as GoogleProvider;
 }
 
 /**
  * Default Google Generative AI provider instance.
  */
-export const google = createGoogleGenerativeAI();
+export const google = createGoogle();

package/src/google-speech-api.ts

@@ -0,0 +1,36 @@
+import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+/**
+ * Response schema for the Gemini `:generateContent` endpoint when called with
+ * `responseModalities: ['AUDIO']`. The generated audio is returned as base64
+ * encoded raw PCM in the first inline-data part.
+ */
+export const googleSpeechResponseSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      candidates: z
+        .array(
+          z.object({
+            content: z
+              .object({
+                parts: z
+                  .array(
+                    z.object({
+                      inlineData: z
+                        .object({
+                          mimeType: z.string().nullish(),
+                          data: z.string().nullish(),
+                        })
+                        .nullish(),
+                    }),
+                  )
+                  .nullish(),
+              })
+              .nullish(),
+          }),
+        )
+        .nullish(),
+    }),
+  ),
+);

package/src/google-speech-model-options.ts

@@ -0,0 +1,48 @@
+import {
+  lazySchema,
+  zodSchema,
+  type InferSchema,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+
+export type GoogleSpeechModelId =
+  | 'gemini-2.5-flash-preview-tts'
+  | 'gemini-2.5-pro-preview-tts'
+  | 'gemini-3.1-flash-tts-preview'
+  | (string & {});
+
+const prebuiltVoiceConfigSchema = z.object({
+  voiceName: z.string(),
+});
+
+const voiceConfigSchema = z.object({
+  prebuiltVoiceConfig: prebuiltVoiceConfigSchema,
+});
+
+export const googleSpeechProviderOptionsSchema = lazySchema(() =>
+  zodSchema(
+    z.object({
+      /**
+       * Multi-speaker configuration for dialogue audio. When provided, this
+       * overrides the top-level `voice`. The Gemini TTS API supports up to two
+       * speakers; each speaker name must match a name used in the input text.
+       *
+       * https://ai.google.dev/gemini-api/docs/speech-generation#multi-speaker
+       */
+      multiSpeakerVoiceConfig: z
+        .object({
+          speakerVoiceConfigs: z.array(
+            z.object({
+              speaker: z.string(),
+              voiceConfig: voiceConfigSchema,
+            }),
+          ),
+        })
+        .optional(),
+    }),
+  ),
+);
+
+export type GoogleSpeechModelOptions = InferSchema<
+  typeof googleSpeechProviderOptionsSchema
+>;