@ai-sdk/google 4.0.109 → 4.0.111

package/docs/15-google.mdx

@@ -486,12 +486,12 @@ Things to keep in mind:
 
 #### Long decode with the Interactions API
 
-With the [Interactions API](#interactions-api), long decode requires
-`background: true`. The server runs every request itself, so no client-side
-continuation is needed, and `usage` covers all requests. Set an explicit
-`maxOutputTokens` above 65,536 (without it, you get a single 64K request) and
-keep `store` enabled (the default). The provider polls the interaction (or
-streams it, reconnecting when the connection drops) until it finishes.
+With the [Interactions API](#interactions-api), the AI SDK currently requires
+`background: true` for long decode. The server runs every request itself, so no
+client-side continuation is needed, and `usage` covers all requests. Set an
+explicit `maxOutputTokens` above 65,536 and keep `store` enabled (the default).
+The provider polls the interaction (or streams it, reconnecting when the
+connection drops) until it finishes.
 
 ```ts
 import { google } from '@ai-sdk/google';
@@ -510,10 +510,14 @@ const result = await generateText({
 });
 ```
 
-Without `background: true`, an interaction generates at most 65,536 tokens.
-Requests with a higher `maxOutputTokens` are rejected by the API, and an
-interaction that reaches the cap finishes with `length`. Long decode is not
-available with the Vertex AI Interactions API.
+Foreground client-side continuation is not yet supported by the AI SDK.
+If you do not set `maxOutputTokens`, non-streaming calls (`generateText`)
+default to 32,768 tokens and streaming calls (`streamText`) to 65,536 tokens.
+An interaction that reaches its limit finishes with `length`. Long decode is
+not available with the Vertex AI Interactions API.
+
+The token budget includes both thinking and output tokens. To retain the previous
+64K budget for a non-streaming call, set `maxOutputTokens: 65_536` explicitly.
 
 ### File Inputs
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.109",
+  "version": "4.0.111",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "4.0.35",
-    "@ai-sdk/provider-utils": "5.0.72"
+    "@ai-sdk/provider-utils": "5.0.74"
   },
   "devDependencies": {
     "@ai-sdk/test-server": "2.0.4",

package/src/convert-to-google-messages.ts

@@ -6,6 +6,7 @@ import {
   type SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
+  stringifyWithBigIntAndCycles,
   convertToBase64,
   getTopLevelMediaType,
   isFullMediaType,
@@ -67,18 +68,26 @@ function convertUrlToolResultPart(
   };
 }
 
-function containsJSONSchemaReference(value: JSONValue | undefined): boolean {
-  if (Array.isArray(value)) {
-    return value.some(containsJSONSchemaReference);
+function containsJSONSchemaReference(
+  value: JSONValue | undefined,
+  seen: WeakSet<object> = new WeakSet(),
+): boolean {
+  if (value === null || typeof value !== 'object') {
+    return false;
   }
 
-  if (typeof value !== 'object' || value === null) {
+  if (seen.has(value)) {
     return false;
   }
+  seen.add(value);
+
+  if (Array.isArray(value)) {
+    return value.some(item => containsJSONSchemaReference(item, seen));
+  }
 
   return Object.entries(value).some(
     ([key, nestedValue]) =>
-      key === '$ref' || containsJSONSchemaReference(nestedValue),
+      key === '$ref' || containsJSONSchemaReference(nestedValue, seen),
   );
 }
 
@@ -88,7 +97,41 @@ function serializeFunctionResponseContent(
   // Google reserves { $ref: displayName } in structured function responses for
   // multimodal parts. This conflicts with JSON Schema $ref, so serialize the
   // result to preserve it without triggering Google's reference handling.
-  return containsJSONSchemaReference(value) ? JSON.stringify(value) : value;
+  if (containsJSONSchemaReference(value)) {
+    return stringifyWithBigIntAndCycles(value);
+  }
+
+  // Keep Google's structured response for ordinary JSON, but normalize values
+  // that would otherwise fail when the final request body is serialized.
+  return containsNonJsonValue(value)
+    ? secureJsonParse(stringifyWithBigIntAndCycles(value))
+    : value;
+}
+
+function containsNonJsonValue(
+  value: unknown,
+  ancestors = new Set<object>(),
+): boolean {
+  if (typeof value === 'bigint') {
+    return true;
+  }
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  if (typeof (value as { toJSON?: unknown }).toJSON === 'function') {
+    return true;
+  }
+  if (ancestors.has(value)) {
+    return true;
+  }
+  ancestors.add(value);
+  try {
+    return Object.values(value).some(item =>
+      containsNonJsonValue(item, ancestors),
+    );
+  } finally {
+    ancestors.delete(value);
+  }
 }
 
 /*
@@ -586,7 +629,7 @@ export function convertToGoogleMessages(
                         ? { id: part.toolCallId }
                         : {}),
                       name: part.toolName,
-                      args: part.input,
+                      args: parseToolCallInput(part.input),
                     },
                     thoughtSignature: effectiveThoughtSignature,
                   };
@@ -775,3 +818,14 @@ export function convertToGoogleMessages(
     contents,
   };
 }
+
+function parseToolCallInput(input: unknown): unknown {
+  if (typeof input !== 'string') {
+    return input;
+  }
+  try {
+    return secureJsonParse(input);
+  } catch {
+    return input;
+  }
+}

package/src/google-error.ts

@@ -28,3 +28,40 @@ export const googleFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: googleErrorDataSchema,
   errorToMessage: data => data.error.message,
 });
+
+// Google RPC status names can be sent without a numeric HTTP error code.
+export function mapGoogleErrorStatusToHttpStatusCode(
+  status: string,
+): number | undefined {
+  switch (status) {
+    case 'CANCELLED':
+      return 499;
+    case 'INVALID_ARGUMENT':
+    case 'FAILED_PRECONDITION':
+    case 'OUT_OF_RANGE':
+      return 400;
+    case 'DEADLINE_EXCEEDED':
+      return 504;
+    case 'NOT_FOUND':
+      return 404;
+    case 'ALREADY_EXISTS':
+    case 'ABORTED':
+      return 409;
+    case 'PERMISSION_DENIED':
+      return 403;
+    case 'UNAUTHENTICATED':
+      return 401;
+    case 'RESOURCE_EXHAUSTED':
+      return 429;
+    case 'UNIMPLEMENTED':
+      return 501;
+    case 'UNKNOWN':
+    case 'INTERNAL':
+    case 'DATA_LOSS':
+      return 500;
+    case 'UNAVAILABLE':
+      return 503;
+    default:
+      return undefined;
+  }
+}

package/src/google-language-model.ts

@@ -51,6 +51,7 @@ import { getModelPath } from './get-model-path';
 import {
   getGoogleErrorSchema,
   googleFailedResponseHandler,
+  mapGoogleErrorStatusToHttpStatusCode,
 } from './google-error';
 import { sanitizeResponseJsonSchema } from './sanitize-response-json-schema';
 import {
@@ -1040,19 +1041,22 @@ export class GoogleLanguageModel implements LanguageModelV4 {
             if (value.error != null) {
               finishReason = { unified: 'error', raw: undefined };
               const error = value.error;
+              const statusCode =
+                error.code ??
+                mapGoogleErrorStatusToHttpStatusCode(error.status);
               controller.enqueue({
                 type: 'error',
                 error: createProviderStreamError({
                   message: error.message,
                   type: error.status,
                   code: error.code ?? undefined,
-                  statusCode: error.code ?? undefined,
+                  statusCode,
                   isRetryable:
-                    error.code != null &&
-                    (error.code === 408 ||
-                      error.code === 409 ||
-                      error.code === 429 ||
-                      error.code >= 500),
+                    statusCode != null &&
+                    (statusCode === 408 ||
+                      statusCode === 409 ||
+                      statusCode === 429 ||
+                      statusCode >= 500),
                   data: error,
                 }),
               });

package/src/interactions/prepare-google-interactions-tools.ts

@@ -39,7 +39,7 @@ export type PrepareGoogleInteractionsToolsResult = {
  * `toolChoice` shapes:
  * - `'auto'`     -> `'auto'`
  * - `'required'` -> `'any'`
- * - `'none'`     -> `'none'`
+ * - `'none'`     -> omit all tools and `tool_choice`
  * - `{ type: 'tool', toolName }` -> `{ allowed_tools: { mode: 'validated', tools: [name] } }`
  *   (Interactions `AllowedTools.tools` is an `Array<string>` of function
  *   names, not tool descriptors -- see `src/interactions/resources/interactions.ts`
@@ -54,6 +54,12 @@ export function prepareGoogleInteractionsTools({
 }): PrepareGoogleInteractionsToolsResult {
   const toolWarnings: Array<SharedV4Warning> = [];
 
+  // The API's tool_choice only controls function tools. Omit all tools to
+  // disable provider-executed tools as well.
+  if (toolChoice?.type === 'none') {
+    return { tools: undefined, toolChoice: undefined, toolWarnings };
+  }
+
   const normalized = tools?.length ? tools : undefined;
 
   if (normalized == null) {
@@ -223,9 +229,6 @@ export function prepareGoogleInteractionsTools({
       case 'required':
         mappedToolChoice = 'any';
         break;
-      case 'none':
-        mappedToolChoice = 'none';
-        break;
       case 'tool':
         mappedToolChoice = {
           allowed_tools: {