लॉन्ग डिकोड

लॉन्ग डिकोड की सुविधा की मदद से, Gemini 4 Argon, डीप रीज़निंग वाले टास्क के लिए, एक बार में किए गए अनुरोध के आउटपुट की सीमा से ज़्यादा जवाब जनरेट कर सकता है. यह जवाब, 10 लाख टोकन वाली यूनिफ़ाइड कॉन्टेक्स्ट विंडो (इनपुट, थिंकिंग, और आउटपुट के लिए 10,48,576 टोकन शेयर किए जाते हैं) तक जनरेट किया जा सकता है.

सिर्फ़ मॉडल आईडी बदलने से, लंबे डिकोड की सुविधा चालू नहीं होती. अतिरिक्त सेटअप के बिना, स्ट्रीमिंग कॉल के लिए आउटपुट 64 हज़ार टोकन और नॉन-स्ट्रीमिंग कॉल के लिए 32 हज़ार टोकन पर रुक जाता है. लंबे टेक्स्ट को डिकोड करने की सुविधा चालू करने के लिए, Google GenAI SDK को अपग्रेड करें और max_output_tokens को 65,536 से ज़्यादा पर सेट करें. इस गाइड में बताया गया है कि लॉन्ग डिकोड की सुविधा कैसे काम करती है, इसका इस्तेमाल कब करना चाहिए, और generateContent की मदद से इसे कैसे चालू करना चाहिए.

डिकोड करने में कितना समय लगता है

एक स्ट्रीमिंग या एसडीके अनुरोध से ज़्यादा से ज़्यादा 64 हज़ार टोकन जनरेट होते हैं. वहीं, नॉन-स्ट्रीमिंग REST अनुरोध से ज़्यादा से ज़्यादा 32 हज़ार टोकन जनरेट होते हैं. जब किसी जवाब के लिए ज़्यादा टोकन की ज़रूरत होती है, तो मॉडल उसे अनुरोध और जवाब के कई हॉप में जनरेट करता है. हर हॉप, वहीं से शुरू होता है जहां पिछला हॉप खत्म हुआ था.

• इनपुट और आउटपुट टोकन की एक ही सीमा: इनपुट, सोच-विचार, फ़ंक्शन कॉल, और फ़ाइनल जवाब के लिए, 10 लाख टोकन की एक ही विंडो शेयर की जाती है. आउटपुट में ज़्यादा से ज़्यादा 10,48,576 टोकन इस्तेमाल किए जा सकते हैं. हालांकि, इसमें से आपके इनपुट टोकन की संख्या कम कर दी जाएगी.
• हर हॉप के लिए एक सीमा: एक हॉप में ज़्यादा से ज़्यादा 65,536 आउटपुट टोकन मिलते हैं. नॉन-स्ट्रीमिंग REST अनुरोधों के लिए, ज़्यादा से ज़्यादा 32,768 टोकन इस्तेमाल किए जा सकते हैं.
• जारी रखने का सिग्नल: अगर मॉडल, जवाब के लिए तय की गई सीमा तक पहुंच जाता है और उसके पास कुछ टोकन बचे हैं, तो जवाब finish_reason: CONTINUATION और continuation_token से खत्म होता है.
• अगला हॉप: क्लाइंट, टोकन के साथ वही अनुरोध फिर से भेजता है. मॉडल वहीं से शुरू होता है जहां वह रुका था.
• सभी हॉप के लिए एक कुल संख्या: max_output_tokens, सभी हॉप के लिए, सूझ-बूझ वाले मॉडल के इस्तेमाल और आउटपुट टोकन की कुल संख्या सेट करता है.
• स्टॉप सिग्नल: जब मॉडल max_output_tokens का पूरा इस्तेमाल कर लेता है, तो जवाब finish_reason: MAX_TOKENS पर खत्म हो जाता है.

मुश्किल सवालों के जवाब देने के लिए, एक हॉप अपने सभी टोकन का इस्तेमाल इंटरनल थिंकिंग के लिए कर सकता है. साथ ही, continuation_token के साथ खाली टेक्स्ट दिखा सकता है. यह सामान्य है और आखिरी जवाब बाद के हॉप में मिलता है.

डिफ़ॉल्ट आउटपुट सीमाएं

लॉन्ग डिकोड के बिना, एक अनुरोध इन सीमाओं पर रुक जाता है:

