@ai-sdk/google 4.0.94 → 4.0.95

package/docs/15-google.mdx

@@ -253,6 +253,12 @@ The following optional provider options are available for Google models:
   [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`.
@@ -318,6 +324,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.finalStep.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.finalStep.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 provider supports file inputs, e.g. PDF files.
@@ -1059,6 +1195,7 @@ will still validate the response against the schema in `Output.object`.
 | Model                                 | Image Input | Object Generation | Tool Usage | Tool Streaming | Google Search | URL Context |
 | ------------------------------------- | ----------- | ----------------- | ---------- | -------------- | ------------- | ----------- |
 | `gemini-nano-banana-2.1`              | <Check />   | <Cross />         | <Cross />  | <Cross />      | <Check />     | <Cross />   |
+| `gemini-4-argon`                      | <Check />   | <Check />         | <Check />  | <Check />      | <Check />     | <Check />   |
 | `gemini-3.8-flash`                    | <Check />   | <Check />         | <Check />  | <Check />      | <Check />     | <Check />   |
 | `gemini-3.7-flash`                    | <Check />   | <Check />         | <Check />  | <Check />      | <Check />     | <Check />   |
 | `gemini-3.6-flash`                    | <Check />   | <Check />         | <Check />  | <Check />      | <Check />     | <Check />   |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/google",
-  "version": "4.0.94",
+  "version": "4.0.95",
   "type": "module",
   "license": "Apache-2.0",
   "sideEffects": false,

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-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'