Dekode panjang

Dekode panjang memungkinkan Gemini 4 Argon menghasilkan output melebihi batas output permintaan tunggal untuk tugas penalaran mendalam, hingga jendela konteks 1 juta token terpadu (1.048.576 token yang dibagikan di seluruh input, pemikiran, dan output).

Mengubah ID model saja tidak akan mengaktifkan dekode panjang. Tanpa penyiapan tambahan, output akan berhenti pada 64 ribu token untuk panggilan streaming dan 32 ribu token untuk panggilan non-streaming. Cara tercepat untuk mengaktifkan dekode panjang adalah dengan mengupgrade Google GenAI SDK dan menetapkan max_output_tokens lebih besar dari 65.536. Panduan ini menjelaskan cara kerja dekode panjang, kapan harus menggunakannya, dan cara mengaktifkannya dengan generateContent.

Durasi kerja dekode

Satu permintaan streaming atau SDK menghasilkan hingga 64 ribu token, dan permintaan REST non-streaming menghasilkan hingga 32 ribu token. Jika respons memerlukan lebih banyak token, model akan membuatnya di beberapa hop permintaan dan respons yang masing-masing melanjutkan dari tempat hop sebelumnya berhenti.

• Batas token input dan output terpadu: Input, pemikiran, panggilan fungsi, dan respons akhir berbagi satu jendela 1 juta token. Output dapat menggunakan hingga 1.048.576 minus token input Anda.
• Batas pada setiap hop: Satu hop menampilkan hingga 65.536 token output. Permintaan REST non-streaming menampilkan hingga 32.768.
• Sinyal kelanjutan: Jika model mencapai batas dan masih memiliki token, respons akan diakhiri dengan finish_reason: CONTINUATION dan continuation_token.
• Langkah berikutnya: Klien mengirimkan permintaan yang sama lagi dengan token. Model melanjutkan dari tempat model berhenti.
• Satu total untuk semua hop: max_output_tokens menetapkan total token output dan penalaran untuk semua hop secara bersamaan.
• Sinyal berhenti: Jika model menggunakan semua max_output_tokens, respons akan berakhir dengan finish_reason: MAX_TOKENS.

Untuk masalah sulit, hop dapat menghabiskan semua tokennya untuk pemikiran internal dan menampilkan teks kosong dengan continuation_token. Hal ini normal, dan jawaban akhir akan muncul di hop berikutnya.

Batas output default

Tanpa dekode panjang, satu permintaan akan berhenti pada batas per permintaan berikut:

• Permintaan streaming dan permintaan non-streaming melalui Google GenAI SDK (generate_content): Default ke token output 64K.
• Panggilan REST non-streaming langsung (generateContent): Default ke 32 ribu token output. Menetapkan max_output_tokens lebih besar dari 32.768 pada panggilan REST non-streaming tanpa continuation_token akan menampilkan error 400.

Kapan harus menggunakan dekode panjang

Sebagian besar permintaan selesai dalam batas permintaan tunggal (64 ribu token untuk panggilan streaming dan SDK, atau 32 ribu token untuk panggilan REST non-streaming). Gunakan dekode panjang jika respons memerlukan lebih banyak token pemikiran dan output gabungan daripada yang diizinkan oleh satu permintaan. Meningkatkan max_output_tokens memberi model batas atas yang lebih tinggi untuk memecahkan masalah sulit, bukan membuat jawaban standar lebih panjang.

Menetapkan max_output_tokens yang tinggi memberi model ruang untuk berpikir lebih lama tentang masalah sulit, tetapi model tetap memutuskan berapa banyak yang harus ditulis. Untuk mengontrol seberapa besar upaya penalaran yang digunakan model, tetapkan thinking_level.

Mengaktifkan dekode panjang

Anda dapat menjalankan dekode panjang secara otomatis dengan Google GenAI SDK (Opsi 1, direkomendasikan untuk sebagian besar aplikasi) atau menulis loop kelanjutan Anda sendiri (Opsi 2). Kedua opsi mendukung jendela konteks 1 juta token penuh.

continuation_token yang dienkripsi membawa status model di antara permintaan, sehingga tidak ada yang disimpan di server.

Opsi 1: Menggunakan Google GenAI SDK (direkomendasikan)

Di Google GenAI SDK terbaru, automatic_continuation diaktifkan secara default untuk panggilan streaming dan non-streaming, sehingga Anda tidak perlu menyetelnya. Saat Anda menyetel max_output_tokens di atas batas per permintaan, SDK akan otomatis menjalankan hop lanjutan dan menampilkan satu respons gabungan.

1. Upgrade SDK.

   Python

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

   JavaScript

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

2. Setel max_output_tokens lebih besar dari 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);
   

