@ai-sdk/google 4.0.94 → 4.0.96

package/src/convert-google-usage.ts

@@ -50,3 +50,79 @@ export function convertGoogleUsage(
     raw: usage,
   };
 }
+
+/**
+ * Sums the usage metadata of two requests, e.g. the hops of a long decode
+ * response that was continued automatically. Non-numeric fields are taken
+ * from the later request.
+ */
+export function addGoogleUsageMetadata<T extends GoogleUsageMetadata>(
+  a: T | undefined,
+  b: T | undefined,
+): T | undefined {
+  if (a == null || b == null) {
+    return b ?? a;
+  }
+
+  return {
+    ...a,
+    ...b,
+    promptTokenCount: addCounts(a.promptTokenCount, b.promptTokenCount),
+    candidatesTokenCount: addCounts(
+      a.candidatesTokenCount,
+      b.candidatesTokenCount,
+    ),
+    toolUsePromptTokenCount: addCounts(
+      a.toolUsePromptTokenCount,
+      b.toolUsePromptTokenCount,
+    ),
+    totalTokenCount: addCounts(a.totalTokenCount, b.totalTokenCount),
+    cachedContentTokenCount: addCounts(
+      a.cachedContentTokenCount,
+      b.cachedContentTokenCount,
+    ),
+    thoughtsTokenCount: addCounts(a.thoughtsTokenCount, b.thoughtsTokenCount),
+    promptTokensDetails: addTokenDetails(
+      a.promptTokensDetails,
+      b.promptTokensDetails,
+    ),
+    cacheTokensDetails: addTokenDetails(
+      a.cacheTokensDetails,
+      b.cacheTokensDetails,
+    ),
+    candidatesTokensDetails: addTokenDetails(
+      a.candidatesTokensDetails,
+      b.candidatesTokensDetails,
+    ),
+    toolUsePromptTokensDetails: addTokenDetails(
+      a.toolUsePromptTokensDetails,
+      b.toolUsePromptTokensDetails,
+    ),
+  };
+}
+
+function addCounts(
+  a: number | null | undefined,
+  b: number | null | undefined,
+): number | null | undefined {
+  return a == null && b == null ? (b ?? a) : (a ?? 0) + (b ?? 0);
+}
+
+function addTokenDetails(
+  a: GoogleTokenDetail[] | null | undefined,
+  b: GoogleTokenDetail[] | null | undefined,
+): GoogleTokenDetail[] | null | undefined {
+  if (a == null || b == null) {
+    return b ?? a;
+  }
+
+  const tokenCounts = new Map<string, number>();
+  for (const { modality, tokenCount } of [...a, ...b]) {
+    tokenCounts.set(modality, (tokenCounts.get(modality) ?? 0) + tokenCount);
+  }
+
+  return Array.from(tokenCounts, ([modality, tokenCount]) => ({
+    modality,
+    tokenCount,
+  }));
+}

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

@@ -35,6 +35,7 @@ export type GoogleModelId =
   | 'gemini-3.6-flash'
   | 'gemini-3.7-flash'
   | 'gemini-3.8-flash'
+  | 'gemini-4-argon'
   | 'gemini-nano-banana-2.1'
   // latest version
   // https://ai.google.dev/gemini-api/docs/models#latest