• Google GenAI SDK (generate_content) के ज़रिए स्ट्रीमिंग और नॉन-स्ट्रीमिंग अनुरोध: डिफ़ॉल्ट रूप से, 64K आउटपुट टोकन.
• डायरेक्ट नॉन-स्ट्रीमिंग REST कॉल (generateContent): डिफ़ॉल्ट रूप से, 32,000 आउटपुट टोकन. अगर continuation_token के बिना, नॉन-स्ट्रीमिंग REST कॉल पर max_output_tokens को 32,768 से ज़्यादा पर सेट किया जाता है, तो 400 गड़बड़ी का मैसेज दिखता है.

लॉन्ग डिकोड का इस्तेमाल कब करना चाहिए

ज़्यादातर अनुरोध, एक अनुरोध के लिए तय की गई सीमा के अंदर पूरे हो जाते हैं. स्ट्रीमिंग और एसडीके कॉल के लिए 64 हज़ार टोकन या नॉन-स्ट्रीमिंग REST कॉल के लिए 32 हज़ार टोकन. लॉन्ग डिकोड का इस्तेमाल तब करें, जब किसी जवाब के लिए, एक अनुरोध में मिलने वाले आउटपुट टोकन और सूझ-बूझ वाले मॉडल के इस्तेमाल की सीमा से ज़्यादा टोकन की ज़रूरत हो. max_output_tokens की सीमा बढ़ाने से, मॉडल को मुश्किल सवालों को हल करने के लिए ज़्यादा समय मिलता है. इससे मॉडल, स्टैंडर्ड जवाबों को लंबा करने के बजाय, मुश्किल सवालों को हल करने पर ज़्यादा ध्यान दे पाता है.

max_output_tokens की वैल्यू ज़्यादा सेट करने पर, मॉडल को मुश्किल सवालों के बारे में ज़्यादा सोचने का समय मिलता है. हालांकि, मॉडल अब भी यह तय करता है कि उसे कितना लिखना है. यह तय करने के लिए कि मॉडल को जवाब देने के लिए कितनी मेहनत करनी है, thinking_level को सेट करें.

ज़्यादा समय तक डिकोड करने की सुविधा चालू करना

Google GenAI SDK की मदद से, लंबे डिकोड को अपने-आप चलाया जा सकता है. यह पहला विकल्प है और ज़्यादातर ऐप्लिकेशन के लिए इसका सुझाव दिया जाता है. इसके अलावा, अपना कॉन्टिन्यूएशन लूप भी लिखा जा सकता है. यह दूसरा विकल्प है. दोनों विकल्पों में, 10 लाख टोकन वाली कॉन्टेक्स्ट विंडो का इस्तेमाल किया जा सकता है.

एन्क्रिप्ट (सुरक्षित) किए गए continuation_token में, अनुरोधों के बीच मॉडल की स्थिति की जानकारी होती है. इसलिए, सर्वर पर कुछ भी सेव नहीं किया जाता.

पहला विकल्प: Google GenAI SDK का इस्तेमाल करना (सुझाया गया)

Google GenAI SDK के नए वर्शन में, स्ट्रीमिंग और नॉन-स्ट्रीमिंग कॉल, दोनों के लिए automatic_continuation डिफ़ॉल्ट रूप से चालू होता है. इसलिए, आपको इसे सेट करने की ज़रूरत नहीं है. जब हर अनुरोध के लिए max_output_tokens को तय सीमा से ज़्यादा पर सेट किया जाता है, तो एसडीके अपने-आप कंटिन्यूएशन हॉप चलाता है और एक साथ कई जवाब देता है.

1. एसडीके को अपग्रेड करें.

   Python

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

   JavaScript

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

2. max_output_tokens को 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);
   

इन बातों का ध्यान रखें:

• स्ट्रीमिंग: generate_content_stream (Python) और generateContentStream (JavaScript) भी आपके लिए जारी रहेंगे. अगर किसी चेकपॉइंट के बाद स्ट्रीम बंद हो जाती है, तो एसडीके उस चेकपॉइंट से स्ट्रीम को फिर से शुरू करता है.
• टाइम आउट: टाइम आउट और फिर से कोशिश करने की सुविधा, हर हॉप पर लागू होती है, न कि पूरे रन पर.
• मैन्युअल कंट्रोल: लूप को खुद चलाने के लिए, automatic_continuation=False (Python) या automaticContinuation: false (JavaScript) सेट करें. इसके बाद, दूसरे विकल्प को अपनाएं.
• इस्तेमाल: इस्तेमाल के फ़ील्ड में, सभी हॉप का योग दिखता है. अपने प्रॉम्प्ट का साइज़ जानने के लिए, initial_prompt_token_count पढ़ें. टोकन की गिनती करना देखें.