Ingatlah poin-poin berikut:

• Streaming: generate_content_stream (Python) dan generateContentStream (JavaScript) juga akan dilanjutkan untuk Anda. Jika streaming terputus setelah checkpoint, SDK akan melanjutkan dari checkpoint tersebut.
• Waktu tunggu: Waktu tunggu dan percobaan ulang berlaku untuk setiap hop, bukan untuk keseluruhan proses.
• Kontrol manual: Untuk menjalankan loop sendiri, tetapkan automatic_continuation=False (Python) atau automaticContinuation: false (JavaScript). Kemudian, ikuti Opsi 2.
• Penggunaan: Kolom penggunaan menampilkan jumlah semua hop. Untuk mendapatkan ukuran perintah, baca initial_prompt_token_count. Lihat Menghitung token.

Opsi 2: Menulis loop Anda sendiri

Tulis loop Anda sendiri jika Anda memanggil REST secara langsung, menggunakan bahasa tanpa SDK terbaru, atau memerlukan kontrol penuh. Anda juga dapat melihat implementasi Google GenAI SDK kami di Python dan JavaScript/TypeScript sebagai referensi.

Ikuti aturan berikut:

1. Kirim permintaan yang sama di setiap hop. Kirim contents, system_instruction, tools, dan generation_config asli. Biarkan max_output_tokens tetap sama.
2. Jangan menambahkan output parsial ke contents. continuation_token membawa status model, termasuk proses berpikirnya.
3. Hanya kirim token terbaru. Setiap token berisi semua progres sebelumnya.
4. Lanjutkan saat finish_reason adalah CONTINUATION. Berhenti karena alasan penyelesaian lainnya.
5. Gabungkan bagian-bagian setelah hop terakhir. Gabungkan bagian dari semua hop menjadi satu giliran model untuk histori percakapan.

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

Lompatan yang sepenuhnya dihabiskan untuk berpikir akan menampilkan text kosong dengan finishReason: "CONTINUATION". Perlakukan ini sebagai progres normal dan minta next hop:

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

Loop streaming memerlukan satu aturan lagi. Setelah 32.768 token pertama, streaming akan mengirimkan token checkpoint setiap 5.000 token. Simpan potongan baru dalam daftar tertunda. Jika chunk memiliki continuation_token, pindahkan chunk yang tertunda ke output yang telah di-commit dan simpan token. Jika streaming terputus, hapus potongan yang tertunda dan lanjutkan dari token terakhir. Jika streaming terhenti sebelum checkpoint pertama, kirim permintaan asli lagi.

Tetapkan max_output_tokens

max_output_tokens menetapkan batas gabungan untuk penalaran dan output di semua hop. Menurunkannya tidak membuat model berpikir lebih ringkas, tetapi justru memotong respons lebih awal.

Untuk menggunakan lebih sedikit token, turunkan thinking_level. Gunakan high untuk tugas penalaran tersulit. Gunakan medium (default) untuk sebagian besar pekerjaan coding dan agentic. Gunakan low untuk tugas yang tidak terlalu kompleks.

Menangani permintaan yang berjalan lama

Karena Gemini 4 Argon berpikir lebih lama daripada model Gemini 3.x untuk masalah yang sulit, Anda harus meningkatkan waktu tunggu klien agar permintaan yang lama tidak terputus lebih awal.

• Panggilan non-streaming: Server akan menutup koneksi setelah 10 menit.
• Panggilan streaming: Server akan menutup streaming setelah 20 menit.
• Waktu tunggu klien: Tetapkan waktu tunggu baca HTTP ke 20 menit. Waktu tunggu 3 menit atau 5 menit akan menghentikan permintaan lebih awal.

Di Python, tetapkan waktu tunggu pada klien dalam milidetik:

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

Untuk tugas yang di-polling klien Anda, Interactions API menjalankan dekode panjang di server. Lihat eksekusi latar belakang.

Melanjutkan saat model menggunakan semua token output

Saat respons diakhiri dengan MAX_TOKENS, respons tersebut masih menyertakan continuation_token. Anda memiliki dua pilihan:

• Lanjutkan: Kirim permintaan yang sama dengan token dan max_output_tokens yang lebih tinggi. Nilainya harus lebih tinggi dari token yang digunakan sejauh ini. Jika tidak, API akan menampilkan error 400.
• Mulai lagi: Kirim permintaan asli dengan max_output_tokens yang lebih tinggi dan tanpa token. Anda akan dikenai biaya untuk kedua operasi tersebut.

Menghitung token

Dengan kelanjutan otomatis, usage_metadata melaporkan total di semua hop. SDK menjumlahkan setiap kolom jumlah: prompt_token_count, cached_content_token_count, candidates_token_count, thoughts_token_count, dan total_token_count.

