@ai-sdk/google 3.0.60 → 3.0.62

package/dist/index.mjs

@@ -7,7 +7,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "3.0.60" : "0.0.0-test";
+var VERSION = true ? "3.0.62" : "0.0.0-test";
 
 // src/google-generative-ai-embedding-model.ts
 import {
@@ -825,6 +825,17 @@ var googleLanguageModelOptions = lazySchema4(
           longitude: z4.number()
         }).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: z4.boolean().optional(),
       /**
        * Optional. The service tier to use for the request.
        */
@@ -1085,6 +1096,229 @@ function prepareTools({
   }
 }
 
+// src/google-json-accumulator.ts
+var GoogleJSONAccumulator = class {
+  constructor() {
+    this.accumulatedArgs = {};
+    this.jsonText = "";
+    /**
+     * Stack representing the currently "open" containers in the JSON output.
+     * Entry 0 is always the root `{` object once the first value is written.
+     */
+    this.pathStack = [];
+    /**
+     * Whether a string value is currently "open" (willContinue was true),
+     * meaning the closing quote has not yet been emitted.
+     */
+    this.stringOpen = false;
+  }
+  /**
+   * Input: [{jsonPath:"$.brightness",numberValue:50}]
+   * Output: { currentJSON:{brightness:50}, textDelta:'{"brightness":50' }
+   */
+  processPartialArgs(partialArgs) {
+    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 !== void 0;
+      if (isStringContinuation) {
+        const escaped = JSON.stringify(arg.stringValue).slice(1, -1);
+        setNestedValue(
+          this.accumulatedArgs,
+          segments,
+          existingValue + 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() {
+    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)
+   */
+  ensureRoot() {
+    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"'
+   */
+  emitNavigationTo(targetSegments, arg, valueJson) {
+    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")
+   */
+  findCommonStackDepth(targetContainer) {
+    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: '}'
+   */
+  closeDownTo(targetDepth) {
+    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":['
+   */
+  openDownTo(targetContainer, leafSegment) {
+    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)
+   */
+  emitLeaf(leafSegment, arg, valueJson) {
+    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;
+  }
+};
+function parsePath(rawPath) {
+  const segments = [];
+  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;
+}
+function getNestedValue(obj, segments) {
+  let current = obj;
+  for (const seg of segments) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[seg];
+  }
+  return current;
+}
+function setNestedValue(obj, segments, value) {
+  let current = 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];
+  }
+  current[segments[segments.length - 1]] = value;
+}
+function resolvePartialArgValue(arg) {
+  var _a, _b;
+  const value = (_b = (_a = arg.stringValue) != null ? _a : arg.numberValue) != null ? _b : arg.boolValue;
+  if (value != null) return { value, json: JSON.stringify(value) };
+  if ("nullValue" in arg) return { value: null, json: "null" };
+  return void 0;
+}
+
 // src/map-google-generative-ai-finish-reason.ts
 function mapGoogleGenerativeAIFinishReason({
   finishReason,
@@ -1141,8 +1375,8 @@ var GoogleGenerativeAILanguageModel = class {
     tools,
     toolChoice,
     providerOptions
-  }) {
-    var _a;
+  }, { isStreaming = false } = {}) {
+    var _a, _b;
     const warnings = [];
     const providerOptionsName = this.config.provider.includes("vertex") ? "vertex" : "google";
     let googleOptions = await parseProviderOptions2({
@@ -1157,14 +1391,21 @@ var GoogleGenerativeAILanguageModel = class {
         schema: googleLanguageModelOptions
       });
     }
+    const isVertexProvider = this.config.provider.startsWith("google.vertex.");
     if ((tools == null ? void 0 : tools.some(
       (tool) => tool.type === "provider" && tool.id === "google.vertex_rag_store"
-    )) && !this.config.provider.startsWith("google.vertex.")) {
+    )) && !isVertexProvider) {
       warnings.push({
         type: "other",
         message: `The 'vertex_rag_store' tool is only supported with the Google Vertex provider and might not be supported or could behave unexpectedly with the current Google provider (${this.config.provider}).`
       });
     }
+    if ((googleOptions == null ? void 0 : 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");
     const { contents, systemInstruction } = convertToGoogleGenerativeAIMessages(
@@ -1184,6 +1425,19 @@ var GoogleGenerativeAILanguageModel = class {
       toolChoice,
       modelId: this.modelId
     });
+    const streamFunctionCallArguments = isStreaming && isVertexProvider ? (_a = googleOptions == null ? void 0 : googleOptions.streamFunctionCallArguments) != null ? _a : false : void 0;
+    const toolConfig = googleToolConfig || streamFunctionCallArguments || (googleOptions == null ? void 0 : googleOptions.retrievalConfig) ? {
+      ...googleToolConfig,
+      ...streamFunctionCallArguments && {
+        functionCallingConfig: {
+          ...googleToolConfig == null ? void 0 : googleToolConfig.functionCallingConfig,
+          streamFunctionCallArguments: true
+        }
+      },
+      ...(googleOptions == null ? void 0 : googleOptions.retrievalConfig) && {
+        retrievalConfig: googleOptions.retrievalConfig
+      }
+    } : void 0;
     return {
       args: {
         generationConfig: {
@@ -1201,7 +1455,7 @@ var GoogleGenerativeAILanguageModel = class {
           responseSchema: (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && // Google GenAI does not support all OpenAPI Schema features,
           // so this is needed as an escape hatch:
           // TODO convert into provider option
-          ((_a = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _a : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
+          ((_b = googleOptions == null ? void 0 : googleOptions.structuredOutputs) != null ? _b : true) ? convertJSONSchemaToOpenAPISchema(responseFormat.schema) : void 0,
           ...(googleOptions == null ? void 0 : googleOptions.audioTimestamp) && {
             audioTimestamp: googleOptions.audioTimestamp
           },
@@ -1219,10 +1473,7 @@ var GoogleGenerativeAILanguageModel = class {
         systemInstruction: isGemmaModel ? void 0 : systemInstruction,
         safetySettings: googleOptions == null ? void 0 : googleOptions.safetySettings,
         tools: googleTools2,
-        toolConfig: (googleOptions == null ? void 0 : googleOptions.retrievalConfig) ? {
-          ...googleToolConfig,
-          retrievalConfig: googleOptions.retrievalConfig
-        } : googleToolConfig,
+        toolConfig,
         cachedContent: googleOptions == null ? void 0 : googleOptions.cachedContent,
         labels: googleOptions == null ? void 0 : googleOptions.labels,
         serviceTier: googleOptions == null ? void 0 : googleOptions.serviceTier
@@ -1300,7 +1551,7 @@ var GoogleGenerativeAILanguageModel = class {
             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",
           toolCallId: this.config.generateId(),
@@ -1413,7 +1664,10 @@ var GoogleGenerativeAILanguageModel = class {
     };
   }
   async doStream(options) {
-    const { args, warnings, providerOptionsName } = await this.getArgs(options);
+    const { args, warnings, providerOptionsName } = await this.getArgs(
+      options,
+      { isStreaming: true }
+    );
     const headers = combineHeaders2(
       await resolve2(this.config.headers),
       options.headers
@@ -1446,6 +1700,7 @@ var GoogleGenerativeAILanguageModel = class {
     const emittedSourceUrls = /* @__PURE__ */ new Set();
     let lastCodeExecutionToolCallId;
     let lastServerToolCallId;
+    const activeStreamingToolCalls = [];
     return {
       stream: response.pipeThrough(
         new TransformStream({
@@ -1453,7 +1708,7 @@ var GoogleGenerativeAILanguageModel = class {
             controller.enqueue({ type: "stream-start", warnings });
           },
           transform(chunk, controller) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
             if (options.includeRawChunks) {
               controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
             }
@@ -1646,36 +1901,110 @@ var GoogleGenerativeAILanguageModel = class {
                   lastServerToolCallId = void 0;
                 }
               }
-              const toolCallDeltas = getToolCallsFromParts({
-                parts: content.parts,
-                generateId: generateId3,
-                providerOptionsName
-              });
-              if (toolCallDeltas != null) {
-                for (const toolCall of toolCallDeltas) {
+              for (const part of parts) {
+                if (!("functionCall" in part)) continue;
+                const providerMeta = part.thoughtSignature ? {
+                  [providerOptionsName]: {
+                    thoughtSignature: part.thoughtSignature
+                  }
+                } : void 0;
+                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 = generateId3();
+                    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
+                      );
+                      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
+                    );
+                    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 = generateId3();
+                  const toolName = part.functionCall.name;
+                  const args2 = typeof part.functionCall.args === "string" ? part.functionCall.args : JSON.stringify((_i = part.functionCall.args) != null ? _i : {});
                   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: args2,
+                    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: args2,
+                    providerMetadata: providerMeta
                   });
                   hasToolCalls = true;
                 }
@@ -1691,12 +2020,12 @@ var GoogleGenerativeAILanguageModel = class {
               };
               providerMetadata = {
                 [providerOptionsName]: {
-                  promptFeedback: (_i = value.promptFeedback) != null ? _i : null,
+                  promptFeedback: (_j = value.promptFeedback) != null ? _j : null,
                   groundingMetadata: lastGroundingMetadata,
                   urlContextMetadata: lastUrlContextMetadata,
-                  safetyRatings: (_j = candidate.safetyRatings) != null ? _j : null,
+                  safetyRatings: (_k = candidate.safetyRatings) != null ? _k : null,
                   usageMetadata: usageMetadata != null ? usageMetadata : null,
-                  finishMessage: (_k = candidate.finishMessage) != null ? _k : null,
+                  finishMessage: (_l = candidate.finishMessage) != null ? _l : null,
                   serviceTier
                 }
               };
@@ -1729,26 +2058,6 @@ var GoogleGenerativeAILanguageModel = class {
     };
   }
 };
-function getToolCallsFromParts({
-  parts,
-  generateId: generateId3,
-  providerOptionsName
-}) {
-  const functionCallParts = parts == null ? void 0 : parts.filter(
-    (part) => "functionCall" in part
-  );
-  return functionCallParts == null || functionCallParts.length === 0 ? void 0 : functionCallParts.map((part) => ({
-    type: "tool-call",
-    toolCallId: generateId3(),
-    toolName: part.functionCall.name,
-    args: JSON.stringify(part.functionCall.args),
-    providerMetadata: part.thoughtSignature ? {
-      [providerOptionsName]: {
-        thoughtSignature: part.thoughtSignature
-      }
-    } : void 0
-  }));
-}
 function extractSources({
   groundingMetadata,
   generateId: generateId3
@@ -1892,14 +2201,24 @@ var getGroundingMetadataSchema = () => z5.object({
     z5.object({})
   ]).nullish()
 });
+var partialArgSchema = z5.object({
+  jsonPath: z5.string(),
+  stringValue: z5.string().nullish(),
+  numberValue: z5.number().nullish(),
+  boolValue: z5.boolean().nullish(),
+  nullValue: z5.unknown().nullish(),
+  willContinue: z5.boolean().nullish()
+});
 var getContentSchema = () => z5.object({
   parts: z5.array(
     z5.union([
       // note: order matters since text can be fully empty
       z5.object({
         functionCall: z5.object({
-          name: z5.string(),
-          args: z5.unknown()
+          name: z5.string().nullish(),
+          args: z5.unknown().nullish(),
+          partialArgs: z5.array(partialArgSchema).nullish(),
+          willContinue: z5.boolean().nullish()
         }),
         thoughtSignature: z5.string().nullish()
       }),