ถอดรหัสแบบยาว

การถอดรหัสแบบยาวช่วยให้ Gemini 4 Argon สร้างเอาต์พุตได้เกินขีดจำกัดของคำขอเดียวสำหรับงานที่ต้องใช้การให้เหตุผลเชิงลึก โดยรองรับหน้าต่างบริบทแบบรวมขนาด 1 ล้านโทเค็น (1,048,576 โทเค็นที่แชร์ระหว่างอินพุต การคิด และเอาต์พุต)

การเปลี่ยนรหัสโมเดลเพียงอย่างเดียวไม่ได้เปิดใช้การถอดรหัสแบบยาว หากไม่มีการตั้งค่าเพิ่มเติม เอาต์พุตจะหยุดที่ 64,000 โทเค็นสำหรับการโทรแบบสตรีมมิง และ 32,000 โทเค็นสำหรับการโทรแบบไม่สตรีมมิง วิธีที่เร็วที่สุดในการเปิดการถอดรหัสแบบยาวคือการอัปเกรด Google GenAI SDK และตั้งค่า max_output_tokens ให้มากกว่า 65,536 คู่มือนี้จะอธิบายวิธีการทำงานของการถอดรหัสแบบยาว กรณีที่ควรใช้ และวิธีเปิดใช้ด้วย generateContent

ระยะเวลาที่การถอดรหัสทำงาน

คำขอสตรีมมิงหรือ SDK รายการเดียวจะสร้างโทเค็นได้สูงสุด 64,000 รายการ และคำขอ REST ที่ไม่ใช่สตรีมมิงจะสร้างโทเค็นได้สูงสุด 32,000 รายการ เมื่อคำตอบต้องการโทเค็นเพิ่มเติม โมเดลจะสร้างโทเค็นดังกล่าวในการส่งคำขอและการตอบกลับหลายครั้ง โดยแต่ละครั้งจะดำเนินการต่อจากที่การส่งต่อครั้งก่อนหน้าหยุด

• ขีดจำกัดโทเค็นอินพุตและเอาต์พุตแบบรวม: อินพุต การคิด การเรียกใช้ฟังก์ชัน และคำตอบสุดท้ายจะใช้หน้าต่างโทเค็นขนาด 1 ล้านโทเค็นร่วมกัน เอาต์พุตสามารถใช้โทเค็นได้สูงสุด 1,048,576 ลบด้วยโทเค็นอินพุต
• ขีดจำกัดของแต่ละฮอป: ฮอปหนึ่งๆ จะแสดงโทเค็นเอาต์พุตได้สูงสุด 65,536 รายการ คำขอ REST ที่ไม่ใช่สตรีมมิงจะแสดงผลได้สูงสุด 32,768 รายการ
• สัญญาณความต่อเนื่อง: หากโมเดลถึงขีดจำกัดและยังมีโทเค็นเหลืออยู่ คำตอบจะสิ้นสุดด้วย finish_reason: CONTINUATION และ continuation_token
• การ Hop ถัดไป: ไคลเอ็นต์จะส่งคำขอเดิมอีกครั้งพร้อมโทเค็น โมเดลจะดำเนินการต่อจากจุดที่หยุดไว้
• ยอดรวมเดียวสำหรับฮ็อปทั้งหมด: max_output_tokens จะกำหนดโทเค็นการคิดและเอาต์พุตรวมสำหรับฮ็อปทั้งหมดรวมกัน
• สัญญาณหยุด: เมื่อโมเดลใช้ max_output_tokens ทั้งหมด คำตอบจะลงท้ายด้วย finish_reason: MAX_TOKENS

สำหรับปัญหาที่ยาก ฮอปอาจใช้โทเค็นทั้งหมดไปกับการคิดภายในและส่งคืนข้อความว่างพร้อมด้วย continuation_token ซึ่งเป็นเรื่องปกติ และคำตอบสุดท้ายจะมาถึงในฮ็อปถัดไป

ขีดจำกัดเอาต์พุตเริ่มต้น

หากไม่มีการถอดรหัสแบบยาว คำขอเดียวจะหยุดที่ขีดจำกัดต่อคำขอต่อไปนี้

