פענוח ארוך

פענוח ארוך מאפשר ל-Gemini 4 Argon ליצור יותר מ-64, 000 טוקנים למשימות חשיבה מעמיקה,עד לחלון ההקשר המאוחד של מיליון טוקנים (1,048, 576 טוקנים שמשותפים לקלט, לחשיבה ולפלט). ב-Interactions API, אתם מפעילים פענוח ארוך עם הפעלה ברקע, כדי שהשרתים שלנו ייצרו באופן אוטומטי כל קפיצה של 64K וישלבו אותה באינטראקציה אחת.

How long decode works

קריאה אחת למודל יוצרת עד 64,000 טוקנים. כשצריך יותר מ-64K טוקנים כדי ליצור תשובה, השרת יוצר אותה בקפיצות של 64K, שממשיכות מהמקום שבו הקפיצה הקודמת הסתיימה. כל דילוג מוסיף שלב של model_output אל interaction.steps באותו מזהה אינטראקציה, כך שאתם מחברים את השלבים האלה כדי לקרוא את התגובה המלאה:

1. אתם יוצרים אינטראקציה עם background: true ו-max_output_tokens,עם ערך שגדול מ-65, 536 ועד מיליון.
2. השרת יוצר את הניתוב הראשון, עד 64,000 אסימונים.
3. השרת מתחיל את הדילוג הבא מהמקום שבו הדילוג האחרון נעצר, וחוזר על הפעולה עד שהמודל מסיים או משתמש בכל max_output_tokens.
4. כדי לקבל את התוצאה, אתם יכולים לבצע דגימה של האינטראקציה או להעביר אותה בסטרימינג.

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

מגבלות על הפלט

כברירת מחדל, אינטראקציות בסטרימינג ובלי סטרימינג מוגבלות ל-64,000 טוקנים בפלט, כך שלא צריך לשנות את הקוד בתשובות עם עד 64,000 טוקנים. כדי ליצור יותר מ-64,000 טוקנים, מפעילים את ההרצה ברקע ומגדילים את max_output_tokens.

מתי כדאי להשתמש בפענוח ארוך

רוב הבקשות מסתיימות בתוך 64,000 טוקנים. כדאי להשתמש בפענוח ארוך רק כשצריך יותר חשיבה ופלט מתשובה אחת.

אם מגדירים ערך גבוה של max_output_tokens, המודל יכול להקדיש יותר זמן לפתרון בעיות מורכבות, אבל הוא עדיין מחליט כמה לכתוב. כדי לשלוט במידת המאמץ של המודל להסיק מסקנות, מגדירים את thinking_level.

בחירת אופן ההפעלה של פענוח ארוך

הדרך הקלה ביותר להריץ פענוח ארוך ב-Interactions API היא באמצעות הפעלה ברקע. המשך בצד הלקוח, שבו הקוד מתחיל כל דילוג, זמין ב-GenerateContent API. בקרוב נוסיף ל-Interactions API אפשרות מתקדמת יותר לניהול העמידות שלכם.

כדי להשתמש בהמשך בצד הלקוח, עיינו במאמר פענוח ארוך באמצעות GenerateContent API.

פענוח ארוך של שידור

כדי להזרים את הפלט ואת סיכומי המחשבות כשהם מגיעים, מוסיפים את stream: true ואת thinking_summaries: "auto". שידורים ארוכים עלולים להתנתק, ולכן הלקוח צריך להתחבר מחדש. פועלים לפי דפוס החיבור מחדש שמפורט במדריך להפעלת תהליכים ברקע. פענוח ארוך מוסיף את הכללים הבאים:

