@ai-sdk/google 3.0.60 → 3.0.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "3.0.60",
+  "version": "3.0.61",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -44,8 +44,8 @@
     "tsup": "^8",
     "typescript": "5.8.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "1.0.3",
-    "@vercel/ai-tsconfig": "0.0.0"
+    "@vercel/ai-tsconfig": "0.0.0",
+    "@ai-sdk/test-server": "1.0.3"
   },
   "peerDependencies": {
     "zod": "^3.25.76 || ^4.1.8"

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

@@ -44,6 +44,7 @@ import {
   GoogleGenerativeAIProviderMetadata,
 } from './google-generative-ai-prompt';
 import { prepareTools } from './google-prepare-tools';
+import { GoogleJSONAccumulator, PartialArg } from './google-json-accumulator';
 import { mapGoogleGenerativeAIFinishReason } from './map-google-generative-ai-finish-reason';
 
 type GoogleGenerativeAIConfig = {
@@ -119,12 +120,14 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
     }
 
     // Add warning if Vertex rag tools are used with a non-Vertex Google provider
+    const isVertexProvider = this.config.provider.startsWith('google.vertex.');
+
     if (
       tools?.some(
         tool =>
           tool.type === 'provider' && tool.id === 'google.vertex_rag_store',
       ) &&
-      !this.config.provider.startsWith('google.vertex.')
+      !isVertexProvider
     ) {
       warnings.push({
         type: 'other',
@@ -135,6 +138,16 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
       });
     }
 
+    if (googleOptions?.streamFunctionCallArguments && !isVertexProvider) {
+      warnings.push({
+        type: 'other',
+        message:
+          "'streamFunctionCallArguments' is only supported on the Vertex AI API " +
+          'and will be ignored with the current Google provider ' +
+          `(${this.config.provider}). See https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/function-calling#streaming-fc`,
+      });
+    }
+
     const isGemmaModel = this.modelId.toLowerCase().startsWith('gemma-');
     const supportsFunctionResponseParts = this.modelId.startsWith('gemini-3');
 
@@ -157,6 +170,28 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
       modelId: this.modelId,
     });
 
+    const streamFunctionCallArguments = isVertexProvider
+      ? (googleOptions?.streamFunctionCallArguments ?? true)
+      : undefined;
+
+    const toolConfig =
+      googleToolConfig ||
+      streamFunctionCallArguments ||
+      googleOptions?.retrievalConfig
+        ? {
+            ...googleToolConfig,
+            ...(streamFunctionCallArguments && {
+              functionCallingConfig: {
+                ...googleToolConfig?.functionCallingConfig,
+                streamFunctionCallArguments: true as const,
+              },
+            }),
+            ...(googleOptions?.retrievalConfig && {
+              retrievalConfig: googleOptions.retrievalConfig,
+            }),
+          }
+        : undefined;
+
     return {
       args: {
         generationConfig: {
@@ -200,12 +235,7 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
         systemInstruction: isGemmaModel ? undefined : systemInstruction,
         safetySettings: googleOptions?.safetySettings,
         tools: googleTools,
-        toolConfig: googleOptions?.retrievalConfig
-          ? {
-              ...googleToolConfig,
-              retrievalConfig: googleOptions.retrievalConfig,
-            }
-          : googleToolConfig,
+        toolConfig,
         cachedContent: googleOptions?.cachedContent,
         labels: googleOptions?.labels,
         serviceTier: googleOptions?.serviceTier,
@@ -301,7 +331,11 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
             providerMetadata: thoughtSignatureMetadata,
           });
         }