दूसरा विकल्प: अपना लूप लिखना

अगर आपको REST को सीधे कॉल करना है, किसी ऐसी भाषा का इस्तेमाल करना है जिसमें एसडीके का नया वर्शन उपलब्ध नहीं है या आपको पूरा कंट्रोल चाहिए, तो अपना लूप लिखें. रेफ़रंस के तौर पर, Python और JavaScript/TypeScript में Google GenAI SDK टूल के इस्तेमाल के बारे में भी जानकारी दी गई है.

ऐसा करते समय इन नियमों का पालन करें:

1. हर हॉप पर एक ही अनुरोध भेजें. ओरिजनल contents, system_instruction, tools, और generation_config सबमिट करें. max_output_tokens को पहले जैसा ही रखें.
2. contents में अधूरा आउटपुट न जोड़ें. continuation_token में मॉडल की स्थिति की जानकारी होती है. इसमें यह भी शामिल होता है कि मॉडल क्या सोच रहा है.
3. सिर्फ़ सबसे नया टोकन भेजें. हर टोकन में, पहले की गई सभी प्रोग्रेस शामिल होती है.
4. finish_reason के CONTINUATION होने पर जारी रखें. किसी अन्य वजह से बंद हो गया.
5. आखिरी हॉप के बाद, हिस्सों को जोड़ें. बातचीत के इतिहास के लिए, सभी हॉप के हिस्सों को एक मॉडल टर्न में जोड़ें.

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

अगर किसी हॉप में सिर्फ़ गहराई से विचार करने की प्रोसेस हुई है, तो finishReason: "CONTINUATION" के साथ खाली text दिखेगा. इसे सामान्य प्रोग्रेस मानें और अगले हॉप का अनुरोध करें:

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

स्ट्रीमिंग लूप के लिए एक और नियम की ज़रूरत है. शुरुआती 32,768 टोकन के बाद, स्ट्रीम हर 5,000 टोकन पर एक चेकपॉइंट टोकन भेजती है. नए चंक को 'मंज़ूरी बाकी है' सूची में रखें. जब किसी चंक में continuation_token हो, तो बाकी बचे चंक को अपने कमिट किए गए आउटपुट में ले जाएं और टोकन को सेव करें. अगर स्ट्रीम बंद हो जाती है, तो बाकी बचे चंक को खारिज कर दें और आखिरी टोकन से फिर से शुरू करें. अगर स्ट्रीम पहले चेकपॉइंट से पहले ही बंद हो जाती है, तो ओरिजनल अनुरोध को फिर से भेजें.

सेट max_output_tokens

max_output_tokens सभी हॉप के लिए, सोचने और आउटपुट देने की कुल सीमा सेट करता है. इसे कम करने से, मॉडल ज़्यादा सटीक तरीके से नहीं सोचता. इसके बजाय, जवाब को पहले ही काट दिया जाता है.

कम टोकन का इस्तेमाल करने के लिए, thinking_level की वैल्यू कम करें. सबसे मुश्किल तर्कों वाले टास्क के लिए, high का इस्तेमाल करें. ज़्यादातर कोडिंग और एजेंटिक काम के लिए, medium (डिफ़ॉल्ट) का इस्तेमाल करें. कम मुश्किल कामों के लिए, low का इस्तेमाल करें.

लंबे समय तक चलने वाले अनुरोधों को मैनेज करना

मुश्किल सवालों के जवाब देने के लिए, Gemini 4 Argon, Gemini 3.x मॉडल से ज़्यादा समय लेता है. इसलिए, आपको क्लाइंट के टाइमआउट को बढ़ाना चाहिए, ताकि लंबे अनुरोधों को समय से पहले बंद न किया जा सके.

• नॉन-स्ट्रीमिंग कॉल: सर्वर, 10 मिनट के बाद कनेक्शन बंद कर देता है.
• स्ट्रीमिंग कॉल: सर्वर, 20 मिनट बाद स्ट्रीम बंद कर देता है.
• क्लाइंट टाइमआउट: एचटीटीपी रीड टाइमआउट को 20 मिनट पर सेट करें. तीन या पांच मिनट का टाइम आउट, अनुरोध को जल्दी रोक देता है.

Python में, क्लाइंट पर टाइम आउट को मिलीसेकंड में सेट करें:

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

