Долгое декодирование

Благодаря длинному декодированию 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.
• Следующий переход. Клиент отправляет тот же запрос с токеном. Модель продолжит работу с того места, где остановилась.
• Общее количество для всех переходов. max_output_tokens задает общее количество токенов для рассуждений и вывода для всех переходов.
• Сигнал остановки. Когда модель использует все токены из max_output_tokens, ответ заканчивается символами finish_reason: MAX_TOKENS.

При решении сложных задач шаг может потратить все токены на внутренние рассуждения и вернуть пустой текст с continuation_token. Это нормально, и окончательный ответ будет получен на более поздних этапах.

Ограничения на вывод по умолчанию

Без длинного декодирования один запрос останавливается при достижении следующих лимитов:

• Запросы потоковой передачи и обычные запросы через GenAI SDK от Google (generate_content): по умолчанию используется 64 000 выходных токенов.
• Прямые REST-вызовы без потоковой передачи (generateContent). По умолчанию 32 000 выходных токенов. Если в вызове REST без потоковой передачи задать для параметра max_output_tokens значение больше 32 768 и не указать параметр continuation_token,будет возвращена ошибка 400.

Когда использовать длинное декодирование

Большинство запросов укладываются в лимит на один запрос (64 000 токенов для потоковой передачи и вызовов SDK или 32 000 токенов для вызовов REST без потоковой передачи). Используйте длинное декодирование, когда для ответа требуется больше токенов, чем разрешено в одном запросе. Увеличение значения max_output_tokens позволяет модели лучше справляться со сложными задачами, а не просто давать более длинные ответы.

Если задать высокое значение max_output_tokens, у модели будет больше времени на размышления над сложными задачами, но она по-прежнему будет сама решать, сколько писать. Чтобы контролировать, сколько усилий по рассуждению использует модель, задайте параметр thinking_level.

Как включить длинное декодирование

Вы можете автоматически выполнять длинное декодирование с помощью Google GenAI SDK (вариант 1, рекомендуется для большинства приложений) или написать собственный цикл продолжения (вариант 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". Рассматривайте это как нормальный прогресс и запрашивайте следующий переход:

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

Для стриминговых лупов нужно ещё одно правило. После первых 32 768 токенов поток отправляет контрольный токен каждые 5000 токенов. Сохранять новые фрагменты в списке ожидания. Если в фрагменте есть continuation_token, переместите ожидающие фрагменты в зафиксированный выходной файл и сохраните токен. Если поток прерывается, отбросьте ожидающие фрагменты и возобновите работу с последнего токена. Если трансляция прервется до первой контрольной точки, отправьте исходный запрос повторно.

Установить max_output_tokens

max_output_tokens задает общее ограничение на размышления и вывод данных на всех этапах. Если вы уменьшите его, модель не станет отвечать более лаконично, а просто будет обрывать ответ раньше.

Чтобы использовать меньше токенов, уменьшите значение thinking_level. Используйте high для самых сложных задач, требующих рассуждения. Используйте medium (по умолчанию) для большинства задач по написанию кода и работы с агентами. Для менее сложных задач используйте low.

Как обрабатывать длительные запросы

Поскольку Gemini 4 Argon дольше, чем модели Gemini 3.x, думает над сложными задачами, вам следует увеличить время ожидания клиента, чтобы долгие запросы не отключались раньше времени.

• Звонки без потоковой передачи. Сервер закрывает подключение через 10 минут.
• Потоковая передача вызовов. Сервер закрывает поток через 20 минут.
• Тайм-ауты клиента. Установите тайм-аут чтения HTTP на 20 минут. Если задать тайм-аут на три или пять минут, запрос будет остановлен раньше.

В Python задайте время ожидания для клиента в миллисекундах:

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

Для заданий, которые опрашивает клиент, Interactions API выполняет длительное декодирование на сервере. Подробнее о выполнении в фоновом режиме…

Возобновить, когда модель использует все выходные токены

Если ответ заканчивается на MAX_TOKENS, он все равно включает continuation_token. У вас есть два варианта:

• Продолжить. Отправить тот же запрос с токеном и более высоким значением max_output_tokens. Значение должно быть больше, чем количество использованных токенов. В противном случае API возвращает ошибку 400.
• Начните заново. Отправьте исходный запрос с более высоким значением max_output_tokens и без токена. Вы платите за обе поездки.

Как подсчитать токены

При автоматическом продолжении 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 запрос на 1000 токенов, который создает 200 000 токенов рассуждений и выходных данных, проходит четыре этапа:

prompt_token_count сообщает о примерно 397 000 токенов (при этом повторные входные данные автоматически уменьшаются на 95% за счет неявного кеширования), а total_token_count – о примерно 597 000 токенов, хотя фактический размер контекста составляет всего около 201 000 токенов: запрос на 1000 токенов плюс 200 000 токенов рассуждений и выходных данных. В цикле REST без потоковой передачи используется 32 000 переходов, поэтому для получения того же результата требуется семь переходов и 695 128 входных токенов.

prompt_token_count и total_token_count – это сумма всех переходов, а не размер контекста. Не используйте их, чтобы решать, когда следует сокращать историю чата (сжатие контекста) или применять ограничение на контекст. Чтобы оценить размер контекста, добавьте размер запроса из таблицы к candidates_token_count и thoughts_token_count.

Прежде чем запускать декодирование длинных запросов, обновите фреймворк агента, инструмент оценки или прокси-сервер.

• Агенты и инструменты оценки. Если ваш код сжимает контекст или останавливает выполнение при достижении лимита токенов, используйте initial_prompt_token_count (или prompt_token_count первого перехода в REST) вместо суммированного prompt_token_count. Ответы, которые завершаются за один переход, сообщают одно и то же значение в обоих полях, поэтому короткие тесты не показывают проблему.
• Прокси-серверы и шлюзы, вызывающие REST. Каждый ответ REST сообщает только о собственном переходе. Сложите значения полей для всех переходов, чтобы получить стоимость, и сохраните значение promptTokenCount первого перехода в качестве размера запроса. В противном случае пользователи будут видеть другие числа, чем пользователи SDK, для одного и того же запроса.
• Журналы и сериализованные ответы. SDK рассчитывает initial_prompt_token_count на стороне клиента. Его нет в ответе REST или в выходных данных JSON SDK, например model_dump(). Если вам понадобится это значение позже, сохраните его отдельно.

Если вы транслируете видео в цикле, то значение usage_metadata будет накапливаться в рамках каждой трансляции. Сохраните только последнее значение каждого потока, а затем сложите значения по переходам.

Оплата

Вы платите за каждый токен на каждом этапе, включая этапы, содержащие только рассуждения.

• Скидка на кеширование. При неявном кешировании повторный ввод на каждом шаге уменьшается на 95%. В течение ознакомительного периода цена за 1 млн токенов кешированных входных данных составляет 0,10 доллара США вместо 2,00 долларов США.
• Срок действия кеша. Кеш удаляется, если он не используется в течение 15–20 минут. Если между прыжками проходит много времени, то за следующий прыжок снова взимается полная стоимость.
• Неудачные переходы без потоковой передачи. Вы платите только за завершенные ответы. Неудачные или отмененные запросы не оплачиваются.
• Прерванные трансляции. Если трансляция прерывается до того, как будет сгенерировано 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 для размера контекста и сжатия.
• Прежде чем запускать большую оценку, выполните один запрос в качестве теста.

Дальнейшие действия

• Что нового в Gemini 4 Argon
• Размышления
• Подсчет токенов