• คำขอสตรีมและคำขอที่ไม่ใช่การสตรีมผ่าน Google GenAI SDK (generate_content): ค่าเริ่มต้นคือโทเค็นเอาต์พุต 64,000 รายการ
• การเรียก REST แบบไม่สตรีมโดยตรง (generateContent): ค่าเริ่มต้นคือโทเค็นเอาต์พุต 32,000 รายการ การตั้งค่า max_output_tokens มากกว่า 32,768 ในการเรียก REST ที่ไม่ใช่การสตรีมโดยไม่มี continuation_token จะแสดงข้อผิดพลาด 400

เมื่อใดที่ควรใช้การถอดรหัสแบบยาว

คำขอส่วนใหญ่จะเสร็จสิ้นภายในขีดจำกัดของคำขอเดียว (64,000 โทเค็นสำหรับการสตรีมและการเรียก SDK หรือ 32,000 โทเค็นสำหรับการเรียก REST ที่ไม่ใช่การสตรีม) ใช้การถอดรหัสแบบยาวเมื่อคำตอบต้องใช้โทเค็นการคิดและเอาต์พุตรวมกันมากกว่าที่คำขอเดียวอนุญาต การเพิ่ม max_output_tokens จะทำให้โมเดลมีเพดานที่สูงขึ้นในการให้เหตุผลผ่านปัญหาที่ยาก แทนที่จะทำให้คำตอบมาตรฐานยาวขึ้น

การตั้งค่า max_output_tokens สูงจะช่วยให้โมเดลมีเวลาคิดนานขึ้นสำหรับปัญหาที่ยาก แต่โมเดลจะยังคงเป็นผู้กำหนดปริมาณข้อความที่จะเขียน หากต้องการควบคุมความพยายามในการให้เหตุผลที่โมเดลใช้ ให้ตั้งค่า thinking_level

เปิดใช้การถอดรหัสแบบยาว

คุณสามารถเรียกใช้การถอดรหัสแบบยาวโดยอัตโนมัติด้วย Google GenAI SDK (ตัวเลือกที่ 1 แนะนำสำหรับแอปส่วนใหญ่) หรือเขียนลูปความต่อเนื่องของคุณเอง (ตัวเลือกที่ 2) ทั้ง 2 ตัวเลือกนี้รองรับหน้าต่างบริบทขนาด 1 ล้านโทเค็นแบบเต็ม

continuation_token ที่เข้ารหัสจะเก็บสถานะของโมเดลไว้ระหว่างคำขอ จึงไม่มีการจัดเก็บข้อมูลใดๆ ไว้ในเซิร์ฟเวอร์

ตัวเลือกที่ 1: ใช้ Google GenAI SDK (แนะนำ)

ใน Google GenAI SDK เวอร์ชันล่าสุด ระบบจะเปิดใช้ automatic_continuation โดยค่าเริ่มต้นสำหรับการเรียกทั้งแบบสตรีมมิงและไม่ใช่สตรีมมิง คุณจึงไม่จำเป็นต้องตั้งค่า เมื่อตั้งค่าmax_output_tokensสูงกว่าขีดจํากัดต่อคําขอ SDK จะเรียกใช้การเปลี่ยนเส้นทางต่อเนื่องโดยอัตโนมัติและแสดงผลการตอบกลับที่รวมกัน

1. อัปเกรด SDK

   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) จะเขียนต่อให้คุณด้วย หากสตรีมหยุดลงหลังจากจุดตรวจสอบ SDK จะกลับมาทำงานต่อจากจุดตรวจสอบนั้น
• ระยะหมดเวลา: ระยะหมดเวลาและการลองใหม่จะมีผลกับการส่งต่อแต่ละครั้ง ไม่ใช่การเรียกใช้ทั้งหมด
• การควบคุมด้วยตนเอง: หากต้องการเรียกใช้ลูปด้วยตนเอง ให้ตั้งค่า automatic_continuation=False (Python) หรือ automaticContinuation: false (JavaScript) จากนั้นทำตามตัวเลือกที่ 2
• การใช้งาน: ฟิลด์การใช้งานจะแสดงผลรวมของการส่งต่อทั้งหมด หากต้องการดูขนาดของพรอมต์ โปรดอ่าน initial_prompt_token_count ดูนับโทเค็น

