Długie dekodowanie

Długie dekodowanie umożliwia modelowi Gemini 4 Argon generowanie ponad 64 tys. tokenów na potrzeby złożonych zadań związanych z wnioskowaniem, aż do ujednoliconego okna kontekstu z milionem tokenów (1 048 576 tokenów współdzielonych między danymi wejściowymi, wnioskowaniem i danymi wyjściowymi). W przypadku interfejsu Interactions API włączasz długie dekodowanie z wykonywaniem w tle, dzięki czemu nasze serwery automatycznie generują i łączą każdy przeskok o długości 64 tys. tokenów w jedną interakcję.

Jak działa długie dekodowanie

Pojedyncze wywołanie modelu generuje do 64 tys. tokenów. Gdy odpowiedź wymaga więcej niż 64 tys. tokenów, serwer generuje ją w przeskokach o długości 64 tys. tokenów, które są kontynuowane od miejsca, w którym zatrzymał się poprzedni przeskok. Każdy przeskok dodaje krok model_output do interaction.steps w ramach tego samego identyfikatora interakcji, dzięki czemu możesz połączyć te kroki, aby odczytać pełną odpowiedź:

1. Tworzysz interakcję z parametrami background: true i max_output_tokens o wartości większej niż 65 536, aż do 1 mln.
2. Serwer generuje pierwszy przeskok o długości do 64 tys. tokenów.
3. Serwer rozpoczyna następny przeskok od miejsca, w którym zatrzymał się poprzedni, i powtarza ten proces, aż model zakończy działanie lub wykorzysta wszystkie tokeny max_output_tokens.
4. Aby uzyskać wynik, odpytujesz interakcję lub przesyłasz ją strumieniowo.

import time
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Write a complete, rigorous proof of the prime number theorem.",
    background=True,
    generation_config={
        "max_output_tokens": 262144,
        "thinking_level": "high",
    },
)

while interaction.status in ("in_progress", "queued"):
    time.sleep(5)
    interaction = client.interactions.get(id=interaction.id)

# Each hop adds a model_output step, so join the text of all of them.
text = "".join(
    content.text
    for step in interaction.steps
    if step.type == "model_output"
    for content in step.content
    if content.type == "text"
)
print(text)
print("Status:", interaction.status)
print("Usage:", interaction.usage)

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

const client = new GoogleGenAI({});

let interaction = await client.interactions.create({
  model: "gemini-4-argon",
  input: "Write a complete, rigorous proof of the prime number theorem.",
  background: true,
  generation_config: {
    max_output_tokens: 262144,
    thinking_level: "high",
  },
});

while (interaction.status === "in_progress" || interaction.status === "queued") {
  await new Promise((resolve) => setTimeout(resolve, 5000));
  interaction = await client.interactions.get(interaction.id);
}

// Each hop adds a model_output step, so join the text of all of them.
const text = interaction.steps
  .filter((step) => step.type === "model_output")
  .flatMap((step) => step.content ?? [])
  .filter((content) => content.type === "text")
  .map((content) => content.text)
  .join("");
console.log(text);
console.log("Status:", interaction.status);
console.log("Usage:", interaction.usage);

# 1. Create the background interaction. It returns an ID right away.
ID=$(curl -s -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-4-argon",
    "input": "Write a complete, rigorous proof of the prime number theorem.",
    "background": true,
    "generation_config": {"max_output_tokens": 262144, "thinking_level": "high"}
  }' | jq -r '.id')

# 2. Poll until the status is no longer in_progress or queued.
#    The REST response has no output_text field, so join the text of every model_output step.
while true; do
  RESP=$(curl -s "https://generativelanguage.googleapis.com/v1beta/interactions/$ID" \
    -H "x-goog-api-key: $GEMINI_API_KEY")
  STATUS=$(echo "$RESP" | jq -r '.status')
  if [[ "$STATUS" != "in_progress" && "$STATUS" != "queued" ]]; then
    echo "$RESP" | jq -r '[.steps[]? | select(.type == "model_output") | .content[]? | select(.type == "text") | .text] | join("")'
    echo "$RESP" | jq '{status, usage}'
    break
  fi
  sleep 5
done

Limity danych wyjściowych

Interakcje strumieniowe i niestrumieniowe domyślnie mają limit 64 tys. tokenów wyjściowych, więc odpowiedzi o długości do 64 tys. tokenów nie wymagają zmian w kodzie. Aby wygenerować więcej niż 64 tys. tokenów, włącz wykonywanie w tle i zwiększ wartość max_output_tokens.

Kiedy używać długiego dekodowania

Większość żądań kończy się w ciągu 64 tys. tokenów. Długiego dekodowania używaj tylko wtedy, gdy jedna odpowiedź wymaga więcej wnioskowania i danych wyjściowych.

Ustawienie wysokiej wartości max_output_tokens daje modelowi więcej czasu na wnioskowanie w przypadku trudnych problemów, ale model nadal decyduje, ile ma napisać. Aby kontrolować, ile wysiłku model poświęca na wnioskowanie, ustaw thinking_level.

Wybierz sposób uruchamiania długiego dekodowania

