Lange Decodierung

Mit der Funktion „Long Decode“ kann Gemini 4 Argon bei Deep-Reasoning-Aufgaben über das Ausgabelimit für einzelne Anfragen hinaus generieren – bis zum einheitlichen Kontextfenster von 1 Million Tokens (1.048.576 Tokens, die auf Eingabe, Denkprozess und Ausgabe aufgeteilt werden).

Wenn Sie nur die Modell-ID ändern, wird die lange Decodierung nicht aktiviert. Ohne zusätzliche Einrichtung wird die Ausgabe bei 64.000 Tokens für Streamingaufrufe und 32.000 Tokens für Nicht-Streamingaufrufe beendet. Am schnellsten lässt sich die lange Dekodierung aktivieren,indem Sie das Google GenAI SDK aktualisieren und max_output_tokens auf einen Wert über 65.536 festlegen. In diesem Leitfaden wird erläutert, wie lange die Dekodierung funktioniert, wann Sie sie verwenden sollten und wie Sie sie mit generateContent aktivieren.

Wie lange die Decodierung funktioniert

Bei einer einzelnen Streaming- oder SDK-Anfrage werden bis zu 64.000 Tokens generiert, bei einer Nicht-Streaming-REST-Anfrage bis zu 32.000 Tokens. Wenn für eine Antwort mehr Tokens erforderlich sind, wird sie in mehreren Anfrage-Antwort-Schleifen generiert, die jeweils dort fortgesetzt werden, wo die vorherige Schleife aufgehört hat.

• Einheitliches Tokenlimit für Eingabe und Ausgabe: Eingabe, Thinking, Funktionsaufrufe und die endgültige Antwort teilen sich ein Fenster mit 1 Million Tokens. Die Ausgabe kann bis zu 1.048.576 Tokens minus Ihre Eingabetokens umfassen.
• Obergrenze für jeden Hop: Ein Hop gibt bis zu 65.536 Ausgabetokens zurück. REST-Anfragen ohne Streaming geben bis zu 32.768 Tokens zurück.
• Ein Fortsetzungssignal: Wenn das Modell die Obergrenze erreicht und noch Tokens übrig hat, endet die Antwort mit finish_reason: CONTINUATION und einem continuation_token.
• Der nächste Hop: Der Client sendet dieselbe Anfrage noch einmal mit dem Token. Das Modell fährt dort fort, wo es aufgehört hat.
• Ein Gesamtwert für alle Hops:Mit max_output_tokens werden die Thinking- und Ausgabetokens für alle Hops zusammen festgelegt.
• Stoppsignal:Wenn das Modell alle max_output_tokens verwendet hat, endet die Antwort mit finish_reason: MAX_TOKENS.

Bei schwierigen Problemen kann ein Hop alle seine Tokens für interne Überlegungen ausgeben und leeren Text mit einem continuation_token zurückgeben. Das ist normal. Die endgültige Antwort wird in späteren Hops geliefert.

Standardmäßige Ausgabelimits

Ohne lange Decodierung wird eine einzelne Anfrage bei den folgenden Limits pro Anfrage gestoppt:

• Streaming-Anfragen und Nicht-Streaming-Anfragen über das Google GenAI SDK (generate_content): Standardmäßig 64.000 Ausgabetokens.
• Direkte REST-Aufrufe ohne Streaming (generateContent): Standardmäßig 32.000 Ausgabetokens. Wenn Sie max_output_tokens bei einem REST-Aufruf ohne Streaming und ohne continuation_token auf einen Wert größer als 32.768 festlegen,wird der Fehler 400 zurückgegeben.

Wann sollte die lange Decodierung verwendet werden?

Die meisten Anfragen werden innerhalb des Limits für einzelne Anfragen abgeschlossen (64.000 Tokens für Streaming- und SDK-Aufrufe oder 32.000 Tokens für Nicht-Streaming-REST-Aufrufe). Verwenden Sie „long decode“, wenn für eine Antwort mehr kombinierte Thinking- und Output-Tokens erforderlich sind, als in einer einzelnen Anfrage zulässig sind. Wenn Sie max_output_tokens erhöhen, hat das Modell mehr Spielraum, um schwierige Probleme zu lösen, anstatt Standardantworten zu verlängern.

