@ai-sdk/google 3.0.142 → 3.0.143

package/docs/15-google-generative-ai.mdx

@@ -1210,6 +1210,16 @@ The errors that you get in this case look like this:
 `GenerateContentRequest.generation_config.response_schema.properties[occupation].type: must be specified`
 
 By default, structured outputs are enabled (and for tool calling they are required).
+
+The Google provider bounds schema conversion to prevent excessive resource use
+when expanding local references. Input inspection and conversion each have a
+separate budget of 10,000 visited JSON values and a conservative
+1,000,000-character serialized-size allowance, with a depth limit of 100.
+String-size accounting reserves six characters per UTF-16 code unit for JSON
+escaping. Schemas that exceed these limits throw `UnsupportedFunctionalityError`
+before a model request is sent. Reduce the schema's size, nesting, or repeated
+references to stay within these limits.
+
 You can disable structured outputs for object generation as a workaround:
 
 ```ts highlight="3,8"
@@ -1334,6 +1344,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": "3.0.142",
+  "version": "3.0.143",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "3.0.19",
-    "@ai-sdk/provider-utils": "4.0.64"
+    "@ai-sdk/provider-utils": "4.0.65"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/convert-json-schema-to-openapi-schema.ts

@@ -12,8 +12,14 @@ type ReferenceContext = {
   definitions: Record<string, JSONSchema7Definition> | undefined;
   dollarDefinitions: Record<string, JSONSchema7Definition> | undefined;
   resolvingReferences: ReadonlySet<string>;
+  budget: { nodes: number; size: number };
+  depth: number;
 };
 
+const maxSchemaDepth = 100;
+const maxSchemaNodes = 10_000;
+const maxSchemaSize = 1_000_000;
+
 const recursiveReferenceFunctionalityPrefix =
   'recursive JSON Schema reference:';
 
@@ -33,6 +39,12 @@ export function convertJSONSchemaToOpenAPISchema(
   jsonSchema: JSONSchema7Definition | undefined,
   isRoot = true,
 ): unknown {
+  // Bound the input too, including metadata copied while resolving references.
+  consumeSchemaBudget(jsonSchema, {
+    nodes: maxSchemaNodes,
+    size: maxSchemaSize,
+  });
+
   const rootSchema =
     typeof jsonSchema === 'object'
       ? (jsonSchema as JSONSchema7WithDefinitions)
@@ -42,6 +54,8 @@ export function convertJSONSchemaToOpenAPISchema(
     definitions: rootSchema?.definitions,
     dollarDefinitions: rootSchema?.$defs,
     resolvingReferences: new Set(),
+    budget: { nodes: maxSchemaNodes, size: maxSchemaSize },
+    depth: 0,
   });
 }
 
@@ -54,10 +68,34 @@ function convertJSONSchemaDefinition(
     return undefined;
   }
 
+  // Every visit is charged, even when the same definition was already expanded.
+  // Reserve space for emitted schema keywords and container punctuation.
+  referenceContext.budget.nodes--;
+  referenceContext.budget.size -= 128;
+  checkSchemaBudget(referenceContext.budget, referenceContext.depth);
+  referenceContext = {
+    ...referenceContext,
+    depth: referenceContext.depth + 1,
+  };
+
   if (typeof jsonSchema === 'boolean') {
     return { type: 'boolean', properties: {} };
   }
 
+  consumeSchemaBudget(
+    [
+      jsonSchema.$ref,
+      jsonSchema.type,
+      jsonSchema.description,
+      jsonSchema.required,
+      jsonSchema.format,
+      jsonSchema.const,
+      jsonSchema.enum,
+      jsonSchema.minLength,
+    ],
+    referenceContext.budget,
+  );
+
   if (jsonSchema.$ref != null) {
     return convertJSONSchemaReference({
       jsonSchema,
@@ -141,6 +179,7 @@ function convertJSONSchemaDefinition(
   if (properties != null) {
     result.properties = Object.entries(properties).reduce(
       (acc, [key, value]) => {
+        consumeSchemaBudget(key, referenceContext.budget);
         acc[key] = convertJSONSchemaDefinition(value, false, referenceContext);
         return acc;
       },
@@ -209,6 +248,52 @@ function convertJSONSchemaDefinition(
   return result;
 }
 
+function checkSchemaBudget(
+  budget: ReferenceContext['budget'],
+  depth: number,
+): void {
+  if (budget.nodes < 0 || budget.size < 0 || depth > maxSchemaDepth) {
+    throw new UnsupportedFunctionalityError({
+      functionality: 'JSON Schema conversion exceeding resource limits',
+      message:
+        'Google schema conversion exceeded its node, size, or depth limit.',
+    });
+  }
+}
+
+function consumeSchemaBudget(
+  value: unknown,
+  budget: ReferenceContext['budget'],
+  depth = 0,
+): void {
+  if (value === undefined) {
+    return;
+  }
+
+  budget.nodes--;
+  // A JSON string can require six characters per UTF-16 code unit when escaped.
+  // Other values reserve room for numbers, delimiters, and separators.
+  budget.size -= typeof value === 'string' ? value.length * 6 + 2 : 32;
+  checkSchemaBudget(budget, depth);
+
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      consumeSchemaBudget(item, budget, depth + 1);
+    }
+  } else if (value !== null && typeof value === 'object') {
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        consumeSchemaBudget(key, budget, depth + 1);
+        consumeSchemaBudget(
+          (value as Record<string, unknown>)[key],
+          budget,
+          depth + 1,
+        );
+      }
+    }
+  }
+}
+
 type EnumValues = NonNullable<JSONSchema7['enum']>;
 type EnumType = 'string' | 'number' | 'integer' | 'boolean';
 type GoogleEnumSchema = {

package/src/google-json-accumulator.ts

@@ -61,6 +61,7 @@ export class GoogleJSONAccumulator {
       if (!rawPath || rawPath === '$') continue;
 
       const segments = parsePath(rawPath);
+      if (!hasContiguousIndexes(this.accumulatedArgs, segments)) continue;
 
       const existingValue = getNestedValue(this.accumulatedArgs, segments);
       const isStringContinuation =
@@ -374,6 +375,39 @@ function getNestedValue(
   return current;
 }
 
+/**
+ * Checks that every array index on the path 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 hasContiguousIndexes(
+  obj: Record<string, unknown>,
+  segments: Array<string | number>,
+): boolean {
+  let current: unknown = obj;
+  for (const pathSegment of segments) {
+    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/interactions/google-interactions-language-model-options.ts

@@ -53,6 +53,8 @@ export type GoogleInteractionsModelId =
 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

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

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

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