• שומרים את מזהה האינטראקציה: קוראים אותו מהאירוע interaction.created.
• שמירה בכל event_id: יכול להגיע event_id באירועים של interaction.status_update, לא רק בשינויים בטקסט.
• חידוש הקשר עם last_event_id: מתקשרים אל interactions.get עם stream: true ו-event_id האחרונות. השידור ממשיך אחרי האירוע הזה.
• קוראים עד הסוף: אחרי שמתחברים מחדש, קוראים את הפיד עד הסוף לפני שבודקים את הסטטוס. השרת מפעיל מחדש אירועים שהוחמצו, גם אחרי שהאינטראקציה מסתיימת.
• הגדירו פסקי זמן ארוכים: הגדירו פסקי זמן לקריאת HTTP ל-15 עד 20 דקות לכל שידור.
• הפלט צפוי להגיע במקטעים של 5,000 טוקנים: אחרי 64,000 הטוקנים הראשונים (בערך 10 הדקות הראשונות), הסטרימינג שולח פלט במקטעים של כ-5,000 טוקנים. הפסקות בין קטעים הן דבר נורמלי. האינטראקציה לא נתקעה, לכן צריך להשאיר את החיבור פתוח.

סטטוס הרקע

אינטראקציה ברקע יכולה לפעול עד 24 שעות. כשהסטטוס הוא כבר לא in_progress או queued, מטפלים במצב הסופי לפי הטבלה הבאה:

כדי לעצור אינטראקציה פעילה, מפעילים את client.interactions.cancel(id=interaction.id) ב-Python, את client.interactions.cancel(interaction.id) ב-JavaScript או את POST /v1beta/interactions/{id}/cancel ב-REST.

הגדרה של max_output_tokens

‫max_output_tokens מגדיר את המגבלה המשולבת של החשיבה והפלט במהלך האינטראקציה. הורדת הערך לא גורמת למודל לחשוב בצורה תמציתית יותר, אלא מקצרת את התשובה.

כדי להשתמש בפחות אסימונים, צריך להקטין את הערך של thinking_level. אפשר להשתמש ב-high למשימות החשיבה הקשות ביותר. כדאי להשתמש ב-medium (ברירת המחדל) לרוב משימות התכנות והעבודה עם סוכנים.

ספירת טוקנים

interaction.usage מדווח על הסכומים הכוללים בכל הדילוגים. לקרוא את השדות הבאים: total_input_tokens,‏ total_cached_tokens,‏ total_output_tokens,‏ total_thought_tokens ו-total_tokens.

‫total_input_tokens מסכם את אסימוני הקלט של כל שלב. בכל שלב, ההנחיה וכל מה שנוצר עד עכשיו נשלחים בחזרה למודל כקלט, כך שאותם אסימונים נספרים שוב בכל שלב מאוחר יותר. לדוגמה, הנחיה של 1,000 טוקנים שמפיקה 200,000 טוקנים של חשיבה ופלט, דורשת ארבעה דילוגים:

‫total_input_tokens מדווח על כ-397,000 טוקנים (עם הנחה אוטומטית של 95% על קלט של דילוגים חוזרים באמצעות שמירה במטמון משתמעת), למרות שגודל ההקשר בפועל הוא רק כ-201,000 טוקנים: ההנחיה של 1,000 טוקנים בתוספת 200,000 טוקנים של חשיבה ופלט.

במהלך סטרימינג, גם אירועים מסוג step.stop וגם אירועים מסוג interaction.status_update כוללים את usage (מצטבר לאינטראקציה). לקרוא את הערך האחרון usage במקום לחבר את הערכים.

הסבר על החיוב

אתם משלמים על כל טוקן בכל שלב, כולל שלבים שמכילים רק חשיבה.

• הנחת מטמון: הנחה מרומזת על שמירת נתונים במטמון, שבה הקלט החוזר בכל קפיצה מוזל ב-95%. במהלך תקופת ההיכרות, קלט במטמון עולה 0.10 $למיליון טוקנים במקום 2.00$.
• אינטראקציות שבוטלו או נכשלו: אתם משלמים על כל העבודה שהושלמה לפני שהאינטראקציה מסתיימת.

פתרון בעיות

מגבלות

• אין פענוח ארוך בלי הרצה ברקע: האינטראקציות עם background: false נעצרות ב-65,536 טוקנים. בקרוב תהיה תמיכה.
• אין יעדי אורך: המודל לא פועל לפי יעדים של אורך טוקנים או ספירת מילים.

השלבים הבאים

• מה חדש ב-Gemini 4 Argon
• הרצה ברקע
• תהליך החשיבה
• פענוח ארוך באמצעות GenerateContent API