Wenn Sie einen hohen Wert für max_output_tokens festlegen, hat das Modell mehr Zeit, um über schwierige Probleme nachzudenken. Das Modell entscheidet jedoch weiterhin, wie viel es schreibt. Mit thinking_level können Sie festlegen, wie viel Aufwand das Modell für die Schlussfolgerungen verwendet.

Langes Decodieren aktivieren

Sie können die lange Decodierung automatisch mit dem Google GenAI SDK ausführen (Option 1, für die meisten Anwendungen empfohlen) oder eine eigene Fortsetzungsschleife schreiben (Option 2). Beide Optionen unterstützen das vollständige Kontextfenster mit 1 Million Tokens.

Der verschlüsselte continuation_token enthält den Status des Modells zwischen Anfragen, sodass nichts auf dem Server gespeichert wird.

Option 1: Google GenAI SDK verwenden (empfohlen)

Im neuesten Google GenAI SDK ist automatic_continuation standardmäßig sowohl für Streaming- als auch für Nicht-Streaming-Aufrufe aktiviert. Sie müssen es also nicht festlegen. Wenn Sie max_output_tokens über dem Limit pro Anfrage festlegen, führt das SDK automatisch die Fortsetzungssprünge aus und gibt eine kombinierte Antwort zurück.

1. SDK aktualisieren

   Python

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

   JavaScript

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

2. Setzen Sie max_output_tokens auf einen Wert über 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);
   

Folgendes solltest du beachten:

• Streaming: generate_content_stream (Python) und generateContentStream (JavaScript) werden ebenfalls fortgesetzt. Wenn ein Stream nach einem Prüfpunkt abbricht, setzt das SDK die Wiedergabe ab diesem Prüfpunkt fort.
• Timeouts:Timeouts und Wiederholungsversuche gelten für jeden Hop, nicht für den gesamten Lauf.
• Manuelle Steuerung: Wenn Sie die Schleife selbst ausführen möchten, legen Sie automatic_continuation=False (Python) oder automaticContinuation: false (JavaScript) fest. Folgen Sie dann Option 2.
• Verwendung:In den Verwendungsfeldern wird die Summe aller Hops angezeigt. Die Größe Ihres Prompts finden Sie unter initial_prompt_token_count. Siehe Tokens zählen.

Option 2: Eigenen Loop schreiben

Schreiben Sie Ihren eigenen Loop, wenn Sie REST direkt aufrufen, eine Sprache ohne das neueste SDK verwenden oder die vollständige Kontrolle benötigen. Sie können sich auch unsere Google GenAI SDK-Implementierungen in Python und JavaScript/TypeScript ansehen.

Gehen Sie dabei so vor:

1. Senden Sie bei jedem Hop dieselbe Anfrage. Sende die ursprünglichen contents, system_instruction, tools und generation_config. Behalten Sie max_output_tokens bei.
2. Fügen Sie contents keine Teilausgabe hinzu. Der continuation_token enthält den Status des Modells, einschließlich seiner Denkprozesse.
3. Nur das letzte Token senden. Jedes Token enthält alle bisherigen Fortschritte.
4. Fahre fort, während finish_reason CONTINUATION ist. Beenden Sie die Ausführung bei einem anderen Beendigungsgrund.
5. Fügen Sie die Teile nach dem letzten Hop zusammen. Kombinieren Sie die Teile aus allen Hops in einem Modelllauf für den Unterhaltungsverlauf.

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

Ein Hop, der ausschließlich für das Nachdenken verwendet wird, gibt ein leeres text mit finishReason: "CONTINUATION" zurück. Behandle dies als normalen Fortschritt und fordere den nächsten Hop an:

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