ตัวเลือกที่ 2: เขียนลูปของคุณเอง

เขียนลูปของคุณเองหากเรียกใช้ REST โดยตรง ใช้ภาษาที่ไม่มี SDK ล่าสุด หรือต้องการควบคุมอย่างเต็มที่ นอกจากนี้ คุณยังดูการติดตั้งใช้งาน Google GenAI SDK ใน Python และ JavaScript/TypeScript เพื่อใช้เป็นข้อมูลอ้างอิงได้ด้วย

โดยทำตามกฎต่อไปนี้

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

การฮ็อปที่ใช้เวลาทั้งหมดไปกับการคิดจะแสดงผล text ที่ว่างเปล่าพร้อม finishReason: "CONTINUATION" ให้ถือว่านี่เป็นความคืบหน้าตามปกติและขอการ Hop ถัดไปโดยทำดังนี้

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

ลูปสตรีมมิงต้องมีกฎอีก 1 ข้อ หลังจาก 32,768 โทเค็นแรก สตรีมจะส่งโทเค็นจุดตรวจสอบทุกๆ 5,000 โทเค็น เก็บกลุ่มใหม่ไว้ในรายการที่รอดำเนินการ เมื่อกลุ่มมี continuation_token ให้ย้ายกลุ่มที่รอดำเนินการไปยังเอาต์พุตที่คอมมิตแล้วและบันทึกโทเค็น หากสตรีมหยุดทำงาน ให้ทิ้งก้อนข้อมูลที่รอดำเนินการและเล่นต่อจากโทเค็นสุดท้าย หากสตรีมหยุดลงก่อนจุดตรวจสอบแรก ให้ส่งคำขอเดิมอีกครั้ง

ชุด max_output_tokens

max_output_tokens กำหนดขีดจำกัดรวมสำหรับการคิดและเอาต์พุตในทุกฮ็อป การลดค่านี้ไม่ได้ทำให้โมเดลคิดอย่างกระชับมากขึ้น แต่จะทำให้โมเดลตัดคำตอบออกเร็วขึ้น

หากต้องการใช้โทเค็นน้อยลง ให้ลด thinking_level ใช้ high สำหรับงานที่ต้องใช้การให้เหตุผลที่ยากที่สุด ใช้ medium (ค่าเริ่มต้น) สำหรับงานการเขียนโค้ดและงานแบบ Agent ส่วนใหญ่ ใช้ low สำหรับงานที่ซับซ้อนน้อยกว่า

จัดการคำขอที่ใช้เวลานาน

เนื่องจาก Gemini 4 Argon ใช้เวลาคิดนานกว่าโมเดล Gemini 3.x สำหรับปัญหาที่ยาก คุณจึงควรเพิ่มระยะหมดเวลาของไคลเอ็นต์เพื่อให้คำขอที่ใช้เวลานานไม่ถูกตัดการเชื่อมต่อก่อนเวลาอันควร

• การโทรที่ไม่ได้สตรีม: เซิร์ฟเวอร์จะปิดการเชื่อมต่อหลังจากผ่านไป 10 นาที
• การเรียกแบบสตรีมมิง: เซิร์ฟเวอร์จะปิดสตรีมหลังจากผ่านไป 20 นาที
• ระยะหมดเวลาของไคลเอ็นต์: ตั้งค่าระยะหมดเวลาในการอ่าน HTTP เป็น 20 นาที การหมดเวลา 3 นาทีหรือ 5 นาทีจะหยุดคำขอก่อนเวลา

ใน Python ให้ตั้งค่าการหมดเวลาในไคลเอ็นต์เป็นมิลลิวินาที

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

สำหรับงานที่ไคลเอ็นต์ของคุณสำรวจ Interactions API จะทำการถอดรหัสแบบยาวในเซิร์ฟเวอร์ ดูการดำเนินการในเบื้องหลัง

