@ai-sdk/google 3.0.140 → 3.0.142

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

@@ -447,12 +447,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';
@@ -471,10 +471,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": "3.0.140",
+  "version": "3.0.142",
   "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.63"
+    "@ai-sdk/provider-utils": "4.0.64"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

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

@@ -1,9 +1,11 @@
 import {
+  type JSONValue,
   UnsupportedFunctionalityError,
   type LanguageModelV3Prompt,
   type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
+  stringifyWithBigIntAndCycles,
   convertToBase64,
   isUrlSupported,
   secureJsonParse,
@@ -105,6 +107,42 @@ function convertUrlToolResultPart(
     : undefined;
 }
 
+function serializeFunctionResponseContent(
+  value: JSONValue,
+): JSONValue | string {
+  // 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);
+  }
+}
+
 /*
  * Appends tool result content parts to the message using the functionResponse
  * format with support for multimodal parts (e.g. inline images/files alongside
@@ -151,12 +189,12 @@ function appendToolResultParts(
         if (functionResponsePart != null) {
           functionResponseParts.push(functionResponsePart);
         } else {
-          responseTextParts.push(JSON.stringify(contentPart));
+          responseTextParts.push(stringifyWithBigIntAndCycles(contentPart));
         }
         break;
       }
       default: {
-        responseTextParts.push(JSON.stringify(contentPart));
+        responseTextParts.push(stringifyWithBigIntAndCycles(contentPart));
         break;
       }
     }
@@ -234,7 +272,7 @@ function appendLegacyToolResultParts(
         break;
       }
       default:
-        parts.push({ text: JSON.stringify(contentPart) });
+        parts.push({ text: stringifyWithBigIntAndCycles(contentPart) });
         break;
     }
   }
@@ -462,7 +500,7 @@ export function convertToGoogleGenerativeAIMessages(
                         ? { id: part.toolCallId }
                         : {}),
                       name: part.toolName,
-                      args: part.input,
+                      args: parseToolCallInput(part.input),
                     },
                     thoughtSignature: effectiveThoughtSignature,
                   };
@@ -579,7 +617,7 @@ export function convertToGoogleGenerativeAIMessages(
                   content:
                     output.type === 'execution-denied'
                       ? (output.reason ?? 'Tool call execution denied.')
-                      : output.value,
+                      : serializeFunctionResponseContent(output.value),
                 },
               },
             });
@@ -633,3 +671,14 @@ export function convertToGoogleGenerativeAIMessages(
     contents,
   };
 }
+
+function parseToolCallInput(input: unknown): unknown {
+  if (typeof input !== 'string') {
+    return input;
+  }
+  try {
+    return secureJsonParse(input);
+  } catch {
+    return input;
+  }
+}

package/src/google-error.ts

@@ -6,15 +6,18 @@ import {
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
+export const getGoogleErrorSchema = () =>
+  z.object({
+    code: z.number().nullable(),
+    message: z.string(),
+    status: z.string(),
+    details: z.array(z.unknown()).nullish(),
+  });
+
 const googleErrorDataSchema = lazySchema(() =>
   zodSchema(
     z.object({
-      error: z.object({
-        code: z.number().nullable(),
-        message: z.string(),
-        status: z.string(),
-        details: z.array(z.unknown()).nullish(),
-      }),
+      error: getGoogleErrorSchema(),
     }),
   ),
 );
@@ -25,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-generative-ai-language-model.ts

@@ -1,15 +1,16 @@
-import type {
-  LanguageModelV3,
-  LanguageModelV3CallOptions,
-  LanguageModelV3Content,
-  LanguageModelV3FinishReason,
-  LanguageModelV3GenerateResult,
-  LanguageModelV3Source,
-  LanguageModelV3StreamPart,
-  LanguageModelV3StreamResult,
-  JSONObject,
-  SharedV3ProviderMetadata,
-  SharedV3Warning,
+import {
+  APICallError,
+  type LanguageModelV3,
+  type LanguageModelV3CallOptions,
+  type LanguageModelV3Content,
+  type LanguageModelV3FinishReason,
+  type LanguageModelV3GenerateResult,
+  type LanguageModelV3Source,
+  type LanguageModelV3StreamPart,
+  type LanguageModelV3StreamResult,
+  type JSONObject,
+  type SharedV3ProviderMetadata,
+  type SharedV3Warning,
 } from '@ai-sdk/provider';
 import {
   combineHeaders,
@@ -37,7 +38,11 @@ import { convertJSONSchemaToOpenAPISchema } from './convert-json-schema-to-opena
 import { convertToGoogleGenerativeAIMessages } from './convert-to-google-generative-ai-messages';
 import { downloadToolResultFiles } from './download-tool-result-files';
 import { getModelPath } from './get-model-path';
-import { googleFailedResponseHandler } from './google-error';
+import {
+  getGoogleErrorSchema,
+  googleFailedResponseHandler,
+  mapGoogleErrorStatusToHttpStatusCode,
+} from './google-error';
 import {
   googleLanguageModelOptions,
   type GoogleGenerativeAIModelId,
@@ -684,11 +689,12 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
       extraHeaders,
     );
 
+    const url = `${this.config.baseURL}/${getModelPath(
+      this.modelId,
+    )}:streamGenerateContent?alt=sse`;
     const streamGenerateContent = (body: typeof args) =>
       postJsonToApi({
-        url: `${this.config.baseURL}/${getModelPath(
-          this.modelId,
-        )}:streamGenerateContent?alt=sse`,
+        url,
         headers,
         body,
         failedResponseHandler: googleFailedResponseHandler,
@@ -829,6 +835,26 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
 
             const value = chunk.value;
 
+            if (value.error != null) {
+              finishReason = { unified: 'error', raw: undefined };
+              const error = value.error;
+              controller.enqueue({
+                type: 'error',
+                error: new APICallError({
+                  message: error.message,
+                  url,
+                  requestBodyValues: args,
+                  statusCode:
+                    error.code ??
+                    mapGoogleErrorStatusToHttpStatusCode(error.status),
+                  responseHeaders,
+                  responseBody: JSON.stringify({ error }),
+                  data: error,
+                }),
+              });
+              return;
+            }
+
             if (!hasEmittedResponseMetadata && value.responseId != null) {
               hasEmittedResponseMetadata = true;
               controller.enqueue({
@@ -1768,6 +1794,7 @@ export type UsageMetadataSchema = NonNullable<
 const chunkSchema = lazySchema(() =>
   zodSchema(
     z.object({
+      error: getGoogleErrorSchema().nullish(),
       responseId: z.string().nullish(),
       candidates: z
         .array(

package/src/google-prepare-tools.ts

@@ -53,6 +53,13 @@ export function prepareTools({
       };
   toolWarnings: SharedV3Warning[];
 } {
+  // 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/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<SharedV3Warning> = [];
 
+  // 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: {