@@ -259,6 +260,17 @@ export const googleLanguageModelOptions = lazySchema(() =>
        */
       serviceTier: z.enum(['standard', 'flex', 'priority']).optional(),
 
+      /**
+       * Optional. Resumes a response that stopped with `MAX_TOKENS` because it
+       * used up its `maxOutputTokens` budget (Gemini 4 long decode). Pass the
+       * `continuationToken` from the previous response's provider metadata
+       * together with the original prompt and a higher `maxOutputTokens` (the
+       * budget is cumulative across requests). Requests that reach the
+       * per-request cap while budget remains (`CONTINUATION`) are continued
+       * automatically. Sent as the `continuationToken` body field.
+       */
+      continuationToken: z.string().optional(),
+
       /**
        * Optional. Vertex AI only. Sent as the
        * `X-Vertex-AI-LLM-Shared-Request-Type` request header to select a

package/src/google-language-model.ts

@@ -36,7 +36,9 @@ import {
   type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
+import { continueGoogleStream } from './continue-google-stream';
 import {
+  addGoogleUsageMetadata,
   convertGoogleUsage,
   type GoogleUsageMetadata,
 } from './convert-google-usage';
@@ -442,6 +444,9 @@ export class GoogleLanguageModel implements LanguageModelV4 {
         cachedContent: googleOptions?.cachedContent,
         labels: googleOptions?.labels,
         serviceTier: bodyServiceTier,
+        ...(googleOptions?.continuationToken != null && {
+          continuationToken: googleOptions.continuationToken,
+        }),
       },
       warnings: [...warnings, ...toolWarnings],
       providerOptionsNames,
@@ -510,6 +515,7 @@ export class GoogleLanguageModel implements LanguageModelV4 {
     providerOptionsNames,
     toolNameMapping,
     jsonResponseToolName,
+    initialPromptTokenCount,
   }: {
     config: GoogleLanguageModelConfig;
     response: InferSchema<typeof responseSchema>;
@@ -517,6 +523,7 @@ export class GoogleLanguageModel implements LanguageModelV4 {
     providerOptionsNames: readonly string[];
     toolNameMapping?: ReturnType<typeof createToolNameMapping>;
     jsonResponseToolName?: string;
+    initialPromptTokenCount?: number | null;
   }): LanguageModelV4GenerateResult {
     const wrapProviderMetadata = (payload: Record<string, unknown>) =>
       Object.fromEntries(
@@ -712,6 +719,10 @@ export class GoogleLanguageModel implements LanguageModelV4 {
         usageMetadata: usageMetadata ?? null,
         finishMessage: candidate?.finishMessage ?? null,
         serviceTier: usageMetadata?.serviceTier ?? null,
+        ...(candidate?.continuationToken != null
+          ? { continuationToken: candidate.continuationToken }
+          : {}),
+        ...(initialPromptTokenCount != null ? { initialPromptTokenCount } : {}),
       } satisfies GoogleProviderMetadata),
       response: {
         // TODO timestamp, model id
@@ -738,31 +749,88 @@ export class GoogleLanguageModel implements LanguageModelV4 {
       extraHeaders,
     );
 
-    const {
+    const generateContent = (body: typeof args) =>
+      postJsonToApi({
+        url: `${this.config.baseURL}/${getModelPath(
+          this.modelId,
+        )}:generateContent`,
+        headers: mergedHeaders,
+        body,
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(responseSchema),
+        abortSignal: options.abortSignal,
+        fetch: this.config.fetch,
+      });
+
+    let {
       responseHeaders,
       value: response,
       rawValue: rawResponse,
-    } = await postJsonToApi({
-      url: `${this.config.baseURL}/${getModelPath(
-        this.modelId,
-      )}:generateContent`,
-      headers: mergedHeaders,
-      body: args,
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createJsonResponseHandler(responseSchema),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch,
-    });
+    } = await generateContent(args);
+
+    // Gemini 4 long decode: a request that reaches the per-request cap while
+    // `maxOutputTokens` budget remains finishes with `CONTINUATION`. Resend
+    // the same request with the continuation token (the server tracks the
+    // cumulative tokens) and combine the content of all requests.
+    //
+    // Usage is summed across requests (matching billing). Each request re-sends
+    // the prompt plus all output so far as input, so the first request's
+    // prompt token count is kept separately for context window checks.
+    const content: LanguageModelV4Content[] = [];
+    let usageMetadata: GoogleUsageMetadata | undefined;
+    const firstPromptTokenCount = response.usageMetadata?.promptTokenCount;
+    let isContinued = false;
+
+    while (true) {
+      const candidate = response.candidates?.[0];
+      const continuationToken =
+        candidate?.finishReason === 'CONTINUATION'
+          ? candidate.continuationToken
+          : undefined;
 
-    const result = GoogleLanguageModel.convertGenerateContentResponse({
+      usageMetadata = addGoogleUsageMetadata(
+        usageMetadata,
+        response.usageMetadata ?? undefined,
+      );
+
+      if (continuationToken == null) {
+        break;
+      }
+
+      content.push(
+        ...GoogleLanguageModel.convertGenerateContentResponse({
+          config: this.config,
+          response,
+          warnings,
+          providerOptionsNames,
+          toolNameMapping,
+          jsonResponseToolName,
+        }).content,
+      );
+
+      isContinued = true;
+      ({
+        responseHeaders,
+        value: response,
+        rawValue: rawResponse,
+      } = await generateContent({ ...args, continuationToken }));
+    }
+
+    const lastResult = GoogleLanguageModel.convertGenerateContentResponse({
       config: this.config,
-      response,
+      response: { ...response, usageMetadata },
       warnings,
       providerOptionsNames,
       toolNameMapping,
       jsonResponseToolName,
+      initialPromptTokenCount: isContinued ? firstPromptTokenCount : undefined,
     });
 
+    const result = {
+      ...lastResult,
+      content: [...content, ...lastResult.content],
+    };
+
     return {
       ...result,
       request: { body: args },
@@ -796,16 +864,37 @@ export class GoogleLanguageModel implements LanguageModelV4 {
       extraHeaders,
     );
 
-    const { responseHeaders, value: response } = await postJsonToApi({
-      url: `${this.config.baseURL}/${getModelPath(
-        this.modelId,
-      )}:streamGenerateContent?alt=sse`,
-      headers,
-      body: args,
-      failedResponseHandler: googleFailedResponseHandler,
-      successfulResponseHandler: createEventSourceResponseHandler(chunkSchema),
-      abortSignal: options.abortSignal,
-      fetch: this.config.fetch,
+    const streamGenerateContent = (body: typeof args) =>
+      postJsonToApi({
+        url: `${this.config.baseURL}/${getModelPath(
+          this.modelId,
+        )}:streamGenerateContent?alt=sse`,
+        headers,
+        body,
+        failedResponseHandler: googleFailedResponseHandler,
+        successfulResponseHandler:
+          createEventSourceResponseHandler(chunkSchema),
+        abortSignal: options.abortSignal,
+        fetch: this.config.fetch,
+      });
+
+    const { responseHeaders, value: firstResponse } =
+      await streamGenerateContent(args);
+
+    // Gemini 4 long decode: when a stream reaches the per-request cap while
+    // `maxOutputTokens` budget remains, its last chunk finishes with
+    // `CONTINUATION`. Resend the same request with the continuation token and
+    // append the new stream, which contains only newly generated content.
+    const response = continueGoogleStream({
+      stream: firstResponse,
+      getContinuationToken: chunk => {
+        const candidate = chunk.candidates?.[0];
+        return candidate?.finishReason === 'CONTINUATION'
+          ? (candidate.continuationToken ?? undefined)
+          : undefined;
+      },
+      continueStream: async continuationToken =>
+        (await streamGenerateContent({ ...args, continuationToken })).value,
     });
 
     let finishReason: LanguageModelV4FinishReason = {
@@ -813,11 +902,16 @@ export class GoogleLanguageModel implements LanguageModelV4 {
       raw: undefined,
     };
     let usage: GoogleUsageMetadata | undefined = undefined;
+    // Usage of the completed requests of an automatically continued response.
+    let continuedUsage: GoogleUsageMetadata | undefined = undefined;
+    // Prompt token count of the first request, for context window checks.
+    let initialPromptTokenCount: number | null | undefined = undefined;
     let promptFeedback: PromptFeedbackSchema | null = null;
     let lastGroundingMetadata: GroundingMetadataSchema | null = null;
     let lastUrlContextMetadata: UrlContextMetadataSchema | null = null;
     let lastSafetyRatings: SafetyRatingSchema[] | null = null;
     let lastFinishMessage: string | null = null;
+    let lastContinuationToken: string | null = null;
     let confirmedPromptBlockReason: string | undefined;
 
     const generateId = this.config.generateId;
@@ -947,6 +1041,9 @@ export class GoogleLanguageModel implements LanguageModelV4 {
               if (candidate.finishMessage != null) {
                 lastFinishMessage = candidate.finishMessage;
               }
+              if (candidate.continuationToken != null) {
+                lastContinuationToken = candidate.continuationToken;
+              }
             }
 
             // A confirmed prompt block is terminal for generated content, but
@@ -1322,6 +1419,16 @@ export class GoogleLanguageModel implements LanguageModelV4 {
               }
             }
 
+            if (candidate.finishReason === 'CONTINUATION') {
+              // Usage metadata is per request. The next request reports its
+              // own usage, so bank the usage of this one.
+              if (continuedUsage == null) {
+                initialPromptTokenCount = usage?.promptTokenCount;
+              }
+              continuedUsage = addGoogleUsageMetadata(continuedUsage, usage);
+              usage = undefined;
+            }
+
             if (candidate.finishReason != null) {
               finishReason = {
                 unified: mapGoogleFinishReason({
@@ -1334,6 +1441,8 @@ export class GoogleLanguageModel implements LanguageModelV4 {
           },
 
           flush(controller) {
+            usage = addGoogleUsageMetadata(continuedUsage, usage);
+
             if (currentTextBlockId !== null) {
               controller.enqueue({
                 type: 'text-end',
@@ -1359,6 +1468,17 @@ export class GoogleLanguageModel implements LanguageModelV4 {
                 usageMetadata: usage ?? null,
                 finishMessage: lastFinishMessage,
                 serviceTier: usage?.serviceTier ?? 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.
+                ...(lastContinuationToken != null &&
+                (finishReason.raw === 'MAX_TOKENS' ||
+                  finishReason.raw === 'CONTINUATION')
+                  ? { continuationToken: lastContinuationToken }
+                  : {}),
+                ...(initialPromptTokenCount != null
+                  ? { initialPromptTokenCount }
+                  : {}),
               } satisfies GoogleProviderMetadata),
             });
           },
@@ -1845,6 +1965,7 @@ export const responseSchema = lazySchema(() =>
             content: getContentSchema().nullish().or(z.object({}).strict()),
             finishReason: z.string().nullish(),
             finishMessage: z.string().nullish(),
+            continuationToken: z.string().nullish(),
             safetyRatings: z.array(getSafetyRatingSchema()).nullish(),
             groundingMetadata: getGroundingMetadataSchema().nullish(),
             urlContextMetadata: getUrlContextMetadataSchema().nullish(),
@@ -1898,6 +2019,7 @@ const chunkSchema = lazySchema(() =>
             content: getContentSchema().nullish(),
             finishReason: z.string().nullish(),
             finishMessage: z.string().nullish(),
+            continuationToken: z.string().nullish(),
             safetyRatings: z.array(getSafetyRatingSchema()).nullish(),
             groundingMetadata: getGroundingMetadataSchema().nullish(),
             urlContextMetadata: getUrlContextMetadataSchema().nullish(),

package/src/google-prompt.ts

@@ -100,4 +100,22 @@ export interface GoogleProviderMetadata {
   finishReason?: string | null;
   finishMessage: string | null;
   serviceTier: string | null;
+
+  /**
+   * Opaque token returned when a response stops with `MAX_TOKENS` because it
+   * used up its `maxOutputTokens` budget. Pass it back as
+   * `providerOptions.google.continuationToken` together with a higher
+   * `maxOutputTokens` and the original prompt to resume generation.
+   */
+  continuationToken?: string | null;
+
+  /**
+   * Prompt token count of the first request of a long decode response that
+   * was continued automatically (Gemini 4). Usage is summed across requests
+   * to match billing, and each continued request re-sends the prompt plus all
+   * output so far as input. Use this value instead of the summed input tokens
+   * for context window checks and compaction. Only present when the response
+   * spanned more than one request.
+   */
+  initialPromptTokenCount?: number | null;
 }

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

