Длинные ответы и продолжение генерации

Как получать длинные ответы без потерь: stream=True с записью чанков в файл, продолжение после finish_reason="length" с места обрыва, разбиение большого документа на секции, лимиты max_tokens и max_completion_tokens, повторы на 429/5xx и заголовки для поддержки.

Модель останавливается, когда достигает лимита вывода, а не когда ответ закончен. Последний чанк потока сообщает причину в finish_reason: stop — модель закончила, length — ответ обрезан лимитом. Считайте length незавершённым ответом, а не ошибкой.

В примере используется gpt-6.1-sol; код работает с любой чат-моделью каталога. Замените id модели, остальной поток останется тем же.

1. Поток в файл и finish_reason

При stream=True SDK отдаёт чанки по мере поступления. Записывайте каждый delta.content на диск сразу: если соединение оборвётся, уже полученный текст останется. Последний чанк содержит finish_reason.

# pip install openai
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://plusvibeapi.ru/v1",
    api_key=os.environ["PLUSVIBE_API_KEY"],
)

def stream_to_file(messages, path, *, model="gpt-6.1-sol", max_completion_tokens=8192):
    # Пишем каждый чанк на диск и возвращаем текст, finish_reason и id запроса.
    text = []
    finish_reason = None
    with open(path, "w", encoding="utf-8") as out:
        stream = client.chat.completions.create(
            model=model,
            messages=messages,
            max_completion_tokens=max_completion_tokens,
            stream=True,
        )
        # id запроса уже в заголовках ответа, до первого чанка
        response = getattr(stream, "response", None)
        request_id = response.headers.get("x-plusvibe-request-id") if response is not None else None
        for chunk in stream:
            if not chunk.choices:
                continue  # финальный usage-чанк может быть без choices
            choice = chunk.choices[0]
            delta = choice.delta.content
            if delta:
                text.append(delta)
                out.write(delta)
                out.flush()  # байты уже на диске, даже если соединение оборвётся
            if choice.finish_reason:
                finish_reason = choice.finish_reason
    return "".join(text), finish_reason, request_id
stream.response — HTTP-ответ, лежащий в основе потока; id запроса уже в его заголовках, до первого токена.

2. Продолжение оборванного ответа

Если finish_reason равен length, ответ упёрся в лимит вывода. Добавьте полученный текст как сообщение assistant и попросите модель продолжить ровно с места обрыва. Не отправляйте исходный запрос заново как новый ход пользователя: модель начнёт сначала. Повторяйте, пока finish_reason не станет отличным от length, затем склейте части.

# stream_to_file() is defined in the previous example.
MAX_CONTINUATIONS = 8

def generate_long(messages, *, model="gpt-6.1-sol", out_path="answer.txt"):
    parts = []
    conversation = list(messages)
    finish_reason = None
    request_id = None

    for round_no in range(MAX_CONTINUATIONS + 1):
        part_path = f"{out_path}.part{round_no:02d}.txt"
        text, finish_reason, request_id = stream_to_file(
            conversation, part_path, model=model
        )
        parts.append(text)

        if finish_reason != "length":
            break
        if round_no == MAX_CONTINUATIONS:
            raise RuntimeError(
                f"ответ всё ещё обрезан после {MAX_CONTINUATIONS} продолжений; "
                f"request_id={request_id}"
            )

        # Модель видит свой текст как ответ assistant и продолжает ровно с обрыва.
        conversation.append({"role": "assistant", "content": text})
        conversation.append({
            "role": "user",
            "content": (
                "Продолжи ровно с места, где оборвался предыдущий ответ. "
                "Не повторяй и не переформулируй уже написанное."
            ),
        })

    answer = "".join(parts)
    with open(out_path, "w", encoding="utf-8") as out:
        out.write(answer)
    return answer, finish_reason, request_id
Лимит — страховка, а не цель. Если reasoning-модель вернула length почти без видимого текста, сначала увеличьте лимит вывода или уменьшите reasoning effort, а уже потом добавляйте раунды продолжения.

3. Большой документ по секциям

Цикл продолжения держит весь ответ в одном контексте: это дорого и в какой-то момент упирается в контекстное окно. Для большого документа разбейте текст по заголовкам, а слишком длинную секцию — по границам абзацев, и обрабатывайте секции по одной.

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