-      } else if ('functionCall' in part) {
+      } else if (
+        'functionCall' in part &&
+        part.functionCall.name != null &&
+        part.functionCall.args != null
+      ) {
         content.push({
           type: 'tool-call' as const,
           toolCallId: this.config.generateId(),
@@ -478,6 +512,13 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
     // Associates a server-side tool response with its preceding call (tool combination).
     let lastServerToolCallId: string | undefined;
 
+    const activeStreamingToolCalls: Array<{
+      toolCallId: string;
+      toolName: string;
+      accumulator: GoogleJSONAccumulator;
+      providerMetadata?: SharedV3ProviderMetadata;
+    }> = [];
+
     return {
       stream: response.pipeThrough(
         new TransformStream<
@@ -735,40 +776,152 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
                 }
               }
 
-              const toolCallDeltas = getToolCallsFromParts({
-                parts: content.parts,
-                generateId,
-                providerOptionsName,
-              });
+              // Handle streaming and complete function calls
+              for (const part of parts) {
+                if (!('functionCall' in part)) continue;
+
+                const providerMeta = part.thoughtSignature
+                  ? {
+                      [providerOptionsName]: {
+                        thoughtSignature: part.thoughtSignature,
+                      },
+                    }
+                  : undefined;
+
+                const isStreamingChunk =
+                  part.functionCall.partialArgs != null ||
+                  (part.functionCall.name != null &&
+                    part.functionCall.willContinue === true);
+                const isTerminalChunk =
+                  part.functionCall.name == null &&
+                  part.functionCall.args == null &&
+                  part.functionCall.partialArgs == null &&
+                  part.functionCall.willContinue == null;
+                const isCompleteCall =
+                  part.functionCall.name != null &&
+                  part.functionCall.args != null &&
+                  part.functionCall.partialArgs == null;
+
+                if (isStreamingChunk) {
+                  if (
+                    part.functionCall.name != null &&
+                    part.functionCall.willContinue === true
+                  ) {
+                    const toolCallId = generateId();
+                    const accumulator = new GoogleJSONAccumulator();
+                    activeStreamingToolCalls.push({
+                      toolCallId,
+                      toolName: part.functionCall.name,
+                      accumulator,
+                      providerMetadata: providerMeta,
+                    });
+
+                    controller.enqueue({
+                      type: 'tool-input-start',
+                      id: toolCallId,
+                      toolName: part.functionCall.name,
+                      providerMetadata: providerMeta,
+                    });
+
+                    if (part.functionCall.partialArgs != null) {
+                      const { textDelta } = accumulator.processPartialArgs(
+                        part.functionCall.partialArgs as PartialArg[],
+                      );
+                      if (textDelta.length > 0) {
+                        controller.enqueue({
+                          type: 'tool-input-delta',
+                          id: toolCallId,
+                          delta: textDelta,
+                          providerMetadata: providerMeta,
+                        });
+                      }
+                    }
+                  } else if (
+                    part.functionCall.partialArgs != null &&
+                    activeStreamingToolCalls.length > 0
+                  ) {
+                    const active =
+                      activeStreamingToolCalls[
+                        activeStreamingToolCalls.length - 1
+                      ];
+                    const { textDelta } = active.accumulator.processPartialArgs(
+                      part.functionCall.partialArgs as PartialArg[],
+                    );
+                    if (textDelta.length > 0) {
+                      controller.enqueue({
+                        type: 'tool-input-delta',
+                        id: active.toolCallId,
+                        delta: textDelta,
+                        providerMetadata: providerMeta,
+                      });
+                    }
+                  }
+                } else if (
+                  isTerminalChunk &&
+                  activeStreamingToolCalls.length > 0
+                ) {
+                  const active = activeStreamingToolCalls.pop()!;
+                  const { finalJSON, closingDelta } =
+                    active.accumulator.finalize();
+
+                  if (closingDelta.length > 0) {
+                    controller.enqueue({
+                      type: 'tool-input-delta',
+                      id: active.toolCallId,
+                      delta: closingDelta,
+                      providerMetadata: active.providerMetadata,
+                    });
+                  }
+
+                  controller.enqueue({
+                    type: 'tool-input-end',
+                    id: active.toolCallId,
+                    providerMetadata: active.providerMetadata,
+                  });
+
+                  controller.enqueue({
+                    type: 'tool-call',
+                    toolCallId: active.toolCallId,
+                    toolName: active.toolName,
+                    input: finalJSON,
+                    providerMetadata: active.providerMetadata,
+                  });
+
+                  hasToolCalls = true;
+                } else if (isCompleteCall) {
+                  const toolCallId = generateId();
+                  const toolName = part.functionCall.name!;
+                  const args =
+                    typeof part.functionCall.args === 'string'
+                      ? part.functionCall.args
+                      : JSON.stringify(part.functionCall.args ?? {});
 
-              if (toolCallDeltas != null) {
-                for (const toolCall of toolCallDeltas) {
                   controller.enqueue({
                     type: 'tool-input-start',
-                    id: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    providerMetadata: toolCall.providerMetadata,
+                    id: toolCallId,
+                    toolName,
+                    providerMetadata: providerMeta,
                   });
 
                   controller.enqueue({
                     type: 'tool-input-delta',
-                    id: toolCall.toolCallId,
-                    delta: toolCall.args,
-                    providerMetadata: toolCall.providerMetadata,
+                    id: toolCallId,
+                    delta: args,
+                    providerMetadata: providerMeta,
                   });
 
                   controller.enqueue({
                     type: 'tool-input-end',
-                    id: toolCall.toolCallId,
-                    providerMetadata: toolCall.providerMetadata,
+                    id: toolCallId,
+                    providerMetadata: providerMeta,
                   });
 
                   controller.enqueue({
                     type: 'tool-call',
-                    toolCallId: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    input: toolCall.args,
-                    providerMetadata: toolCall.providerMetadata,
+                    toolCallId,
+                    toolName,
+                    input: args,
+                    providerMetadata: providerMeta,
                   });
 
                   hasToolCalls = true;
@@ -1040,6 +1193,15 @@ export const getGroundingMetadataSchema = () =>
       .nullish(),
   });
 
+const partialArgSchema = z.object({
+  jsonPath: z.string(),
+  stringValue: z.string().nullish(),
+  numberValue: z.number().nullish(),
+  boolValue: z.boolean().nullish(),
+  nullValue: z.unknown().nullish(),
+  willContinue: z.boolean().nullish(),
+});
+
 const getContentSchema = () =>
   z.object({
     parts: z
@@ -1048,8 +1210,10 @@ const getContentSchema = () =>
           // note: order matters since text can be fully empty
           z.object({
             functionCall: z.object({
-              name: z.string(),
-              args: z.unknown(),
+              name: z.string().nullish(),
+              args: z.unknown().nullish(),
+              partialArgs: z.array(partialArgSchema).nullish(),
+              willContinue: z.boolean().nullish(),
             }),
             thoughtSignature: z.string().nullish(),
           }),

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

@@ -189,6 +189,17 @@ export const googleLanguageModelOptions = lazySchema(() =>
         })
         .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).
+       *
+       * @default true
+       *
+       * 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.
        */

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

@@ -33,6 +33,7 @@ export function prepareTools({
         functionCallingConfig?: {
           mode: 'AUTO' | 'NONE' | 'ANY' | 'VALIDATED';
           allowedFunctionNames?: string[];
+          streamFunctionCallArguments?: boolean;
         };
         includeServerSideToolInvocations?: boolean;
       };