長解碼

Gemini 4 Argon 具備長解碼功能，可生成超過單一要求輸出限制的內容，用於深度推論工作，最多可達 100 萬個詞元的統一脈絡窗口 (輸入、思考和輸出共用 1,048,576 個詞元)。

只變更模型 ID 並不會啟用長解碼功能。如未進行額外設定，串流通話的輸出內容會在 64,000 個權杖處停止，非串流通話則會在 32,000 個權杖處停止。如要啟用長解碼功能，最快的方法是升級 Google GenAI SDK，並將 max_output_tokens 設為大於 65,536。本指南說明長解碼的運作方式、使用時機，以及如何透過 generateContent 啟用。

解碼作業時間

單一串流或 SDK 要求最多可產生 64,000 個權杖，非串流 REST 要求最多可產生 32,000 個權杖。如果回覆需要更多詞元，模型會透過多個要求和回覆躍點生成回覆，每個躍點都會從上一個躍點停止的位置繼續。

• 輸入和輸出詞元數量限制統一：輸入、思考、函式呼叫和最終回覆共用 100 萬個詞元的視窗。輸出內容最多可使用 1,048,576 個詞元，扣除輸入內容的詞元數。
• 每個躍點的上限：一個躍點最多可傳回 65,536 個輸出權杖。非串流 REST 要求最多可傳回 32,768 個詞元。
• 接續信號：如果模型達到上限且仍有詞元，回應會以 finish_reason: CONTINUATION 和 continuation_token 結尾。
• 下一個躍點：用戶端會再次傳送相同要求，並附上權杖。模型會從停止處繼續訓練。
• 所有躍點的總數： max_output_tokens 會一併設定所有躍點的思考和輸出權杖總數。
• 停止信號：模型用完所有 max_output_tokens 後，回覆會以 finish_reason: MAX_TOKENS 結尾。

遇到困難問題時，躍點可能會將所有權杖用於內部思考，並傳回空白文字和 continuation_token。這是正常現象，最終答案會在後續躍點中傳送。

預設輸出內容限制

如果沒有長時間解碼，單一要求會受到下列限制：

• 透過 Google GenAI SDK (generate_content) 傳送串流和非串流要求：預設為 64K 輸出詞元。
• 直接非串流 REST 呼叫 (generateContent)：預設為 32K 個輸出詞元。在非串流 REST 呼叫中，如果將 max_output_tokens 設為大於 32,768，且未設定 continuation_token，系統會傳回 400 錯誤。

使用長解碼的時機

大多數要求會在單一要求限制內完成 (串流和 SDK 呼叫為 64K 個詞元，非串流 REST 呼叫為 32K 個詞元)。如果回覆所需的思考和輸出詞元總數超過單一要求允許的數量，請使用長解碼。提高 max_output_tokens 可讓模型有更多空間推論困難問題，而不是讓標準答案變長。

設定較高的 max_output_tokens 可讓模型有更多時間思考難題，但模型仍會決定要撰寫多少內容。如要控制模型使用的推論資源量，請設定 thinking_level。

開啟長解碼

您可以使用 Google GenAI SDK 自動執行長解碼 (選項 1，建議大多數應用程式採用)，或自行編寫接續迴圈 (選項 2)。這兩種選項都支援完整的 100 萬個詞元脈絡窗口。

加密的 continuation_token 會在要求之間傳遞模型狀態，因此伺服器不會儲存任何內容。

方法 1：使用 Google GenAI SDK (建議)

在最新版 Google GenAI SDK 中，automatic_continuation 預設為啟用，適用於串流和非串流呼叫，因此您不需設定。如果將 max_output_tokens 設為高於每個要求的上限，SDK 會自動執行接續跳轉，並傳回一個合併的回覆。

1. 升級 SDK。

   Python

   pip install -U "google-genai>=2.30.1"
   

   JavaScript

   npm install "@google/genai@>=2.29.1"
   