กลับมาทำงานต่อเมื่อโมเดลใช้โทเค็นเอาต์พุตทั้งหมด

เมื่อการตอบกลับลงท้ายด้วย MAX_TOKENS การตอบกลับจะยังคงมี continuation_token คุณมี 2 ทางเลือก ดังนี้

• ดำเนินการต่อ: ส่งคำขอเดียวกันพร้อมโทเค็นและ max_output_tokens ที่สูงขึ้น ค่าต้องสูงกว่าโทเค็นที่ใช้ไปแล้ว ไม่เช่นนั้น API จะแสดงข้อผิดพลาด 400
• เริ่มอีกครั้ง: ส่งคำขอเดิมที่มี max_output_tokens สูงขึ้นและไม่มีโทเค็น คุณต้องจ่ายค่าบริการทั้ง 2 ครั้ง

นับโทเค็น

เมื่อใช้การติดตามต่ออัตโนมัติ usage_metadata จะรายงานยอดรวมในทุกฮ็อป SDK จะรวมช่องจำนวนทั้งหมด ได้แก่ prompt_token_count, cached_content_token_count, candidates_token_count, thoughts_token_count และ total_token_count

prompt_token_count จะรวมโทเค็นอินพุตของทุกฮ็อป แต่ละฮ็อปจะส่งพรอมต์ของคุณพร้อมกับทุกอย่างที่สร้างขึ้นจนถึงตอนนี้กลับไปยังโมเดลเป็นอินพุต ดังนั้นระบบจะนับโทเค็นเดียวกันอีกครั้งในทุกฮ็อปที่ตามมา ตัวอย่างเช่น เมื่อใช้ Google GenAI SDK พรอมต์ที่มีโทเค็น 1,000 รายการซึ่งสร้างโทเค็นการคิดและเอาต์พุต 200,000 รายการจะใช้การข้าม 4 ครั้ง ดังนี้

prompt_token_count รายงานโทเค็นประมาณ 397,000 รายการ (โดยอินพุต Hop ที่ซ้ำกันจะลดลง 95% โดยอัตโนมัติด้วยการแคชโดยนัย) และ total_token_count รายงานโทเค็นประมาณ 597,000 รายการ แม้ว่าขนาดบริบทจริงจะอยู่ที่ประมาณ 201,000 โทเค็นเท่านั้น ซึ่งก็คือพรอมต์ 1,000 โทเค็นบวกกับการคิดและเอาต์พุต 200,000 โทเค็น ลูป REST ที่ไม่ใช่การสตรีมใช้ 32, 000 Hop ดังนั้นจึงใช้ 7 Hop สำหรับเอาต์พุตเดียวกันและรายงานโทเค็นอินพุต 695,128 รายการ

prompt_token_count และ total_token_count คือผลรวมของทุกฮ็อป ไม่ใช่ขนาดของบริบท อย่าใช้เพื่อตัดสินใจว่าจะสรุปหรือตัดประวัติการสนทนา (การบีบอัดบริบท) เมื่อใด หรือเพื่อบังคับใช้ขีดจำกัดบริบท หากต้องการประมาณขนาดบริบท ให้เพิ่มขนาดพรอมต์จากตารางลงใน candidates_token_count และ thoughts_token_count

อัปเดตเฟรมเวิร์กของ Agent, เครื่องมือประเมิน หรือพร็อกซี ก่อนที่จะเรียกใช้การถอดรหัสแบบยาว