Für Streaming-Loops ist eine weitere Regel erforderlich. Nach den ersten 32.768 Tokens sendet der Stream alle 5.000 Tokens ein Prüfpunkt-Token. Neue Chunks in einer ausstehenden Liste behalten Wenn ein Block einen continuation_token hat, verschieben Sie die ausstehenden Blöcke in die übernommene Ausgabe und speichern Sie das Token. Wenn der Stream unterbrochen wird, verwerfen Sie die ausstehenden Chunks und setzen Sie die Verarbeitung mit dem letzten Token fort. Wenn der Stream vor dem ersten Checkpoint unterbrochen wird, senden Sie die ursprüngliche Anfrage noch einmal.

max_output_tokens festlegen

max_output_tokens legt das kombinierte Limit für Denken und Ausgabe über alle Hops hinweg fest. Wenn Sie den Wert senken, denkt das Modell nicht präziser, sondern die Antwort wird früher abgeschnitten.

Wenn Sie weniger Tokens verwenden möchten, verringern Sie thinking_level. Verwenden Sie high für die schwierigsten Schlussfolgerungsaufgaben. Verwenden Sie medium (Standard) für die meisten Programmier- und Agentenaufgaben. Verwenden Sie low für weniger komplexe Aufgaben.

Anfragen mit langer Ausführungszeit verarbeiten

Da Gemini 4 Argon bei schwierigen Problemen länger nachdenkt als Gemini 3.x-Modelle, sollten Sie die Client-Timeouts verlängern, damit lange Anfragen nicht vorzeitig getrennt werden.

• Nicht streamende Anrufe:Der Server schließt die Verbindung nach 10 Minuten.
• Streamingaufrufe: Der Server schließt den Stream nach 20 Minuten.
• Client-Timeouts:Legen Sie das HTTP-Lese-Timeout auf 20 Minuten fest. Ein Zeitlimit von 3 oder 5 Minuten beendet die Anfrage vorzeitig.

Legen Sie in Python das Zeitlimit für den Client in Millisekunden fest:

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

Bei Jobs, die von Ihrem Client abgefragt werden, wird die lange Dekodierung der Interactions API auf dem Server ausgeführt. Weitere Informationen finden Sie unter Ausführung im Hintergrund.

Fortsetzen, wenn das Modell alle Ausgabetokens verwendet

Wenn eine Antwort mit MAX_TOKENS endet, enthält sie trotzdem ein continuation_token. Sie haben zwei Möglichkeiten:

• Fortfahren: Senden Sie dieselbe Anfrage mit dem Token und einem höheren max_output_tokens. Der Wert muss über den bisher verwendeten Tokens liegen. Andernfalls gibt die API den Fehler 400 zurück.
• Noch einmal beginnen: Senden Sie die ursprüngliche Anfrage mit einem höheren max_output_tokens und ohne Token. Sie zahlen für beide Läufe.

Tokens zählen

Bei der automatischen Fortsetzung werden in usage_metadata die Gesamtsummen für alle Hops erfasst. Das SDK addiert alle Zählfelder: prompt_token_count, cached_content_token_count, candidates_token_count, thoughts_token_count und total_token_count.

prompt_token_count summiert die Eingabetokens jedes Hops. Bei jedem Hop werden Ihr Prompt und alles, was bisher generiert wurde, als Eingabe an das Modell zurückgesendet. Daher werden dieselben Tokens bei jedem späteren Hop noch einmal gezählt. Beispiel: Mit dem Google GenAI SDK dauert ein Prompt mit 1.000 Tokens, der 200.000 Tokens für Denkprozesse und Ausgabe erzeugt, vier Hops:

prompt_token_count meldet etwa 397.000 Tokens (wobei wiederholte Hop-Eingaben durch implizites Caching automatisch um 95% reduziert werden) und total_token_count meldet etwa 597.000 Tokens, obwohl die tatsächliche Kontextgröße nur etwa 201.000 Tokens beträgt: der Prompt mit 1.000 Tokens plus 200.000 Tokens für Denkprozess und Ausgabe. Eine REST-Schleife ohne Streaming verwendet 32.000 Hops. Es dauert also sieben Hops, bis dieselbe Ausgabe generiert wird,und es werden 695.128 Eingabetokens gemeldet.