prompt_token_count menjumlahkan token input dari setiap hop. Setiap hop mengirimkan perintah Anda beserta semua yang dihasilkan sejauh ini kembali ke model sebagai input, sehingga token yang sama dihitung lagi di setiap hop berikutnya. Misalnya, dengan Google GenAI SDK, perintah 1.000 token yang menghasilkan 200.000 token pemikiran dan output memerlukan empat lompatan:

prompt_token_count melaporkan sekitar 397.000 token (dengan input hop berulang yang secara otomatis didiskon 95% oleh caching implisit), dan total_token_count melaporkan sekitar 597.000 token, meskipun ukuran konteks sebenarnya hanya sekitar 201.000 token: perintah 1.000 token ditambah 200.000 token untuk pemikiran dan output. Loop REST non-streaming menggunakan 32K hop, sehingga memerlukan tujuh hop untuk output yang sama dan melaporkan 695.128 token input.

prompt_token_count dan total_token_count adalah jumlah setiap hop, bukan ukuran konteks Anda. Jangan menggunakannya untuk memutuskan kapan harus meringkas atau memangkas histori percakapan (pemadatan konteks), atau untuk menerapkan batas konteks. Untuk memperkirakan ukuran konteks, tambahkan ukuran perintah Anda dari tabel ke candidates_token_count dan thoughts_token_count.

Perbarui framework agen, alat evaluasi, atau proxy sebelum menjalankan dekode panjang:

• Agen dan alat evaluasi: Jika kode Anda memadatkan konteks atau menghentikan eksekusi pada batas token, gunakan initial_prompt_token_count (atau prompt_token_count hop pertama di REST), bukan prompt_token_count yang dijumlahkan. Respons yang selesai dalam satu hop melaporkan nilai yang sama di kedua kolom, sehingga pengujian singkat tidak menunjukkan masalah tersebut.
• Proxy dan gateway yang memanggil REST: Setiap respons REST hanya melaporkan hop-nya sendiri. Tambahkan setiap kolom di seluruh hop untuk biaya, dan pertahankan promptTokenCount hop pertama sebagai ukuran perintah. Jika tidak, pengguna Anda akan melihat angka yang berbeda dengan yang dilihat pengguna SDK untuk permintaan yang sama.
• Log dan respons yang diserialisasi: SDK menghitung initial_prompt_token_count di klien. Parameter ini tidak ada dalam respons REST atau dalam output JSON SDK, seperti model_dump(). Simpan sebagai nilai terpisah jika Anda membutuhkannya nanti.

Jika Anda melakukan streaming dalam loop Anda sendiri, usage_metadata bersifat kumulatif dalam setiap streaming. Hanya menyimpan nilai terakhir dari setiap aliran, lalu menambahkan nilai di seluruh hop.

Memahami penagihan

Anda membayar untuk setiap token di setiap hop, termasuk hop yang hanya berisi penalaran.

• Diskon cache: Cache implisit mendiskon input berulang di setiap hop sebesar 95%. Input yang di-cache dikenai biaya $0,10 per 1 juta token, bukan $2,00 selama periode perkenalan.
• Masa berlaku cache: Masa berlaku cache berakhir setelah 15 hingga 20 menit tanpa penggunaan. Jeda yang lama di antara lompatan akan mengisi daya dengan kecepatan input penuh lagi.
• Lompatan non-streaming yang gagal: Anda hanya membayar saat respons selesai. Permintaan yang gagal atau dihapus dikenai biaya $0.
• Streaming yang dihapus: Streaming yang dihapus sebelum 32 ribu token dikenai biaya $0. Setelah itu, Anda membayar hingga token pos pemeriksaan terakhir, karena Anda dapat melanjutkan dari sana.

Pemecahan masalah

Batasan

• Endpoint kompatibilitas OpenAI: Dekode panjang tidak tersedia. Output berhenti pada batas per permintaan.
• SDK lama: Versi di bawah minimum dalam catatan tidak akan dilanjutkan secara otomatis.
• Panjang: Model tidak mengikuti target panjang token atau jumlah kata.

Checklist

• Upgrade Google GenAI SDK ke versi minimum.
• Tetapkan max_output_tokens lebih besar dari 65.536.
• Gunakan thinking_level (low, medium, atau high), bukan thinking_budget.
• Setel waktu tunggu baca HTTP ke 20 menit.
• Gunakan initial_prompt_token_count untuk ukuran dan pemadatan konteks.
• Jalankan satu perintah sebagai pengujian sebelum evaluasi besar.

Langkah berikutnya

• Yang baru di Gemini 4 Argon
• Berpikir
• Penghitungan token