@ai-sdk/google 3.0.131 → 3.0.133

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

@@ -267,6 +267,12 @@ The following optional provider options are available for Google Generative AI m
   [Priority inference](https://ai.google.dev/gemini-api/docs/priority-inference)
   and [Flex inference](https://ai.google.dev/gemini-api/docs/flex-inference).
 
+- **continuationToken** _string_
+
+  Optional. Resumes a response that stopped because it used up its
+  `maxOutputTokens` budget (Gemini 4 long decode). Send it with the original
+  request and a higher `maxOutputTokens`. See [Long decode](#long-decode).
+
 - **threshold** _string_
 
   Optional. Standalone threshold setting that can be used independently of `safetySettings`.
@@ -332,6 +338,136 @@ console.log(text);
 console.log(reasoning); // Reasoning summary
 ```
 
+### Long decode
+
+Gemini 4 models such as `gemini-4-argon` can keep thinking and writing past a
+single request's limits, up to the shared 1M token context window (input,
+thinking, and output tokens together). Use it for hard math, science, proofs,
+and long coding or agentic tasks.
+
+- A single request generates at most 32,768 tokens without streaming and 65,536
+  tokens with streaming (`streamText`). Thinking tokens count towards this cap.
+- `maxOutputTokens` is a **cumulative budget across requests**, not a target
+  length. When a request reaches the per-request cap while budget remains, the
+  provider automatically sends the same request again with a continuation token
+  and combines the results into one response. Set `maxOutputTokens` above the
+  per-request cap (up to 1M minus the input tokens) to enable this. If you do
+  not set it, the call ends after one request.
+- A lower `maxOutputTokens` does not make the model think less, it ends the
+  response early (possibly before any answer) and you are still charged for the
+  tokens. Use `thinkingConfig.thinkingLevel` to control how much the model
+  thinks. `thinkingBudget` is not supported by these models.
+- Complex requests can run for several minutes. Make sure your HTTP client
+  allows read timeouts of at least 15 to 20 minutes.
+
+**Usage across requests.** Each continued request re-sends the prompt plus all
+output so far as input, so its prompt token count includes everything
+generated before it. `usage` is the sum of all requests, which matches what
+Google bills (re-sent tokens are billed at a discount through implicit
+caching). Do not use the summed input tokens for context window checks or
+compaction: they can be several times larger than the real context. When a
+response spanned more than one request,
+`providerMetadata.google.initialPromptTokenCount` holds the prompt token count
+of the first request (the google-genai SDKs expose the same value as
+`initial_prompt_token_count`):
+
+```ts
+const result = await generateText({
+  model: google('gemini-4-argon'),
+  prompt,
+  maxOutputTokens: 500_000,
+});
+
+// Billing: summed across all requests
+console.log(result.usage.inputTokens.total);
+
+// Context window: the first request's prompt plus the generated output
+const promptTokens =
+  result.providerMetadata?.google?.initialPromptTokenCount ??
+  result.usage.inputTokens.total;
+const contextTokens = promptTokens + (result.usage.outputTokens.total ?? 0);
+```
+
+**Resuming after the budget is used up.** When the cumulative generated tokens
+reach `maxOutputTokens`, the finish reason is `length` and the provider returns
+a continuation token on `result.providerMetadata.google.continuationToken`. To
+continue, send the **original request unchanged** (same prompt, tools, and
+settings; do not append the partial output as a message) together with the
+token as `providerOptions.google.continuationToken` and a **higher**
+`maxOutputTokens`. Resending with the same `maxOutputTokens` fails because the
+budget is used up. Each response contains only the newly generated content.
+
+```ts
+import { google } from '@ai-sdk/google';
+import { generateText } from 'ai';
+
+const prompt = 'Prove that sqrt(2) is irrational, in detail.';
+
+const result = await generateText({
+  model: google('gemini-4-argon'),
+  prompt,
+  maxOutputTokens: 128_000,
+});
+
+const continuationToken =
+  result.providerMetadata?.google?.continuationToken;
+
+if (result.finishReason === 'length' && typeof continuationToken === 'string') {
+  // The budget was used up. Raise it to keep going.
+  const continued = await generateText({
+    model: google('gemini-4-argon'),
+    prompt,
+    maxOutputTokens: 256_000,
+    providerOptions: { google: { continuationToken } },
+  });
+
+  console.log(result.text + continued.text);
+}
+```
+
+Things to keep in mind:
+
+- **Dropped streams.** Streamed parts are forwarded as they arrive and are not
+  buffered between the server's checkpoints, so a stream that drops mid-request
+  is not resumed automatically. Retry the request from the start.
+- **Provider metadata is per call.** If you store the conversation history,
+  combine the content of all calls into one model message only after the final
+  call finishes. Keep thought signatures unchanged, including the ones on empty
+  trailing text parts.
+- **Zero Data Retention.** Continuation works with `store: false` because the
+  state travels encrypted inside the token.
+
+#### 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.
+
+```ts
+import { google } from '@ai-sdk/google';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: google.interactions('gemini-4-argon'),
+  prompt: 'Prove that sqrt(2) is irrational, in detail.',
+  maxOutputTokens: 500_000,
+  providerOptions: {
+    google: {
+      background: true,
+      pollingTimeoutMs: 60 * 60 * 1000, // default: 30 minutes
+    },
+  },
+});
+```
+
+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.
+
 ### File Inputs
 
 The Google Generative AI provider supports file inputs, e.g. PDF files.
@@ -1086,6 +1222,7 @@ The following Zod features are known to not work with Google Generative AI:
 | Model                                 | Image Input         | Object Generation   | Tool Usage          | Tool Streaming      | Google Search       | URL Context         |
 | ------------------------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- | ------------------- |
 | `gemini-nano-banana-2.1` | <Check size={18} /> | <Cross size={18} /> | <Cross size={18} /> | <Cross size={18} /> | <Check size={18} /> | <Cross size={18} /> |
+| `gemini-4-argon`                      | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `gemini-3.8-flash`                    | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `gemini-3.7-flash`                    | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |
 | `gemini-3.6-flash`                    | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> | <Check size={18} /> |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "3.0.131",
+  "version": "3.0.133",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@ai-sdk/provider": "3.0.18",
-    "@ai-sdk/provider-utils": "4.0.57"
+    "@ai-sdk/provider-utils": "4.0.59"
   },
   "devDependencies": {
     "@types/node": "20.17.24",

package/src/continue-google-stream.ts

@@ -0,0 +1,75 @@
+import type { ParseResult } from '@ai-sdk/provider-utils';
+
+/**
+ * Concatenates the event streams of a long decode response that spans several
+ * requests (Gemini 4 long decode).
+ *
+ * Events of the current stream are passed through unchanged. When an event
+ * signals that the per-request cap was reached while budget remains
+ * (`getContinuationToken` returns a token), the next request is sent with that
+ * token once the current stream ends, and its events are appended. If the
+ * continuation request fails, the error is emitted as a failed parse result
+ * and the stream ends.
+ */
+export function continueGoogleStream<T>({
+  stream,
+  getContinuationToken,
+  continueStream,
+}: {
+  stream: ReadableStream<ParseResult<T>>;
+  getContinuationToken: (value: T) => string | undefined;
+  continueStream: (
+    continuationToken: string,
+  ) => Promise<ReadableStream<ParseResult<T>>>;
+}): ReadableStream<ParseResult<T>> {
+  let reader = stream.getReader();
+  let pendingContinuationToken: string | undefined;
+
+  return new ReadableStream<ParseResult<T>>({
+    async pull(controller) {
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (!done) {
+          if (value.success) {
+            const token = getContinuationToken(value.value);
+            if (token != null) {
+              pendingContinuationToken = token;
+            }
+          }
+          controller.enqueue(value);
+          return;
+        }
+
+        if (pendingContinuationToken == null) {
+          controller.close();
+          return;
+        }
+
+        const continuationToken = pendingContinuationToken;
+        pendingContinuationToken = undefined;
+
+        try {
+          reader = (await continueStream(continuationToken)).getReader();
+        } catch (error) {
+          // Surfaced as an `error` stream part, followed by the `finish` part
+          // with the last continuation token so the caller can resume.
+          controller.enqueue({
+            success: false,
+            error: error as Extract<
+              ParseResult<T>,
+              { success: false }
+            >['error'],
+            rawValue: undefined,
+          });
+          controller.close();
+          return;
+        }
+      }
+    },
+
+    async cancel(reason) {
+      await reader.cancel(reason);
+    },
+  });
+}

package/src/convert-google-generative-ai-usage.ts

@@ -60,3 +60,78 @@ export function convertGoogleGenerativeAIUsage(
     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 addGoogleGenerativeAIUsageMetadata<
+  T extends GoogleGenerativeAIUsageMetadata,
+>(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: GoogleGenerativeAITokenDetail[] | null | undefined,
+  b: GoogleGenerativeAITokenDetail[] | null | undefined,
+): GoogleGenerativeAITokenDetail[] | 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-generative-ai-language-model.ts

@@ -27,7 +27,9 @@ import {
   type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
+import { continueGoogleStream } from './continue-google-stream';
 import {
+  addGoogleGenerativeAIUsageMetadata,
   convertGoogleGenerativeAIUsage,
   type GoogleGenerativeAIUsageMetadata,
 } from './convert-google-generative-ai-usage';
@@ -376,6 +378,9 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
         cachedContent: googleOptions?.cachedContent,
         labels: googleOptions?.labels,
         serviceTier: bodyServiceTier,
+        ...(googleOptions?.continuationToken != null && {
+          continuationToken: googleOptions.continuationToken,
+        }),
       },
       warnings: [...warnings, ...toolWarnings],
       providerOptionsName,
@@ -395,21 +400,60 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
       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 parts and usage 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 continuedParts: ContentPartSchema[] = [];
+    let continuedUsageMetadata: GoogleGenerativeAIUsageMetadata | undefined;
+    const firstPromptTokenCount = response.usageMetadata?.promptTokenCount;
+
+    while (true) {
+      const candidate = response.candidates?.[0];
+      const continuationToken =
+        candidate?.finishReason === 'CONTINUATION'
+          ? candidate.continuationToken
+          : undefined;
+
+      if (continuationToken == null) {
+        break;
+      }
+
+      continuedParts.push(...(candidate?.content?.parts ?? []));
+      continuedUsageMetadata = addGoogleGenerativeAIUsageMetadata(
+        continuedUsageMetadata,
+        response.usageMetadata ?? undefined,
+      );
+
+      ({
+        responseHeaders,
+        value: response,
+        rawValue: rawResponse,
+      } = await generateContent({ ...args, continuationToken }));
+    }
 
     const candidate = response.candidates?.[0];
     const promptBlockReason = response.promptFeedback?.blockReason;
@@ -425,9 +469,12 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
     const content: Array<LanguageModelV3Content> = [];
 
     // map ordered parts to content:
-    const parts = candidate?.content?.parts ?? [];
+    const parts = [...continuedParts, ...(candidate?.content?.parts ?? [])];
 
-    const usageMetadata = response.usageMetadata;
+    const usageMetadata = addGoogleGenerativeAIUsageMetadata(
+      continuedUsageMetadata,
+      response.usageMetadata ?? undefined,
+    );
 
     // Associates code execution results with their preceding call.
     let lastCodeExecutionToolCallId: string | undefined;
@@ -600,6 +647,13 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
           usageMetadata: usageMetadata ?? null,
           finishMessage: candidate?.finishMessage ?? null,
           serviceTier: usageMetadata?.serviceTier ?? null,
+          ...(candidate?.continuationToken != null &&
+          rawFinishReason === 'MAX_TOKENS'
+            ? { continuationToken: candidate.continuationToken }
+            : {}),
+          ...(continuedUsageMetadata != null && firstPromptTokenCount != null
+            ? { initialPromptTokenCount: firstPromptTokenCount }
+            : {}),
         } satisfies GoogleGenerativeAIProviderMetadata,
       },
       request: { body: args },
@@ -624,16 +678,37 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
       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: LanguageModelV3FinishReason = {
@@ -641,11 +716,16 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
       raw: undefined,
     };
     let usage: GoogleGenerativeAIUsageMetadata | undefined = undefined;
+    // Usage of the completed requests of an automatically continued response.
+    let continuedUsage: GoogleGenerativeAIUsageMetadata | 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;
@@ -775,6 +855,9 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
               if (candidate.finishMessage != null) {
                 lastFinishMessage = candidate.finishMessage;
               }
+              if (candidate.continuationToken != null) {
+                lastContinuationToken = candidate.continuationToken;
+              }
             }
 
             // A confirmed prompt block is terminal for generated content, but
@@ -1162,6 +1245,19 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
               }
             }
 
+            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 = addGoogleGenerativeAIUsageMetadata(
+                continuedUsage,
+                usage,
+              );
+              usage = undefined;
+            }
+
             if (candidate.finishReason != null) {
               finishReason = {
                 unified: mapGoogleGenerativeAIFinishReason({
@@ -1174,6 +1270,8 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
           },
 
           flush(controller) {
+            usage = addGoogleGenerativeAIUsageMetadata(continuedUsage, usage);
+
             if (currentTextBlockId !== null) {
               controller.enqueue({
                 type: 'text-end',
@@ -1200,6 +1298,17 @@ export class GoogleGenerativeAILanguageModel implements LanguageModelV3 {
                   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 GoogleGenerativeAIProviderMetadata,
               },
             });
@@ -1571,6 +1680,7 @@ 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(),
@@ -1594,6 +1704,10 @@ type CandidateSchema = NonNullable<
 
 type ContentSchema = NonNullable<CandidateSchema['content']>;
 
+type ContentPartSchema = NonNullable<
+  Extract<ContentSchema, { parts?: unknown }>['parts']
+>[number];
+
 export type GroundingMetadataSchema = NonNullable<
   CandidateSchema['groundingMetadata']
 >;
@@ -1630,6 +1744,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-generative-ai-options.ts

@@ -35,6 +35,7 @@ export type GoogleGenerativeAIModelId =
   | '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
@@ -257,6 +258,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-generative-ai-prompt.ts

@@ -79,4 +79,22 @@ export interface GoogleGenerativeAIProviderMetadata {
   usageMetadata: GoogleGenerativeAIUsageMetadata | 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'