2. 將 max_output_tokens 設為大於 65,536。

   Python

   from google import genai
   from google.genai import types
   
   client = genai.Client()  # Reads GEMINI_API_KEY
   
   response = client.models.generate_content(
       model="gemini-4-argon",
       contents="Write a complete, rigorous proof of the prime number theorem.",
       config=types.GenerateContentConfig(
           max_output_tokens=262_144,  # Total thinking and output for all hops
           thinking_config=types.ThinkingConfig(thinking_level="high"),
           automatic_continuation=True,  # Default. Shown for clarity.
       ),
   )
   
   print(response.text)
   print("Finish reason:", response.candidates[0].finish_reason)
   print("Prompt size:", response.usage_metadata.initial_prompt_token_count)
   print("Billed tokens:", response.usage_metadata.total_token_count)
   

   JavaScript

   import { GoogleGenAI, ThinkingLevel } from "@google/genai";
   
   const ai = new GoogleGenAI({}); // Reads GEMINI_API_KEY
   
   const response = await ai.models.generateContent({
     model: "gemini-4-argon",
     contents: "Write a complete, rigorous proof of the prime number theorem.",
     config: {
       maxOutputTokens: 262144, // Total thinking and output for all hops
       thinkingConfig: { thinkingLevel: ThinkingLevel.HIGH },
       automaticContinuation: true, // Default. Shown for clarity.
     },
   });
   
   console.log(response.text);
   console.log("Finish reason:", response.candidates?.[0]?.finishReason);
   console.log("Prompt size:", response.usageMetadata?.initialPromptTokenCount);
   console.log("Billed tokens:", response.usageMetadata?.totalTokenCount);
   

請注意以下幾點：

• 串流： generate_content_stream (Python) 和 generateContentStream (JavaScript) 也會繼續為您服務。如果串流在檢查點後中斷，SDK 會從該檢查點繼續。
• 逾時：逾時和重試適用於每個躍點，而非完整執行。
• 手動控制：如要自行執行迴圈，請設定 automatic_continuation=False (Python) 或 automaticContinuation: false (JavaScript)。然後按照選項 2 的步驟操作。
• 用量：用量欄位會顯示所有躍點的總和。如要取得提示的大小，請讀取 initial_prompt_token_count。請參閱「計算詞元數」。

選項 2：自行編寫迴圈

如果您直接呼叫 REST、使用沒有最新 SDK 的語言，或需要完整控制權，請自行編寫迴圈。您也可以參考 Python 和 JavaScript/TypeScript 的 Google GenAI SDK 實作。

請遵守下列規則：

1. 在每個躍點上傳送相同要求。請傳送原始 contents、system_instruction、tools 和 generation_config。維持 max_output_tokens 不變。
2. 請勿將部分輸出內容新增至 contents。continuation_token 會攜帶模型的狀態，包括思考過程。
3. 只傳送最新的權杖。每個權杖都包含先前的所有進度。
4. 當 finish_reason 為 CONTINUATION 時繼續。因其他原因而停止。
5. 將最後一個躍點後的部分合併。將所有躍點的部分合併為對話記錄的一個模型回合。

from google import genai
from google.genai import types

client = genai.Client()  # Reads GEMINI_API_KEY
PROMPT = "Write a complete, rigorous proof of the prime number theorem."
parts = []
token = None

while True:
    response = client.models.generate_content(
        model="gemini-4-argon",
        contents=PROMPT,  # The original contents on every request
        config=types.GenerateContentConfig(
            max_output_tokens=262_144,  # The same total on every request
            thinking_config=types.ThinkingConfig(thinking_level="high"),
            automatic_continuation=False,  # You run the loop
            continuation_token=token,
        ),
    )
    candidate = response.candidates[0]
    if candidate.content and candidate.content.parts:
        parts.extend(candidate.content.parts)
    token = candidate.continuation_token
    if candidate.finish_reason != types.FinishReason.CONTINUATION or not token:
        break

print("".join(p.text for p in parts if p.text and not p.thought))
print("Finish reason:", candidate.finish_reason)

import { GoogleGenAI, ThinkingLevel } from "@google/genai";

const ai = new GoogleGenAI({}); // Reads GEMINI_API_KEY
const PROMPT = "Write a complete, rigorous proof of the prime number theorem.";
const parts = [];
let token = undefined;
let candidate = undefined;

