@ai-sdk/google 4.0.113 → 4.0.116

package/docs/15-google.mdx

@@ -1594,6 +1594,14 @@ await generateText({
 
 The following optional provider options are available:
 
+- **labels** _Record<string, string>_
+
+  User-defined metadata sent in the top-level `labels` field of the Interactions
+  request. For example, set `{ safety_identifier: 'opaque_user_123' }` to attach
+  an opaque end-user identifier. Other labels are preserved unchanged.
+  Vertex AI Interactions models also read labels from `providerOptions.google`,
+  not `providerOptions.googleVertex` or `providerOptions.vertex`.
+
 - **previousInteractionId** _string_
 
   Server-side interaction id from a prior turn. When set, the server pulls

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.113",
+  "version": "4.0.116",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -35,8 +35,8 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "4.0.36",
-    "@ai-sdk/provider-utils": "5.0.75"
+    "@ai-sdk/provider": "4.0.37",
+    "@ai-sdk/provider-utils": "5.0.78"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

package/src/google-json-accumulator.ts

@@ -61,6 +61,7 @@ export class GoogleJSONAccumulator {
       if (!rawPath || rawPath === '$') continue;
 
       const segments = parsePath(rawPath);
+      if (!normalizeAndCheckIndexes(this.accumulatedArgs, segments)) continue;
 
       const existingValue = getNestedValue(this.accumulatedArgs, segments);
       const isStringContinuation =
@@ -386,6 +387,54 @@ function getNestedValue(
   return current;
 }
 
+/**
+ * Normalizes dotted array indexes in place and checks that every array index
+ * is an existing element or the next one. Arrays are streamed in order, and a
+ * sparse index would make `finalize()` serialize one `null` per hole, so a tiny
+ * response could allocate without bound.
+ * A missing or `null` parent is replaced with a new array, so it starts at 0.
+ *
+ * Input: ({items:["a"]}, ["items",1]) or ({items:["a"]}, ["items",5])
+ * Output: true or false
+ */
+function normalizeAndCheckIndexes(
+  obj: Record<string, unknown>,
+  segments: Array<string | number>,
+): boolean {
+  let current: unknown = obj;
+  for (let i = 0; i < segments.length; i++) {
+    let pathSegment = segments[i];
+    if (Array.isArray(current) && typeof pathSegment === 'string') {
+      const index = Number(pathSegment);
+      // Only canonical array-index keys affect length. Keep object keys as strings.
+      if (
+        Number.isInteger(index) &&
+        index >= 0 &&
+        index < 2 ** 32 - 1 &&
+        String(index) === pathSegment
+      ) {
+        pathSegment = index;
+        segments[i] = index;
+      }
+    }
+    if (typeof pathSegment === 'number') {
+      const length = Array.isArray(current)
+        ? current.length
+        : current == null
+          ? 0
+          : undefined;
+      if (length !== undefined && pathSegment > length) return false;
+    }
+    current =
+      current != null &&
+      typeof current === 'object' &&
+      hasOwnProperty(current as Record<string | number, unknown>, pathSegment)
+        ? (current as Record<string | number, unknown>)[pathSegment]
+        : undefined;
+  }
+  return true;
+}
+
 /**
  * Sets a value at a nested path, creating intermediate objects or arrays as needed.
  *

package/src/google-language-model.ts

@@ -24,9 +24,9 @@ import {
   lazySchema,
   mapReasoningToProviderBudget,
   mapReasoningToProviderEffort,
-  parseProviderOptions,
   postJsonToApi,
   resolve,
+  resolveProviderOptions,
   serializeModelOptions,
   WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE,
@@ -179,25 +179,15 @@ export class GoogleLanguageModel implements LanguageModelV4 {
       ? (['googleVertex', 'vertex'] as const)
       : (['google'] as const);
 
-    let googleOptions: GoogleLanguageModelOptions | undefined;
-    for (const name of providerOptionsNames) {
-      googleOptions = await parseProviderOptions({
-        provider: name,
+    // The first present namespace wins as a whole. A Vertex provider also
+    // falls back to the `google` key (e.g. via the AI Gateway).
+    const { options: googleOptions } =
+      await resolveProviderOptions<GoogleLanguageModelOptions>({
         providerOptions,
+        namespaces: [...providerOptionsNames, 'google'],
+        resolution: 'first',
         schema: googleLanguageModelOptions,
       });
-      if (googleOptions != null) break;
-    }
-
-    // Cross-namespace fallback: a Vertex provider may receive options under
-    // the `google` key (e.g. via the AI Gateway).
-    if (googleOptions == null && !providerOptionsNames.includes('google')) {
-      googleOptions = await parseProviderOptions({
-        provider: 'google',
-        providerOptions,
-        schema: googleLanguageModelOptions,
-      });
-    }
 
     // Add warning if Vertex rag tools are used with a non-Vertex Google provider
     const isVertexProvider = config.provider.startsWith('google.vertex.');
@@ -468,7 +458,13 @@ export class GoogleLanguageModel implements LanguageModelV4 {
     options: LanguageModelV4CallOptions,
     { isStreaming = false }: { isStreaming?: boolean } = {},
   ) {
-    const { responseFormat, tools, toolChoice } = options;
+    const { responseFormat, toolChoice } = options;
+    // Enforce the caller's tool choice before the JSON response fallback can
+    // replace it with a forced call to the synthetic response tool.
+    const tools =
+      toolChoice?.type === 'none'
+        ? options.tools?.filter(tool => tool.type === 'function')
+        : options.tools;
     const entry = getGoogleLanguageModelEntry(this.modelId);
     const { structuredOutput } = entry.capabilities.language;
     let jsonResponseTool: LanguageModelV4FunctionTool | undefined;
@@ -522,6 +518,7 @@ export class GoogleLanguageModel implements LanguageModelV4 {
   static convertGenerateContentResponse({
     config,
     response,
+    responseHeaders,
     warnings,
     providerOptionsNames,
     toolNameMapping,
@@ -531,6 +528,7 @@ export class GoogleLanguageModel implements LanguageModelV4 {
   }: {
     config: GoogleLanguageModelConfig;
     response: InferSchema<typeof responseSchema>;
+    responseHeaders?: Record<string, string>;
     warnings: SharedV4Warning[];
     providerOptionsNames: readonly string[];
     toolNameMapping?: ReturnType<typeof createToolNameMapping>;
@@ -734,7 +732,10 @@ export class GoogleLanguageModel implements LanguageModelV4 {
         safetyRatings: candidate?.safetyRatings ?? null,
         usageMetadata: usageMetadata ?? null,
         finishMessage: candidate?.finishMessage ?? null,
-        serviceTier: usageMetadata?.serviceTier ?? null,
+        serviceTier:
+          usageMetadata?.serviceTier ??
+          responseHeaders?.['x-gemini-service-tier'] ??
+          null,
         ...(candidate?.continuationToken != null
           ? { continuationToken: candidate.continuationToken }
           : {}),
@@ -836,6 +837,7 @@ export class GoogleLanguageModel implements LanguageModelV4 {
     const lastResult = GoogleLanguageModel.convertGenerateContentResponse({
       config: this.config,
       response: { ...response, usageMetadata },
+      responseHeaders,
       warnings,
       providerOptionsNames,
       toolNameMapping,
@@ -1595,7 +1597,10 @@ export class GoogleLanguageModel implements LanguageModelV4 {
                 safetyRatings: lastSafetyRatings,
                 usageMetadata: usage ?? null,
                 finishMessage: lastFinishMessage,
-                serviceTier: usage?.serviceTier ?? null,
+                serviceTier:
+                  usage?.serviceTier ??
+                  responseHeaders?.['x-gemini-service-tier'] ??
+                  null,
                 // Only surface the token when the response stopped early
                 // (budget used up, or continuing failed), not for the
                 // checkpoint tokens of a stream that finished normally.

package/src/google-prepare-tools.ts

@@ -48,6 +48,13 @@ export function prepareTools({
       };
   toolWarnings: SharedV4Warning[];
 } {
+  // NONE only disables function calling in the Google API. Provider tools
+  // must be omitted so they cannot execute server-side. Keep function
+  // declarations for conversation history containing function calls.
+  if (toolChoice?.type === 'none') {
+    tools = tools?.filter(tool => tool.type === 'function');
+  }
+
   // when the tools array is empty, change it to undefined to prevent errors:
   tools = tools?.length ? tools : undefined;
 

package/src/interactions/google-interactions-language-model-options.ts

@@ -76,6 +76,8 @@ export type GoogleInteractionsVideoOptions = {
 export const googleInteractionsLanguageModelOptions = lazySchema(() =>
   zodSchema(
     z.object({
+      /** User-defined request metadata, including `safety_identifier`. */
+      labels: z.record(z.string(), z.string()).nullish(),
       previousInteractionId: z.string().nullish(),
       store: z.boolean().nullish(),
 

package/src/interactions/google-interactions-language-model.ts

@@ -447,6 +447,7 @@ export class GoogleInteractionsLanguageModel implements LanguageModelV4 {
     const args: GoogleInteractionsRequestBody = pruneUndefined({
       ...(isAgent ? { agent: this.agent } : { model: this.modelId }),
       input,
+      labels: googleOptions?.labels ?? undefined,
       system_instruction: systemInstruction,
       tools: toolsForBody,
       response_format:

package/src/interactions/google-interactions-prompt.ts

@@ -577,6 +577,7 @@ export type GoogleInteractionsRequestBody = {
   model?: string;
   agent?: string;
   input: GoogleInteractionsInput;
+  labels?: Record<string, string>;
   system_instruction?: string;
   tools?: Array<GoogleInteractionsTool>;
   response_format?: Array<GoogleInteractionsResponseFormatEntry>;