Wykonywanie w tle to najłatwiejszy sposób na uruchomienie długiego dekodowania w interfejsie Interactions API. Kontynuacja po stronie klienta, w której kod rozpoczyna każdy przeskok, jest dostępna w interfejsie GenerateContent API. Już wkrótce będzie dostępna w interfejsie Interactions API jako bardziej zaawansowana opcja zarządzania odpornością.

Aby użyć kontynuacji po stronie klienta, zapoznaj się z artykułem Długie dekodowanie za pomocą interfejsu GenerateContent API.

Przesyłanie strumieniowe długiego dekodowania

Aby przesyłać strumieniowo dane wyjściowe i podsumowania wnioskowania w miarę ich otrzymywania, dodaj stream: true i thinking_summaries: "auto". Długie strumienie mogą się rozłączać, więc klient musi się ponownie połączyć. Postępuj zgodnie ze wzorcem ponownego łączenia w przewodniku po wykonywaniu w tle. Długie dekodowanie dodaje te reguły:

• Zapisz identyfikator interakcji: odczytaj go z wydarzenia interaction.created.
• Zapisz każdy event_id: event_id może pojawić się w wydarzeniach interaction.status_update, a nie tylko w deltach tekstu.
• Połącz się ponownie za pomocą last_event_id: wywołaj interactions.get z parametrami stream: true i ostatnim event_id. Strumień będzie kontynuowany po tym wydarzeniu.
• Odczytaj do końca: po ponownym połączeniu odczytaj strumień do końca, zanim sprawdzisz stan. Serwer odtwarza pominięte wydarzenia nawet po zakończeniu interakcji.
• Ustaw długie limity czasu: ustaw limity czasu odczytu HTTP na 15–20 minut na strumień.
• Oczekuj danych wyjściowych w blokach po 5 tys. tokenów: po pierwszych 64 tys. tokenów (czyli po około 10 minutach) strumień wysyła dane wyjściowe w blokach po około 5 tys. tokenów. Przerwy między blokami są normalne. Interakcja nie jest zablokowana, więc utrzymuj połączenie.

Stan w tle

Interakcja w tle może trwać do 24 godzin. Gdy stan nie jest już in_progress ani queued, obsługuj stan końcowy za pomocą tej tabeli:

Aby zatrzymać działającą interakcję, wywołaj client.interactions.cancel(id=interaction.id) w Pythonie, client.interactions.cancel(interaction.id) w JavaScript lub POST /v1beta/interactions/{id}/cancel w REST.

Ustaw max_output_tokens

max_output_tokens ustawia łączny limit wnioskowania i danych wyjściowych w ramach interakcji. Zmniejszenie tej wartości nie powoduje, że model wnioskuje bardziej zwięźle, ale skraca odpowiedź.

Aby użyć mniejszej liczby tokenów, zmniejsz wartość thinking_level. W przypadku najtrudniejszych zadań związanych z wnioskowaniem użyj wartości high. W przypadku większości zadań związanych z kodowaniem i agentowych użyj wartości medium (wartość domyślna).

Zliczanie tokenów

interaction.usage podaje sumy we wszystkich przeskokach. Odczytaj te pola: total_input_tokens, total_cached_tokens, total_output_tokens, total_thought_tokens i total_tokens.

total_input_tokens sumuje tokeny wejściowe każdego przeskoku. Każdy przeskok wysyła prompta i wszystko, co zostało wygenerowane do tej pory, z powrotem do modelu jako dane wejściowe, więc te same tokeny są zliczane ponownie w każdym kolejnym przeskoku. Na przykład prompt o długości 1000 tokenów, który generuje 200 tys. tokenów wnioskowania i danych wyjściowych, wymaga 4 przeskoków:

total_input_tokens zgłasza około 397 tys. tokenów (z powtarzającymi się danymi wejściowymi przeskoku automatycznie pomniejszonymi o 95% przez niejawne buforowanie), mimo że rzeczywisty rozmiar kontekstu wynosi tylko około 201 tys. tokenów: prompt o długości 1000 tokenów plus 200 tys. tokenów wnioskowania i danych wyjściowych.

Podczas strumienia zarówno wydarzenia step.stop, jak i interaction.status_update zawierają usage (skumulowane dla interakcji). Zamiast dodawać je do siebie, odczytaj najnowszą wartość usage.

Informacje o rozliczeniach

Płacisz za każdy token w każdym przeskoku, w tym za przeskoki, które zawierają tylko wnioskowanie.

• Rabat za buforowanie: niejawne buforowanie zmniejsza powtarzające się dane wejściowe w każdym przeskoku o 95%. W okresie wprowadzającym buforowane dane wejściowe kosztują 0,10 USD za 1 mln tokenów zamiast 2,00 USD.
• Anulowane i nieudane interakcje: płacisz za całą pracę wykonaną przed zakończeniem interakcji.

Rozwiązywanie problemów

Ograniczenia

• Brak długiego dekodowania bez wykonywania w tle: interakcje z parametrem background: false zatrzymują się na 65 536 tokenach. Już wkrótce.
• Brak docelowej długości: model nie uwzględnia docelowej długości tokenów ani liczby słów.

Dalsze kroki

• Nowości w Gemini 4 Argon
• Wykonywanie w tle
• Myślenie
• Długie dekodowanie za pomocą interfejsu GenerateContent API