@@ -37,6 +37,7 @@ export type GoogleInteractionsModelId =
   | 'gemini-3.6-flash'
   | 'gemini-3.7-flash'
   | 'gemini-3.8-flash'
+  | 'gemini-4-argon'
   | 'gemini-nano-banana-2.1'
   | 'lyria-3-clip-preview'
   | 'lyria-3-pro-preview'

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

@@ -482,7 +482,7 @@ export class GoogleInteractionsLanguageModel implements LanguageModelV4 {
   async doGenerate(
     options: LanguageModelV4CallOptions,
   ): Promise<LanguageModelV4GenerateResult> {
-    const { args, warnings, isAgent, pollingTimeoutMs } =
+    const { args, warnings, isAgent, isBackground, pollingTimeoutMs } =
       await this.getArgs(options);
 
     const url = `${this.config.baseURL}/interactions`;
@@ -511,12 +511,12 @@ export class GoogleInteractionsLanguageModel implements LanguageModelV4 {
     } = postResult;
 
     /*
-     * Agent calls may return a non-terminal status (`in_progress` /
-     * `requires_action`) when invoked with `background: true`. Poll
-     * `GET /interactions/{id}` until terminal so the user-facing surface
-     * matches a synchronous call.
+     * Agent calls and `background: true` calls (e.g. Gemini 4 long decode,
+     * where the server runs every hop) may return a non-terminal status
+     * (`in_progress` / `requires_action`). Poll `GET /interactions/{id}` until
+     * terminal so the user-facing surface matches a synchronous call.
      */
-    if (isAgent && !isTerminalStatus(response.status)) {
+    if ((isAgent || isBackground) && !isTerminalStatus(response.status)) {
       const polled = await pollGoogleInteractionUntilTerminal({
         baseURL: this.config.baseURL,
         interactionId: response.id,

package/src/map-google-finish-reason.ts

@@ -11,6 +11,9 @@ export function mapGoogleFinishReason({
     case 'STOP':
       return hasToolCalls ? 'tool-calls' : 'stop';
     case 'MAX_TOKENS':
+    // Gemini 4 long decode: the per-request cap was reached while budget
+    // remains. Continued automatically; only surfaced if continuing fails.
+    case 'CONTINUATION':
       return 'length';
     case 'IMAGE_SAFETY':
     case 'RECITATION':