आपका क्लाइंट जिन जॉब को पोल करता है उनके लिए, Interactions API सर्वर पर लंबे समय तक डिकोड करता है. बैकग्राउंड में कोड एक्ज़ीक्यूट होने की सुविधा देखें.

मॉडल के सभी आउटपुट टोकन इस्तेमाल करने पर, फिर से शुरू करें

अगर किसी जवाब के आखिर में MAX_TOKENS है, तो भी उसमें continuation_token शामिल होता है. आपके पास दो विकल्प हैं:

• जारी रखें: टोकन और ज़्यादा max_output_tokens के साथ वही अनुरोध भेजें. यह वैल्यू, अब तक इस्तेमाल किए गए टोकन से ज़्यादा होनी चाहिए. ऐसा न होने पर, एपीआई 400 वाली गड़बड़ी दिखाता है.
• फिर से शुरू करें: ज़्यादा max_output_tokens के साथ ओरिजनल अनुरोध भेजें. इसमें कोई टोकन शामिल न करें. आपको दोनों रन के लिए पेमेंट करना होगा.

टोकन की गिनती करना

अपने-आप जारी रहने वाली सुविधा चालू होने पर, usage_metadata सभी हॉप के कुल समय की जानकारी देता है. एसडीके, हर काउंट फ़ील्ड को जोड़ता है: prompt_token_count, cached_content_token_count, candidates_token_count, thoughts_token_count, और total_token_count.

prompt_token_count, हर हॉप के इनपुट टोकन जोड़ता है. हर हॉप, आपके प्रॉम्प्ट के साथ-साथ अब तक जनरेट किए गए कॉन्टेंट को इनपुट के तौर पर मॉडल को वापस भेजता है. इसलिए, बाद के हर हॉप में वही टोकन फिर से गिने जाते हैं. उदाहरण के लिए, Google GenAI SDK का इस्तेमाल करके, 1,000 टोकन वाले प्रॉम्प्ट से 2,00,000 टोकन वाला आउटपुट और थिंकिंग प्रोसेस जनरेट करने में चार हॉप लगते हैं:

prompt_token_count करीब 3,97,000 टोकन की रिपोर्ट करता है. इसमें, बार-बार इस्तेमाल किए गए हॉप इनपुट पर, इंप्लिसिट कैश मेमोरी की वजह से अपने-आप 95% की छूट मिल जाती है. वहीं, total_token_count करीब 5,97,000 टोकन की रिपोर्ट करता है. भले ही, असल कॉन्टेक्स्ट साइज़ सिर्फ़ 2,01,000 टोकन हो: 1,000 टोकन का प्रॉम्प्ट और 2,00,000 टोकन की सोच और आउटपुट. नॉन-स्ट्रीमिंग REST लूप में 32 हज़ार हॉप इस्तेमाल होते हैं. इसलिए, एक ही आउटपुट के लिए सात हॉप लगते हैं और 6,95,128 इनपुट टोकन रिपोर्ट किए जाते हैं.

prompt_token_count और total_token_count, हर हॉप का योग हैं, न कि आपके कॉन्टेक्स्ट का साइज़. इनका इस्तेमाल, बातचीत के इतिहास (कॉन्टेक्स्ट कंपैक्शन) को छोटा करने या उसकी खास जानकारी जनरेट करने का फ़ैसला लेने के लिए न करें. साथ ही, कॉन्टेक्स्ट की सीमा लागू करने के लिए भी इनका इस्तेमाल न करें. कॉन्टेक्स्ट साइज़ का अनुमान लगाने के लिए, टेबल में दिए गए प्रॉम्प्ट साइज़ को candidates_token_count और thoughts_token_count में जोड़ें.

लंबे समय तक डिकोड करने की प्रोसेस शुरू करने से पहले, अपने एजेंट फ़्रेमवर्क, आकलन टूल या प्रॉक्सी को अपडेट करें:

• एजेंट और आकलन करने वाले टूल: अगर आपका कोड, कॉन्टेक्स्ट को छोटा करता है या टोकन की सीमा पर पहुंचने के बाद चलना बंद कर देता है, तो कुल prompt_token_count के बजाय initial_prompt_token_count (या REST में पहले हॉप का prompt_token_count) का इस्तेमाल करें. एक हॉप में खत्म होने वाले जवाब, दोनों फ़ील्ड में एक ही वैल्यू रिपोर्ट करते हैं. इसलिए, छोटे टेस्ट में समस्या नहीं दिखती.
• REST को कॉल करने वाली प्रॉक्सी और गेटवे: हर REST रिस्पॉन्स सिर्फ़ अपने हॉप की जानकारी देता है. हर हॉप के लिए, कीमत के हिसाब से हर फ़ील्ड जोड़ें. साथ ही, पहले हॉप के promptTokenCount को प्रॉम्प्ट साइज़ के तौर पर रखें. ऐसा न करने पर, आपके उपयोगकर्ताओं को वही नंबर दिखेंगे जो एसडीके का इस्तेमाल करने वाले लोगों को दिखते हैं.
• लॉग और सीरियलाइज़ किए गए रिस्पॉन्स: SDK टूल, क्लाइंट पर initial_prompt_token_count का हिसाब लगाता है. यह REST रिस्पॉन्स या SDK टूल के JSON आउटपुट में नहीं होता है, जैसे कि model_dump(). अगर आपको इसकी ज़रूरत बाद में पड़ती है, तो इसे अलग वैल्यू के तौर पर सेव करें.

अगर अपने लूप में स्ट्रीम किया जाता है, तो हर स्ट्रीम में usage_metadata को जोड़ा जाता है. हर स्ट्रीम की सिर्फ़ आखिरी वैल्यू को बनाए रखें. इसके बाद, हॉप के हिसाब से वैल्यू जोड़ें.

बिलिंग के बारे में जानकारी

आपको हर हॉप में इस्तेमाल किए गए हर टोकन के लिए पेमेंट करना होगा. इसमें वे हॉप भी शामिल हैं जिनमें सिर्फ़ थिंकिंग प्रोसेस का इस्तेमाल किया गया है.

• कैश मेमोरी में सेव करने पर मिलने वाली छूट: इंप्लिसिट कैशिंग की सुविधा, हर हॉप में बार-बार इस्तेमाल होने वाले इनपुट को 95% तक कम कर देती है. शुरुआती अवधि के दौरान, कैश मेमोरी में सेव किए गए इनपुट के लिए, हर 10 लाख टोकन पर 2 डॉलर के बजाय 0.10 डॉलर का शुल्क लिया जाता है.
• कैश मेमोरी की समयसीमा खत्म होना: अगर कैश मेमोरी का इस्तेमाल नहीं किया जाता है, तो 15 से 20 मिनट बाद इसकी समयसीमा खत्म हो जाती है. अगर हॉप के बीच लंबा ठहराव होता है, तो इनपुट की पूरी दर फिर से लागू हो जाती है.
• नॉन-स्ट्रीमिंग हॉप के लिए, जवाब जनरेट न हो पाना: आपको सिर्फ़ तब पेमेंट करना होगा, जब जवाब जनरेट हो जाएगा. अनुरोध पूरा न होने या रद्द होने पर, कोई शुल्क नहीं लिया जाता.
• ड्रॉप की गई स्ट्रीम: अगर कोई स्ट्रीम 32 हज़ार टोकन से पहले ड्रॉप हो जाती है, तो उसका शुल्क नहीं लिया जाता. इसके बाद, आपको आखिरी चेकपॉइंट टोकन तक पेमेंट करना होगा, क्योंकि वहां से गेम को फिर से शुरू किया जा सकता है.

समस्या का हल

सीमाएं

• OpenAI के साथ काम करने वाला एंडपॉइंट: Long decode की सुविधा उपलब्ध नहीं है. हर अनुरोध के लिए तय की गई सीमा पर आउटपुट जनरेट होना बंद हो जाता है.
• एसडीके के पुराने वर्शन: नोट में दिए गए ज़रूरी वर्शन से पहले के वर्शन, अपने-आप जारी नहीं होते.
• लंबाई: मॉडल, टोकन की लंबाई या शब्दों की संख्या के टारगेट का पालन नहीं करता.

चेकलिस्ट

• Google GenAI SDK को कम से कम वर्शन पर अपग्रेड करें.
• max_output_tokens को 65,536 से ज़्यादा पर सेट करें.
• thinking_level (low, medium या high) का इस्तेमाल करें, न कि thinking_budget का.
• एचटीटीपी रीड टाइमआउट को 20 मिनट पर सेट करें.
• कॉन्टेक्स्ट के साइज़ और कंपैक्शन के लिए, initial_prompt_token_count का इस्तेमाल करें.
• बड़े पैमाने पर जांच करने से पहले, एक प्रॉम्प्ट को टेस्ट के तौर पर चलाएं.

अगले चरण

• Gemini 4 Argon में नया क्या है
• सोच-विचार करना
• टोकन की गिनती