import os
import re
from pathlib import Path
from openai import OpenAI

client = OpenAI(
    base_url="https://plusvibeapi.ru/v1",
    api_key=os.environ["PLUSVIBE_API_KEY"],
)

MAX_SECTION_CHARS = 12000

def split_sections(text, max_chars=MAX_SECTION_CHARS):
    # Сначала по заголовкам Markdown, затем длинную секцию — по границам абзацев.
    blocks = re.split(r"(?m)^(?=#{1,3}\s)", text)
    sections = []
    for block in blocks:
        block = block.strip()
        if not block:
            continue
        while len(block) > max_chars:
            cut = block.rfind("\n\n", 0, max_chars)
            if cut <= 0:
                cut = max_chars
            sections.append(block[:cut].strip())
            block = block[cut:].strip()
        if block:
            sections.append(block)
    return sections

def process_document(path, instruction, *, model="gpt-6.1-sol"):
    sections = split_sections(Path(path).read_text(encoding="utf-8"))
    results = []
    for index, section in enumerate(sections, start=1):
        prompt = (
            f"Секция {index} из {len(sections)}.\n"
            f"Задача: {instruction}\n"
            "Работай только с этой секцией; не повторяй вывод других секций.\n\n"
            f"{section}"
        )
        response = client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": prompt}],
            max_completion_tokens=4096,
        )
        answer = response.choices[0].message.content or ""
        results.append(f"## Секция {index}\n\n{answer}")
        # Сохраняем после каждой секции: сбой стоит одной секции, а не всего документа.
        Path(f"{path}.out.md").write_text("\n\n".join(results), encoding="utf-8")
    return "\n\n".join(results)

4. Лимиты, рассуждения, повторы и поддержка

max_tokens и max_completion_tokens ограничивают сгенерированные токены. max_completion_tokens — более новое поле; у reasoning-моделей лимит включает и скрытые токены рассуждений, и видимый ответ. Задавайте одно из полей осознанно: маленький лимит может дать finish_reason="length" ещё до первого видимого текста.

Повторяйте только 429 и 5xx. Если есть Retry-After, ждите указанное время; иначе используйте экспоненциальную задержку с джиттером и ограничьте число попыток. Не повторяйте 400, 401, 402, 403, 404, 413 и 422: нужно менять запрос или аккаунт.

import os
import random
import time
import openai
from openai import OpenAI

client = OpenAI(
    base_url="https://plusvibeapi.ru/v1",
    api_key=os.environ["PLUSVIBE_API_KEY"],
)

RETRY_STATUS = {429, 500, 502, 503, 504}

def with_retries(call, *, attempts=5):
    for attempt in range(attempts):
        try:
            return call()
        except openai.APIStatusError as exc:
            if exc.status_code not in RETRY_STATUS or attempt == attempts - 1:
                raise
            header = exc.response.headers.get("retry-after") if exc.response is not None else None
            try:
                delay = float(header) if header is not None else 2 ** attempt
            except ValueError:
                delay = 2 ** attempt
        except openai.APIConnectionError:
            if attempt == attempts - 1:
                raise
            delay = 2 ** attempt
        time.sleep(min(delay, 60) + random.uniform(0, 0.5))

# Open the stream through the retry helper. A stream that breaks mid-answer is resumed
# from the part file, not retried from the beginning.
stream = with_retries(lambda: client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[{"role": "user", "content": "..."}],
    stream=True,
))

Для поддержки сохраните id запроса из заголовков ответа: x-plusvibe-request-id. Это тот же id в истории использования, поэтому поддержка найдёт конкретный запрос. В потоке он появляется в заголовках ответа до первого чанка.

Стоимость списания — в x-pv-cost-rub на не-потоковом ответе; в потоке заголовок доступен, когда известна оценка входа, а финальное usage-событие содержит pv_cost_rub только при x-pv-cost: 1. Фактическое списание всегда в истории использования.

Оборванный поток — не неудавшийся запрос: модель могла сгенерировать, и вы могли оплатить, токены, которые до вас не дошли. Продолжайте с part-файла, а не начинайте заново.
Длинные ответы и продолжение генерации — стриминг, finish_reason, секции документа | PlusVibeAPI