while (true) {
  const response = await ai.models.generateContent({
    model: "gemini-4-argon",
    contents: PROMPT, // The original contents on every request
    config: {
      maxOutputTokens: 262144, // The same total on every request
      thinkingConfig: { thinkingLevel: ThinkingLevel.HIGH },
      automaticContinuation: false, // You run the loop
      continuationToken: token,
    },
  });
  candidate = response.candidates?.[0];
  if (candidate?.content?.parts) {
    parts.push(...candidate.content.parts);
  }
  token = candidate?.continuationToken;
  if (candidate?.finishReason !== "CONTINUATION" || !token) {
    break;
  }
}

console.log(parts.filter((p) => p.text && !p.thought).map((p) => p.text).join(""));
console.log("Finish reason:", candidate?.finishReason);

# Hop 1: send the request with max_output_tokens.
curl -s "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-argon:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "Write a complete, rigorous proof of the prime number theorem."}]}],
    "generationConfig": {
      "maxOutputTokens": 262144,
      "thinkingConfig": {"thinkingLevel": "high"}
    }
  }'

# Hop 2: if finishReason is CONTINUATION, send the same request plus the token.
curl -s "https://generativelanguage.googleapis.com/v1beta/models/gemini-4-argon:generateContent" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [{"role": "user", "parts": [{"text": "Write a complete, rigorous proof of the prime number theorem."}]}],
    "generationConfig": {
      "maxOutputTokens": 262144,
      "thinkingConfig": {"thinkingLevel": "high"}
    },
    "continuationToken": "TOKEN_FROM_HOP_1"
  }'

如果某個躍點完全用於思考，則會傳回空白的 text，並附上 finishReason: "CONTINUATION"。將此視為正常進度，並要求下一個躍點：

{
  "candidates": [{
    "content": {"role": "model", "parts": [{"text": ""}]},
    "finishReason": "CONTINUATION",
    "continuationToken": "CiQ4ZmQ3..."
  }],
  "usageMetadata": {
    "promptTokenCount": 142,
    "candidatesTokenCount": 0,
    "thoughtsTokenCount": 32768,
    "totalTokenCount": 32910
  }
}

串流迴圈還需要一項規則。超過 32,768 個詞元後，串流每 5,000 個詞元會傳送一個檢查點詞元。將新區塊保留在待處理清單中。如果區塊含有 continuation_token，請將待處理的區塊移至已提交的輸出內容，並儲存權杖。如果串流中斷，請捨棄待處理的區塊，並從最後一個權杖繼續。如果串流在第一個檢查點之前中斷，請再次傳送原始要求。

設定max_output_tokens

max_output_tokens 會設定所有躍點的思考和輸出合併限制。調低這個值不會讓模型生成更簡潔的回覆，而是會提早截斷回覆。

如要減少權杖用量，請調低 thinking_level。使用 high 處理最困難的推論工作。對於大多數程式設計和代理工作，請使用 medium (預設)。使用 low 處理較不複雜的工作。

處理長時間執行的要求

Gemini 4 Argon 思考困難問題的時間比 Gemini 3.x 模型長，因此請增加用戶端逾時時間，以免長時間要求提早中斷連線。

• 非串流呼叫：伺服器會在 10 分鐘後關閉連線。
• 串流通話：伺服器會在 20 分鐘後關閉串流。
• 用戶端逾時：將 HTTP 讀取逾時設為 20 分鐘。3 分鐘或 5 分鐘的逾時時間會提早停止要求。

在 Python 中，以毫秒為單位設定用戶端的逾時時間：

client = genai.Client(http_options=types.HttpOptions(timeout=1_200_000))  # 20 minutes

對於用戶端輪詢的作業，Interactions API 會在伺服器上執行長時間解碼。請參閱背景執行。

模型用完所有輸出權杖時繼續

如果回應以 MAX_TOKENS 結尾，仍會包含 continuation_token。您有以下兩種選擇：

• 繼續：使用權杖和較高的 max_output_tokens 傳送相同要求。值必須高於目前使用的權杖數量。否則，API 會傳回 400 錯誤。
• 重新開始：傳送原始要求，並提高 max_output_tokens，且不含權杖。您必須支付兩次執行的費用。

