Dekode panjang

Dekode panjang memungkinkan Gemini 4 Argon membuat lebih dari 64 ribu token untuk tugas penalaran mendalam, hingga jendela konteks 1 juta token terpadu (1.048.576 token yang dibagikan di seluruh input, penalaran, dan output). Di Interactions API, Anda mengaktifkan dekode panjang dengan eksekusi latar belakang sehingga server kami otomatis membuat dan menggabungkan setiap hop 64 ribu menjadi satu interaksi.

Cara kerja dekode panjang

Satu panggilan model menghasilkan hingga 64 ribu token. Jika respons memerlukan lebih dari 64 ribu token, server akan membuatnya dalam hop 64 ribu yang berlanjut dari tempat hop sebelumnya berhenti. Setiap hop menambahkan langkah model_output ke interaction.steps dengan ID interaksi yang sama, sehingga Anda menggabungkan langkah-langkah tersebut untuk membaca respons lengkap:

1. Anda membuat interaksi dengan background: true dan max_output_tokens di atas 65.536, hingga 1 juta.
2. Server membuat hop pertama, hingga 64 ribu token.
3. Server memulai hop berikutnya dari tempat hop terakhir berhenti, dan mengulanginya hingga model selesai atau menggunakan semua max_output_tokens.
4. Anda melakukan polling interaksi, atau melakukan streaming, untuk mendapatkan hasilnya.

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

Batas output

Interaksi streaming dan non-streaming secara default memiliki batas token output 64 ribu, sehingga respons hingga 64 ribu token tidak memerlukan perubahan kode. Untuk membuat lebih dari 64 ribu token, aktifkan eksekusi latar belakang dan tingkatkan max_output_tokens.

Kapan menggunakan dekode panjang

Sebagian besar permintaan selesai dalam 64 ribu token. Gunakan dekode panjang hanya jika satu respons memerlukan lebih banyak pemikiran dan output.

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

Memilih cara menjalankan dekode panjang

Eksekusi latar belakang adalah cara termudah untuk menjalankan dekode panjang di Interactions API. Kelanjutan sisi klien, tempat kode Anda memulai setiap hop, tersedia dengan GenerateContent API. Fitur ini akan segera hadir di Interactions API sebagai opsi yang lebih canggih untuk mengelola ketahanan Anda sendiri.

Untuk menggunakan kelanjutan sisi klien, lihat dekode panjang dengan GenerateContent API.

Streaming dekode panjang

Untuk melakukan streaming output dan ringkasan pemikiran saat diterima, tambahkan stream: true dan thinking_summaries: "auto". Streaming panjang dapat terputus, sehingga klien Anda harus terhubung kembali. Ikuti pola koneksi ulang dalam panduan eksekusi latar belakang. Dekode panjang menambahkan aturan berikut:

• Simpan ID interaksi: Baca dari peristiwa interaction.created.
• Simpan setiap event_id: Sebuah event_id dapat muncul pada peristiwa interaction.status_update, tidak hanya pada delta teks.
• Hubungkan kembali dengan last_event_id: Panggil interactions.get dengan stream: true dan event_id terakhir. Streaming akan berlanjut setelah peristiwa tersebut.
• Baca hingga akhir: Setelah terhubung kembali, baca streaming hingga akhir sebelum Anda memeriksa status. Server akan memutar ulang peristiwa yang terlewat, bahkan setelah interaksi selesai.
• Tetapkan waktu tunggu yang lama: Tetapkan waktu tunggu baca HTTP menjadi 15 hingga 20 menit per streaming.
• Perkirakan output dalam potongan 5 ribu token: Setelah 64 ribu token pertama (sekitar 10 menit pertama), streaming akan mengirim output dalam potongan sekitar 5.000 token. Jeda antar-potongan adalah hal yang normal. Interaksi tidak macet, jadi biarkan koneksi tetap terbuka.

Status latar belakang

Interaksi latar belakang dapat berjalan hingga 24 jam. Setelah status tidak lagi in_progress atau queued, tangani status terminal menggunakan tabel ini:

Untuk menghentikan interaksi yang sedang berjalan, panggil client.interactions.cancel(id=interaction.id) di Python, client.interactions.cancel(interaction.id) di JavaScript, atau POST /v1beta/interactions/{id}/cancel di REST.

Menetapkan max_output_tokens

max_output_tokens menetapkan batas gabungan untuk pemikiran dan output di seluruh interaksi. 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.

Menghitung token

interaction.usage melaporkan total di semua hop. Baca kolom berikut: total_input_tokens, total_cached_tokens, total_output_tokens, total_thought_tokens, dan total_tokens.

total_input_tokens menjumlahkan token input setiap hop. Setiap hop mengirim perintah Anda ditambah semua yang dihasilkan sejauh ini kembali ke model sebagai input, sehingga token yang sama dihitung lagi di setiap hop berikutnya. Misalnya, perintah 1.000 token yang menghasilkan 200.000 token pemikiran dan output memerlukan empat hop:

total_input_tokens melaporkan sekitar 397.000 token (dengan input hop berulang yang otomatis didiskon 95% oleh caching implisit), meskipun ukuran konteks sebenarnya hanya sekitar 201.000 token: perintah 1.000 token ditambah 200.000 token pemikiran dan output.

Selama streaming, peristiwa step.stop dan interaction.status_update menyertakan usage (kumulatif untuk interaksi). Baca nilai usage terbaru, bukan menjumlahkannya.

Memahami penagihan

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

• Diskon cache: Caching 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.
• Interaksi yang dibatalkan dan gagal: Anda membayar semua pekerjaan yang diselesaikan sebelum interaksi berakhir.

Pemecahan masalah

Batasan

• Tidak ada dekode panjang tanpa eksekusi latar belakang: Interaksi dengan background: false berhenti pada 65.536 token. Dukungan akan segera hadir.
• Tidak ada target panjang: Model tidak mengikuti target panjang token atau jumlah kata.

Langkah berikutnya

• Yang baru di Gemini 4 Argon
• Eksekusi latar belakang
• Penalaran
• Dekode panjang dengan GenerateContent API