@ai-sdk/google 4.0.0-beta.4 → 4.0.0-beta.40

package/src/google-generative-ai-options.ts

@@ -7,13 +7,11 @@ export type GoogleGenerativeAIModelId =
   | 'gemini-2.0-flash'
   | 'gemini-2.0-flash-001'
   | 'gemini-2.0-flash-lite'
-  | 'gemini-2.0-flash-exp-image-generation'
   | 'gemini-2.0-flash-lite-001'
   | 'gemini-2.5-pro'
   | 'gemini-2.5-flash'
   | 'gemini-2.5-flash-image'
   | 'gemini-2.5-flash-lite'
-  | 'gemini-2.5-flash-lite-preview-09-2025'
   | 'gemini-2.5-flash-preview-tts'
   | 'gemini-2.5-pro-preview-tts'
   | 'gemini-2.5-flash-native-audio-latest'
@@ -27,6 +25,7 @@ export type GoogleGenerativeAIModelId =
   | 'gemini-3.1-pro-preview-customtools'
   | 'gemini-3.1-flash-image-preview'
   | 'gemini-3.1-flash-lite-preview'
+  | 'gemini-3.1-flash-tts-preview'
   // latest version
   // https://ai.google.dev/gemini-api/docs/models#latest
   | 'gemini-pro-latest'
@@ -189,6 +188,23 @@ export const googleLanguageModelOptions = lazySchema(() =>
             .optional(),
         })
         .optional(),
+
+      /**
+       * Optional. When set to true, function call arguments will be streamed
+       * incrementally via partialArgs in streaming responses. Only supported
+       * on the Vertex AI API (not the Gemini API) and only for Gemini 3+
+       * models.
+       *
+       * @default false
+       *
+       * https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/function-calling#streaming-fc
+       */
+      streamFunctionCallArguments: z.boolean().optional(),
+
+      /**
+       * Optional. The service tier to use for the request.
+       */
+      serviceTier: z.enum(['standard', 'flex', 'priority']).optional(),
     }),
   ),
 );