prompt_token_count und total_token_count sind die Summe aller Hops, nicht die Größe Ihres Kontexts. Verwenden Sie sie nicht, um zu entscheiden, wann der Unterhaltungsverlauf zusammengefasst oder gekürzt werden soll (Kontextkomprimierung), oder um ein Kontextlimit zu erzwingen. Wenn Sie die Kontextgröße schätzen möchten, addieren Sie die Prompt-Größe aus der Tabelle zu candidates_token_count und thoughts_token_count.

Aktualisieren Sie Ihr Agenten-Framework, Ihr Bewertungstool oder Ihren Proxy, bevor Sie die lange Decodierung ausführen:

• Agenten und Bewertungstools: Wenn Ihr Code den Kontext komprimiert oder eine Ausführung bei einem Tokenlimit beendet, verwenden Sie initial_prompt_token_count (oder prompt_token_count des ersten Hops in REST) anstelle der summierten prompt_token_count. Bei Antworten, die in einem Hop abgeschlossen werden, wird in beiden Feldern derselbe Wert gemeldet. Bei kurzen Tests tritt das Problem also nicht auf.
• Proxys und Gateways, die REST aufrufen: Jede REST-Antwort meldet nur den eigenen Hop. Addieren Sie die Kosten für jedes Feld über die Hops hinweg und behalten Sie die promptTokenCount des ersten Hops als Prompt-Größe bei. Andernfalls sehen Ihre Nutzer andere Zahlen als SDK-Nutzer für dieselbe Anfrage.
• Logs und serialisierte Antworten:Das SDK berechnet initial_prompt_token_count auf dem Client. Sie ist nicht in der REST-Antwort oder in der JSON-Ausgabe des SDK enthalten, z. B. model_dump(). Speichern Sie ihn als separaten Wert, wenn Sie ihn später benötigen.

Wenn Sie in Ihrer eigenen Schleife streamen, ist usage_metadata innerhalb jedes Streams kumulativ. Nur den letzten Wert jedes Streams beibehalten und dann die Werte über Hops hinweg addieren.

Informationen zur Abrechnung

Sie bezahlen für jedes Token in jedem Hop, auch für Hops, die nur Überlegungen enthalten.

• Cache-Rabatt: Durch implizites Caching wird die wiederholte Eingabe in jedem Hop um 95 % reduziert. Während des Einführungszeitraums kosten zwischengespeicherte Eingaben 0,10 $ pro Million Tokens statt 2,00 $.
• Cache-Ablauf:Der Cache läuft nach 15 bis 20 Minuten ohne Nutzung ab. Bei einer langen Pause zwischen den Hops wird die volle Eingaberate wieder berechnet.
• Fehlgeschlagene Nicht-Streaming-Hops: Sie zahlen nur, wenn eine Antwort abgeschlossen ist. Eine fehlgeschlagene oder abgebrochene Anfrage kostet 0 $.
• Abgebrochene Streams:Ein Stream, der vor 32.000 Tokens abgebrochen wird, kostet 0 $. Danach bezahlen Sie bis zum letzten Checkpoint-Token, da Sie dort weitermachen können.

Fehlerbehebung

Beschränkungen

• OpenAI-Kompatibilitätsendpunkt: Long Decode ist nicht verfügbar. Die Ausgabe wird bei der Obergrenze pro Anfrage beendet.
• Ältere SDKs:Versionen unter den Mindestanforderungen in der Notiz werden nicht automatisch fortgesetzt.
• Länge: Das Modell hält sich nicht an die Vorgaben für die Tokenlänge oder Wortanzahl.

Checkliste

• Aktualisieren Sie das Google GenAI SDK auf die Mindestversion.
• Setzen Sie max_output_tokens auf einen Wert über 65.536.
• Verwenden Sie thinking_level (low, medium oder high) und nicht thinking_budget.
• Legen Sie für HTTP-Lesezeitüberschreitungen 20 Minuten fest.
• Verwenden Sie initial_prompt_token_count für Kontextgröße und Komprimierung.
• Führen Sie einen Prompt als Test vor einer großen Auswertung aus.

Nächste Schritte

• Das ist neu bei Gemini 4 Argon
• Antwort wird generiert
• Token zählen