計算詞元數

有了自動接續功能，usage_metadata 會回報所有躍點的總計。SDK 會加總各個計數欄位：prompt_token_count、cached_content_token_count、candidates_token_count、thoughts_token_count 和 total_token_count。

prompt_token_count 會加總每個躍點的輸入權杖。每次跳轉時，系統都會將提示詞和截至當時已生成的內容，一併傳回模型做為輸入內容，因此後續每次跳轉都會重複計算相同的詞元。舉例來說，如果使用 Google GenAI SDK，1,000 個權杖的提示會產生 200,000 個權杖的思考和輸出內容，需要四個躍點：

prompt_token_count 回報約 397,000 個詞元 (重複的 hop 輸入內容會透過隱含快取自動折抵 95%)，total_token_count 則回報約 597,000 個詞元，即使實際的脈絡大小只有約 201,000 個詞元：1,000 個詞元的提示，加上 200,000 個詞元的思考和輸出內容。非串流 REST 迴圈會使用 32K 跳轉，因此相同輸出內容需要七次跳轉，並回報 695,128 個輸入權杖。

prompt_token_count 和 total_token_count 是每個躍點的總和，而非環境的大小。請勿使用這些屬性決定何時摘要或修剪對話記錄 (脈絡壓縮)，或強制執行脈絡限制。如要預估脈絡大小，請將表格中的提示大小加到 candidates_token_count 和 thoughts_token_count。

執行長解碼前，請先更新代理架構、評估工具或 Proxy：

• 代理程式和評估工具：如果程式碼會壓縮內容或在達到權杖限制時停止執行，請使用 initial_prompt_token_count (或 REST 中的第一個躍點 prompt_token_count)，而非加總的 prompt_token_count。如果回應在單一躍點中完成，這兩個欄位會回報相同的值，因此短期測試不會顯示問題。
• 呼叫 REST 的 Proxy 和閘道：每個 REST 回應只會回報自己的躍點。將各躍點的欄位加總，即可算出成本，並保留第一個躍點的 promptTokenCount 做為提示大小。否則，使用者看到的數字會與 SDK 使用者看到的不同。
• 記錄和序列化回應：SDK 會在用戶端計算 initial_prompt_token_count。不會出現在 REST 回應或 SDK 的 JSON 輸出內容中，例如 model_dump()。如果日後需要，請將其儲存為獨立值。

如果您在自己的迴圈中串流，usage_metadata 會在每個串流中累積。只保留每個資料串流的最後一個值，然後將各個躍點的值加總。

瞭解計費方式

您需要為每個躍點中的每個詞元付費，包括僅含思考過程的躍點。

• 快取折扣：隱含快取會在每個躍點中，將重複輸入的內容折扣 95%。新用戶優惠期間，快取輸入內容的費用為每 100 萬個詞元 $0.10 美元，而非 $2.00 美元。
• 快取失效：快取會在閒置 15 到 20 分鐘後失效。如果兩次跳轉之間間隔太久，系統會再次收取完整輸入費率。
• 失敗的非串流躍點：只有在回覆完成時，系統才會向您收費。失敗或捨棄的要求費用為 $0 美元。
• 中斷的串流：如果串流在 32,000 個權杖前中斷，費用為 $0 美元。之後，您只需支付到最後一個檢查點權杖的費用，因為您可以從該處繼續。

疑難排解

限制

• OpenAI 相容性端點：不支援長解碼。輸出內容達到單次要求上限時，就會停止。
• 舊版 SDK：如果版本低於附註中的最低版本，系統不會自動繼續。
• 長度：模型不會遵循詞元長度或字數目標。

檢查清單

• 將 Google GenAI SDK 升級至最低版本。
• 將 max_output_tokens 設為大於 65,536。
• 請使用 thinking_level (low、medium 或 high)，而非 thinking_budget。
• 將 HTTP 讀取逾時時間設為 20 分鐘。
• 使用 initial_prompt_token_count 取得內容大小和壓縮資訊。
• 先執行一個提示詞做為測試，再進行大規模評估。

後續步驟

• Gemini 4 Argon 最新消息
• 思考
• 詞元計數