@@ -196,3 +212,10 @@ export const googleLanguageModelOptions = lazySchema(() =>
 export type GoogleLanguageModelOptions = InferSchema<
   typeof googleLanguageModelOptions
 >;
+
+// Vertex API requires another service tier format.
+export const VertexServiceTierMap = {
+  standard: 'SERVICE_TIER_STANDARD',
+  flex: 'SERVICE_TIER_FLEX',
+  priority: 'SERVICE_TIER_PRIORITY',
+} as const;

package/src/google-generative-ai-prompt.ts

@@ -1,8 +1,10 @@
 import {
   GroundingMetadataSchema,
+  PromptFeedbackSchema,
   UrlContextMetadataSchema,
+  type SafetyRatingSchema,
+  UsageMetadataSchema,
 } from './google-generative-ai-language-model';
-import { type SafetyRatingSchema } from './google-generative-ai-language-model';
 
 export type GoogleGenerativeAIPrompt = {
   systemInstruction?: GoogleGenerativeAISystemInstruction;
@@ -20,10 +22,44 @@ export type GoogleGenerativeAIContent = {
 
 export type GoogleGenerativeAIContentPart =
   | { text: string; thought?: boolean; thoughtSignature?: string }
-  | { inlineData: { mimeType: string; data: string } }
+  | {
+      inlineData: { mimeType: string; data: string };
+      thought?: boolean;
+      thoughtSignature?: string;
+    }
   | { functionCall: { name: string; args: unknown }; thoughtSignature?: string }
-  | { functionResponse: { name: string; response: unknown } }
-  | { fileData: { mimeType: string; fileUri: string } };
+  | {
+      functionResponse: {
+        name: string;
+        response: unknown;
+        parts?: Array<GoogleGenerativeAIFunctionResponsePart>;
+      };
+    }
+  | {
+      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 GoogleGenerativeAIFunctionResponsePart = {
+  inlineData: { mimeType: string; data: string };
+};
 
 export type GoogleGenerativeAIGroundingMetadata = GroundingMetadataSchema;
 
@@ -31,8 +67,16 @@ export type GoogleGenerativeAIUrlContextMetadata = UrlContextMetadataSchema;
 
 export type GoogleGenerativeAISafetyRating = SafetyRatingSchema;
 
+export type GoogleGenerativeAIPromptFeedback = PromptFeedbackSchema;
+
+export type GoogleGenerativeAIUsageMetadata = UsageMetadataSchema;
+
 export interface GoogleGenerativeAIProviderMetadata {
+  promptFeedback: GoogleGenerativeAIPromptFeedback | null;
   groundingMetadata: GoogleGenerativeAIGroundingMetadata | null;
   urlContextMetadata: GoogleGenerativeAIUrlContextMetadata | null;
   safetyRatings: GoogleGenerativeAISafetyRating[] | null;
+  usageMetadata: GoogleGenerativeAIUsageMetadata | null;
+  finishMessage: string | null;
+  serviceTier: string | null;
 }

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

@@ -1,7 +1,7 @@
 import {
   AISDKError,
-  type Experimental_VideoModelV3,
-  type SharedV3Warning,
+  type Experimental_VideoModelV4,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -50,8 +50,8 @@ interface GoogleGenerativeAIVideoModelConfig {
   };
 }
 
-export class GoogleGenerativeAIVideoModel implements Experimental_VideoModelV3 {
-  readonly specificationVersion = 'v3';
+export class GoogleGenerativeAIVideoModel implements Experimental_VideoModelV4 {
+  readonly specificationVersion = 'v4';
 
   get provider(): string {
     return this.config.provider;
@@ -68,10 +68,10 @@ export class GoogleGenerativeAIVideoModel implements Experimental_VideoModelV3 {
   ) {}
 
   async doGenerate(
-    options: Parameters<Experimental_VideoModelV3['doGenerate']>[0],
-  ): Promise<Awaited<ReturnType<Experimental_VideoModelV3['doGenerate']>>> {
+    options: Parameters<Experimental_VideoModelV4['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<Experimental_VideoModelV4['doGenerate']>>> {
     const currentDate = this.config._internal?.currentDate?.() ?? new Date();
-    const warnings: SharedV3Warning[] = [];
+    const warnings: SharedV4Warning[] = [];
 
     const googleOptions = (await parseProviderOptions({
       provider: 'google',

package/src/google-generative-ai-video-settings.ts

@@ -2,6 +2,7 @@ export type GoogleGenerativeAIVideoModelId =
   | 'veo-3.1-fast-generate-preview'
   | 'veo-3.1-generate-preview'
   | 'veo-3.1-generate'
+  | 'veo-3.1-lite-generate-preview'
   | 'veo-3.0-generate-001'
   | 'veo-3.0-fast-generate-001'
   | 'veo-2.0-generate-001'

package/src/google-json-accumulator.ts

@@ -0,0 +1,336 @@
+export type PartialArg = {
+  jsonPath: string;
+  stringValue?: string | null;
+  numberValue?: number | null;
+  boolValue?: boolean | null;
+  nullValue?: unknown;
+  willContinue?: boolean | null;
+};
+
+type PathSegment = string | number;
+
+type StackEntry = {
+  segment: PathSegment;
+  isArray: boolean;
+  childCount: number;
+};
+
+/**
+ * Incrementally builds a JSON object from Google's streaming `partialArgs`
+ * chunks emitted during tool-call function calling. Tracks both the structured
+ * object and a running JSON text representation so callers can emit text deltas
+ * that, when concatenated, form valid nested JSON matching JSON.stringify output.
+ *
+ * Input: [{jsonPath:"$.location",stringValue:"Boston"}]
+ * Output: '{"location":"Boston"', then finalize() → closingDelta='}'
+ */
+export class GoogleJSONAccumulator {
+  private accumulatedArgs: Record<string, unknown> = {};
+  private jsonText = '';
+
+  /**
+   * Stack representing the currently "open" containers in the JSON output.
+   * Entry 0 is always the root `{` object once the first value is written.
+   */
+  private pathStack: StackEntry[] = [];
+
+  /**
+   * Whether a string value is currently "open" (willContinue was true),
+   * meaning the closing quote has not yet been emitted.
+   */
+  private stringOpen = false;
+
+  /**
+   * Input: [{jsonPath:"$.brightness",numberValue:50}]
+   * Output: { currentJSON:{brightness:50}, textDelta:'{"brightness":50' }
+   */
+  processPartialArgs(partialArgs: PartialArg[]): {
+    currentJSON: Record<string, unknown>;
+    textDelta: string;
+  } {
+    let delta = '';
+
+    for (const arg of partialArgs) {
+      const rawPath = arg.jsonPath.replace(/^\$\./, '');
+      if (!rawPath) continue;
+
+      const segments = parsePath(rawPath);
+
+      const existingValue = getNestedValue(this.accumulatedArgs, segments);
+      const isStringContinuation =
+        arg.stringValue != null && existingValue !== undefined;
+
+      if (isStringContinuation) {
+        const escaped = JSON.stringify(arg.stringValue).slice(1, -1);
+        setNestedValue(
+          this.accumulatedArgs,
+          segments,
+          (existingValue as string) + arg.stringValue,
+        );
+        delta += escaped;
+        continue;
+      }
+
+      const resolved = resolvePartialArgValue(arg);
+      if (resolved == null) continue;
+
+      setNestedValue(this.accumulatedArgs, segments, resolved.value);
+      delta += this.emitNavigationTo(segments, arg, resolved.json);
+    }
+
+    this.jsonText += delta;
+
+    return {
+      currentJSON: this.accumulatedArgs,
+      textDelta: delta,
+    };
+  }
+
+  /**
+   * Input: jsonText='{"brightness":50', accumulatedArgs={brightness:50}
+   * Output: { finalJSON:'{"brightness":50}', closingDelta:'}' }
+   */
+  finalize(): { finalJSON: string; closingDelta: string } {
+    const finalArgs = JSON.stringify(this.accumulatedArgs);
+    const closingDelta = finalArgs.slice(this.jsonText.length);
+    return { finalJSON: finalArgs, closingDelta };
+  }
+
+  /**
+   * Input: pathStack=[] (first call) or pathStack=[root,...] (subsequent calls)
+   * Output: '{' (first call) or '' (subsequent calls)
+   */
+  private ensureRoot(): string {
+    if (this.pathStack.length === 0) {
+      this.pathStack.push({ segment: '', isArray: false, childCount: 0 });
+      return '{';
+    }
+    return '';
+  }
+
+  /**
+   * Emits the JSON text fragment needed to navigate from the current open
+   * path to the new leaf at `targetSegments`, then writes the value.
+   *
+   * Input: targetSegments=["recipe","name"], arg={jsonPath:"$.recipe.name",stringValue:"Lasagna"}, valueJson='"Lasagna"'
+   * Output: '{"recipe":{"name":"Lasagna"'
+   */
+  private emitNavigationTo(
+    targetSegments: PathSegment[],
+    arg: PartialArg,
+    valueJson: string,
+  ): string {
+    let fragment = '';
+
+    if (this.stringOpen) {
+      fragment += '"';
+      this.stringOpen = false;
+    }
+
+    fragment += this.ensureRoot();
+
+    const targetContainerSegments = targetSegments.slice(0, -1);
+    const leafSegment = targetSegments[targetSegments.length - 1];
+
+    const commonDepth = this.findCommonStackDepth(targetContainerSegments);
+
+    fragment += this.closeDownTo(commonDepth);
+    fragment += this.openDownTo(targetContainerSegments, leafSegment);
+    fragment += this.emitLeaf(leafSegment, arg, valueJson);
+
+    return fragment;
+  }
+
+  /**
+   * Returns the stack depth to preserve when navigating to a new target
+   * container path. Always >= 1 (the root is never popped).
+   *
+   * Input: stack=[root,"recipe","ingredients",0], target=["recipe","ingredients",1]
+   * Output: 3 (keep root+"recipe"+"ingredients")
+   */
+  private findCommonStackDepth(targetContainer: PathSegment[]): number {
+    const maxDepth = Math.min(
+      this.pathStack.length - 1,
+      targetContainer.length,
+    );
+    let common = 0;
+    for (let i = 0; i < maxDepth; i++) {
+      if (this.pathStack[i + 1].segment === targetContainer[i]) {
+        common++;
+      } else {
+        break;
+      }
+    }
+    return common + 1;
+  }
+
+  /**
+   * Closes containers from the current stack depth back down to `targetDepth`.
+   *
+   * Input: this.pathStack=[root,"recipe","ingredients",0], targetDepth=3
+   * Output: '}'
+   */
+  private closeDownTo(targetDepth: number): string {
+    let fragment = '';
+    while (this.pathStack.length > targetDepth) {
+      const entry = this.pathStack.pop()!;
+      fragment += entry.isArray ? ']' : '}';
+    }
+    return fragment;
+  }
+
+  /**
+   * Opens containers from the current stack depth down to the full target
+   * container path, emitting opening `{`, `[`, keys, and commas as needed.
+   * `leafSegment` is used to determine if the innermost container is an array.
+   *
+   * Input: this.pathStack=[root], targetContainer=["recipe","ingredients"], leafSegment=0
+   * Output: '"recipe":{"ingredients":['
+   */
+  private openDownTo(
+    targetContainer: PathSegment[],
+    leafSegment: PathSegment,
+  ): string {
+    let fragment = '';
+
+    const startIdx = this.pathStack.length - 1;
+
+    for (let i = startIdx; i < targetContainer.length; i++) {
+      const seg = targetContainer[i];
+      const parentEntry = this.pathStack[this.pathStack.length - 1];
+
+      if (parentEntry.childCount > 0) {
+        fragment += ',';
+      }
+      parentEntry.childCount++;
+
+      if (typeof seg === 'string') {
+        fragment += `${JSON.stringify(seg)}:`;
+      }
+
+      const childSeg =
+        i + 1 < targetContainer.length ? targetContainer[i + 1] : leafSegment;
+      const isArray = typeof childSeg === 'number';
+
+      fragment += isArray ? '[' : '{';
+
+      this.pathStack.push({ segment: seg, isArray, childCount: 0 });
+    }
+
+    return fragment;
+  }
+
+  /**
+   * Emits the comma, key, and value for a leaf entry in the current container.
+   *
+   * Input: leafSegment="name", arg={stringValue:"Lasagna"}, valueJson='"Lasagna"'
+   * Output: '"name":"Lasagna"' (or ',"name":"Lasagna"' if container.childCount > 0)
+   */
+  private emitLeaf(
+    leafSegment: PathSegment,
+    arg: PartialArg,
+    valueJson: string,
+  ): string {
+    let fragment = '';
+    const container = this.pathStack[this.pathStack.length - 1];
+
+    if (container.childCount > 0) {
+      fragment += ',';
+    }
+    container.childCount++;
+
+    if (typeof leafSegment === 'string') {
+      fragment += `${JSON.stringify(leafSegment)}:`;
+    }
+
+    if (arg.stringValue != null && arg.willContinue) {
+      fragment += valueJson.slice(0, -1);
+      this.stringOpen = true;
+    } else {
+      fragment += valueJson;
+    }
+
+    return fragment;
+  }
+}
+
+/**
+ * Splits a dotted/bracketed JSON path like `recipe.ingredients[0].name` into segments.
+ *
+ * Input: "recipe.ingredients[0].name"
+ * Output: ["recipe", "ingredients", 0, "name"]
+ */
+function parsePath(rawPath: string): Array<string | number> {
+  const segments: Array<string | number> = [];
+  for (const part of rawPath.split('.')) {
+    const bracketIdx = part.indexOf('[');
+    if (bracketIdx === -1) {
+      segments.push(part);
+    } else {
+      if (bracketIdx > 0) segments.push(part.slice(0, bracketIdx));
+      for (const m of part.matchAll(/\[(\d+)\]/g)) {
+        segments.push(parseInt(m[1], 10));
+      }
+    }
+  }
+  return segments;
+}
+
+/**
+ * Traverses a nested object along the given path segments and returns the leaf value.
+ *
+ * Input: ({recipe:{name:"Lasagna"}}, ["recipe","name"])
+ * Output: "Lasagna"
+ */
+function getNestedValue(
+  obj: Record<string, unknown>,
+  segments: Array<string | number>,
+): unknown {
+  let current: unknown = obj;
+  for (const seg of segments) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = (current as Record<string | number, unknown>)[seg];
+  }
+  return current;
+}
+
+/**
+ * Sets a value at a nested path, creating intermediate objects or arrays as needed.
+ *
+ * Input: obj={}, segments=["recipe","ingredients",0,"name"], value="Noodles"
+ * Output: {recipe:{ingredients:[{name:"Noodles"}]}}
+ */
+function setNestedValue(
+  obj: Record<string, unknown>,
+  segments: Array<string | number>,
+  value: unknown,
+): void {
+  let current: Record<string | number, unknown> = obj;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const seg = segments[i];
+    const nextSeg = segments[i + 1];
+    if (current[seg] == null) {
+      current[seg] = typeof nextSeg === 'number' ? [] : {};
+    }
+    current = current[seg] as Record<string | number, unknown>;
+  }
+  current[segments[segments.length - 1]] = value;
+}
+
+/**
+ * Extracts the first non-null typed value from a partial arg and returns it with its JSON representation.
+ *
+ * Input: arg={stringValue:"Boston"} or arg={numberValue:50}
+ * Output: {value:"Boston", json:'"Boston"'} or {value:50, json:'50'}
+ */
+function resolvePartialArgValue(arg: {
+  stringValue?: string | null;
+  numberValue?: number | null;
+  boolValue?: boolean | null;
+  nullValue?: unknown;
+}): { value: unknown; json: string } | undefined {
+  const value = arg.stringValue ?? arg.numberValue ?? arg.boolValue;
+  if (value != null) return { value, json: JSON.stringify(value) };
+  if ('nullValue' in arg) return { value: null, json: 'null' };
+  return undefined;
+}

package/src/google-prepare-tools.ts

@@ -1,6 +1,6 @@
 import {
-  LanguageModelV3CallOptions,
-  SharedV3Warning,
+  LanguageModelV4CallOptions,
+  SharedV4Warning,
   UnsupportedFunctionalityError,
 } from '@ai-sdk/provider';
 import { convertJSONSchemaToOpenAPISchema } from './convert-json-schema-to-openapi-schema';
@@ -11,8 +11,8 @@ export function prepareTools({
   toolChoice,
   modelId,
 }: {
-  tools: LanguageModelV3CallOptions['tools'];
-  toolChoice?: LanguageModelV3CallOptions['toolChoice'];
+  tools: LanguageModelV4CallOptions['tools'];
+  toolChoice?: LanguageModelV4CallOptions['toolChoice'];
   modelId: GoogleGenerativeAIModelId;
 }): {
   tools:
@@ -30,17 +30,19 @@ 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 = (
     [
@@ -54,6 +56,7 @@ export function prepareTools({
     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 +68,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 +123,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 +181,59 @@ 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' },
+        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,