• Agent และเครื่องมือประเมิน: หากโค้ดของคุณบีบอัดบริบทหรือหยุดการเรียกใช้ที่ขีดจำกัดโทเค็น ให้ใช้ initial_prompt_token_count (หรือ prompt_token_count ของฮ็อปแรกใน REST) แทน prompt_token_count ที่รวมแล้ว การตอบกลับที่เสร็จสิ้นในฮ็อปเดียวจะรายงานค่าเดียวกันในทั้ง 2 ฟิลด์ ดังนั้นการทดสอบระยะสั้นจึงไม่แสดงปัญหา
• พร็อกซีและเกตเวย์ที่เรียก REST: การตอบกลับ REST แต่ละรายการจะรายงานเฉพาะการส่งต่อของตัวเอง เพิ่มแต่ละฟิลด์ในการส่งต่อแต่ละครั้งสำหรับค่าใช้จ่าย และเก็บ promptTokenCount ของการส่งต่อครั้งแรกไว้เป็นขนาดพรอมต์ ไม่เช่นนั้น ผู้ใช้จะเห็นตัวเลขที่แตกต่างจากผู้ใช้ SDK สำหรับคำขอเดียวกัน
• บันทึกและการตอบกลับที่แปลงเป็นอนุกรม: SDK จะคำนวณ initial_prompt_token_count ในไคลเอ็นต์ ซึ่งไม่ได้อยู่ในการตอบกลับ REST หรือในเอาต์พุต JSON ของ SDK เช่น model_dump() บันทึกเป็นค่าแยกต่างหากหากต้องการใช้ในภายหลัง

หากคุณสตรีมในลูปของตัวเอง usage_metadata จะสะสมภายในแต่ละสตรีม เก็บเฉพาะค่าสุดท้ายของแต่ละสตรีม แล้วบวกค่าต่างๆ ในฮ็อป

ทำความเข้าใจการเรียกเก็บเงิน

คุณต้องจ่ายค่าโทเค็นทุกรายการในทุกฮ็อป รวมถึงฮ็อปที่มีเฉพาะการคิดเท่านั้น

• ส่วนลดการแคช: การแคชโดยนัยจะลดราคาอินพุตที่ซ้ำกันในแต่ละฮ็อป 95% อินพุตที่แคชไว้จะมีค่าใช้จ่าย $0.10 ต่อ 1 ล้านโทเค็นแทนที่จะเป็น $2.00 ในช่วงแนะนำ
• การหมดอายุของแคช: แคชจะหมดอายุหลังจากที่ไม่มีการใช้งานเป็นเวลา 15-20 นาที การหยุดพักเป็นเวลานานระหว่างการกระโดดจะทำให้ระบบคิดอัตราการป้อนข้อมูลเต็มอีกครั้ง
• การข้ามที่ไม่ใช่การสตรีมที่ล้มเหลว: คุณจะจ่ายเมื่อคำตอบเสร็จสมบูรณ์เท่านั้น คำขอที่ไม่สำเร็จหรือถูกทิ้งจะมีค่าใช้จ่าย $0
• สตรีมที่หยุดกลางคัน: สตรีมที่หยุดก่อนถึง 32,000 โทเค็นจะไม่มีค่าใช้จ่าย หลังจากนั้น คุณจะชำระเงินสำหรับโทเค็นจุดตรวจสอบสุดท้าย เนื่องจากคุณสามารถดำเนินการต่อจากจุดนั้นได้

การแก้ปัญหา

ข้อจำกัด

• ปลายทางความเข้ากันได้กับ OpenAI: การถอดรหัสแบบยาวไม่พร้อมใช้งาน เอาต์พุตจะหยุดที่ขีดจำกัดต่อคำขอ
• SDK เวอร์ชันเก่า: เวอร์ชันที่ต่ำกว่าเวอร์ชันขั้นต่ำในหมายเหตุจะไม่ดำเนินการต่อโดยอัตโนมัติ
• ความยาว: โมเดลไม่เป็นไปตามเป้าหมายความยาวโทเค็นหรือจำนวนคำ

เช็กลิสต์

• อัปเกรด Google GenAI SDK เป็นเวอร์ชันขั้นต่ำ
• ตั้งค่า max_output_tokens ให้มากกว่า 65,536
• ใช้ thinking_level (low, medium หรือ high) ไม่ใช่ thinking_budget
• ตั้งค่าการหมดเวลาอ่าน HTTP เป็น 20 นาที
• ใช้ initial_prompt_token_count สำหรับขนาดบริบทและการบีบอัด
• เรียกใช้พรอมต์ 1 รายการเป็นการทดสอบก่อนการประเมินขนาดใหญ่

ขั้นตอนถัดไป

• มีอะไรใหม่ใน Gemini 4 Argon
• การคิด
• การนับโทเค็น