gpt-6.1-sol: рецепты промптов для кодинга, рассуждений, JSON и вызова инструментов (с реальными выводами)

gpt-6.1-sol — это текстовая модель уровня рассуждений на hiapi: диалог, кодинг и пошаговые рассуждения, доступные через Responses API (POST /v1/responses). Если вы уже знаете, как её вызывать, эта страница — следующий шаг: набор рецептов промптов, которые можно скопировать и вставить, охватывающих четыре наиболее часто используемых на практике типа задач — кодинг, рассуждения, строгий JSON и вызов инструментов — и каждый рецепт сопровождается точным выводом, который мы получили, запуская его для этой статьи. По вопросам аутентификации, потоковой передачи и разбора SSE начните с руководства по настройке; здесь мы сосредоточимся только на самих промптах.

Каждый рецепт ниже — это тело запроса, которое можно сразу поместить в эту настройку. Промпт задаётся двумя полями: верхнеуровневым instructions (роль и правила форматирования) и массивом input (сама задача). Здесь нет никакой теории — выводы дословно скопированы из реальных событий response.completed.

Три рычага, влияющих на то, как вы пишете промпты для gpt-6.1-sol

Прежде чем перейти к рецептам, три вещи о модели формируют каждый промпт, который вы пишете. Все три подтверждены по текущему контракту модели на hiapi.

1. Нет temperature и нет top_p. Эта конфигурация выполнения отключает оба параметра (а также max_output_tokens). Вы не можете регулировать детерминированность или креативность с помощью сэмплирования — единственные доступные ручки — это ваши instructions, ваш input и reasoning.effort. Если вы хотите лаконичный, почти детерминированный вывод, укажите это в instructions; вы не можете установить temperature: 0.
2. reasoning.effort имеет пять уровней: low, medium, high, xhigh, max (по умолчанию medium). Более высокий effort расходует больше скрытых токенов рассуждений — а они тарифицируются как выходные токены. Рецепт 2 показывает реальную кривую.
3. Окно контекста около 1,05 млн токенов (максимальный вывод 128K). Тарификация по токенам ступенчатая: как только вход одного запроса превышает 272K токенов, ставки ввода/вывода примерно удваиваются. Для повседневных промптов вы до этой черты далеко не дотянетесь; для задач с длинным контекстом (рецепт 5) об этом стоит знать.

Рецепт 1 — кодинг: сгенерировать функцию по спецификации

Поместите инженерную роль и форму вывода в instructions, а спецификацию — в input. Ограничение формы («один блок кода в ограждении, затем одно предложение») — именно то, что мешает модели рассуждений обернуть код тремя абзацами вступления.

{
  "model": "gpt-6.1-sol",
  "instructions": "Вы — старший инженер Python. Верните один блок кода Python в ограждении, затем одним предложением опишите сложность. Без вступлений.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Напишите `merge_intervals(intervals: list[list[int]]) -> list[list[int]]`, которая объединяет перекрывающиеся замкнутые интервалы и возвращает их, отсортировав по началу. Обработайте пустой список. Включите docstring." }
    ] }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

То, что она вернула (дословно):

def merge_intervals(intervals: list[list[int]]) -> list[list[int]]:
    """Объединяет перекрывающиеся замкнутые интервалы и возвращает их, отсортировав по началу.

    Входной список и интервалы в нём не изменяются.
    """
    if not intervals:
        return []

    ordered = sorted(intervals, key=lambda interval: interval[0])
    merged = [ordered[0].copy()]

    for start, end in ordered[1:]:
        if start <= merged[-1][1]:
            merged[-1][1] = max(merged[-1][1], end)
        else:
            merged.append([start, end])

    return merged

Временная сложность — O(n log n), пространственная — O(n).

Обратите внимание, что дало ограничение: она корректно обработала случай пустого списка, скопировала каждый интервал перед изменением (ordered[0].copy()), так что данные вызывающего кода не были затронуты, и остановилась ровно на одном аналитическом предложении. Для такого механического кодинга effort: low вполне достаточно — она использовала ноль токенов рассуждений и всё равно сгенерировала корректный код без изменения на месте.

Рецепт 2 — рассуждения: управление бюджетом размышлений через effort

Поскольку temperature установить нельзя, reasoning.effort — ваша основная ручка для сложных задач. Оставьте промпт неизменным и меняйте только effort:

{
  "model": "gpt-6.1-sol",
  "instructions": "Думайте пошагово, затем завершите строкой `Answer: <value>`.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Пекарня продаёт печенье в коробках по 6 и по 11 штук. Какое наибольшее количество печенья невозможно купить ровно? Покажите рассуждение." }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Мы запустили один и тот же промпт на всех пяти уровнях effort. Каждый уровень вернул правильный ответ 49. Различалось то, сколько размышлений на это ушло:

reasoning.effort	Токены рассуждений	Всего выходных токенов	Примерная стоимость*
low	76	305	≈ $0,0008
medium	121	380	≈ $0,0010
high	209	427	≈ $0,0011
xhigh	626	845	≈ $0,0021
max	622	813	≈ $0,0021

*По базовым ставкам ($0,50 / 1M ввода, $2,50 / 1M вывода); токены рассуждений тарифицируются как выходные. Данные из этого запуска по состоянию на 2026-10. Актуальные ставки смотрите на странице цен.

Практический урок в последних двух строках: effort плавно растёт от low до high, а затем выходит на плато — xhigh и max оба останавливаются примерно на 620 токенах рассуждений, потому что эта задача просто недостаточно сложна, чтобы требовать больше размышлений. Выкручивание effort на максимум для простого промпта не даёт лучшего ответа; оно просто тратит примерно в 2,5 раза больше выходных токенов на то же «49». Сопоставляйте effort со сложностью: для большинства промптов используйте low/medium, и только когда задача действительно требует более глубокого поиска — high и выше.

Вот вывод с medium, чтобы вы увидели, какую форму дал промпт:

Наибольшее число — 49 печений.

1. Доказательство, что 49 невозможно купить ровно. Предположим, 49 = 6a + 11b, где a, b — неотрицательные целые. Взяв обе стороны по модулю 6, получаем 5b ≡ 1 (mod 6), следовательно b ≡ 5 (mod 6). Значит, b не меньше 5, но пять коробок по 11 уже содержат 55 печений. Это невозможно.

2. Доказательство, что любое число больше 49 можно купить ровно. …Каждое целое не меньше 50 является одним из шести последовательных достижимых итогов плюс неотрицательное кратное 6.

Answer: 49

Строка Answer: <value> в instructions действительно работает: она позволяет вам просто разобрать последнюю строку (text.rsplit("Answer:", 1)[-1].strip()), не заставляя модель отбрасывать процесс рассуждений.

Рецепт 3 — строгий JSON со схемой

Не просите JSON в прозе и не надейтесь. gpt-6.1-sol поддерживает строгий структурированный вывод: передайте text.format с json_schema, и модель будет ограничена выводом соответствующего JSON — без ограждений кода, без лишней прозы.

{
  "model": "gpt-6.1-sol",
  "instructions": "Классифицируйте тикет поддержки. Отвечайте только этим JSON-объектом.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Тикет: 'С сегодняшнего утра эндпоинт 4K-апскейла возвращает 500 при каждом вызове. Завтра у нас релиз, и это нас блокирует.'" }
    ] }
  ],
  "text": {
    "format": {
      "type": "json_schema",
      "name": "ticket",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "sentiment": { "type": "string", "enum": ["positive", "neutral", "negative"] },
          "topics": { "type": "array", "items": { "type": "string" } },
          "action_required": { "type": "boolean" }
        },
        "required": ["sentiment", "topics", "action_required"],
        "additionalProperties": false
      }
    }
  },
  "reasoning": { "effort": "low" },
  "stream": true
}

То, что она вернула (дословно, одна строка):

{"action_required":true,"sentiment":"negative","topics":["4K upscale endpoint","HTTP 500 errors","Service outage","Launch blocker","Urgent support"]}

Две вещи нужно усвоить. Во-первых, strict: true гарантирует типы и обязательные ключи, но не порядок ключей — обратите внимание, что action_required идёт первым, хотя в схеме он указан последним, поэтому разбирайте по ключам и никогда по позиции. Во-вторых, ответ всё равно нужно накапливать из блоков response.output_text.delta, как и любой другой ответ; схема формирует содержимое, а не способ передачи.

Рецепт 4 — вызов инструментов и продолжение по результату

gpt-6.1-sol может вызывать функции и — что важно — продолжать после того, как вы вернёте результат. Объявите массив tools; когда модель решает вызвать инструмент, она выдаёт элемент function_call вместо текста.

{
  "model": "gpt-6.1-sol",
  "instructions": "Вы можете вызывать инструменты. Когда пользователь спрашивает о задаче, вызывайте get_task_status.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Можете проверить, что с task_abc123? Он уже давно в состоянии pending." }
    ] }
  ],
  "tools": [
    {
      "type": "function",
      "name": "get_task_status",
      "description": "Запрашивает статус асинхронной задачи генерации изображения/видео по id.",
      "parameters": {
        "type": "object",
        "properties": { "task_id": { "type": "string", "description": "id задачи, например 'task_abc123'." } },
        "required": ["task_id"],
        "additionalProperties": false
      }
    }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Ответ не содержал текста — только вызов инструмента, переданный как элемент function_call в финальном событии (его аргументы передаются потоком в блоках response.function_call_arguments.delta):

{
  "type": "function_call",
  "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b",
  "name": "get_task_status",
  "arguments": "{\"task_id\":\"task_abc123\"}"
}

Теперь вторая половина, которую не покрывает базовая настройка: выполните свою функцию и верните результат обратно — добавьте function_call модели и ваш function_call_output (связанный тем же call_id) в массив input, затем вызовите снова:

{
  "model": "gpt-6.1-sol",
  "instructions": "Вы можете вызывать инструменты. Суммируйте результат инструмента для пользователя в одном-двух предложениях.",
  "input": [
    { "type": "message", "role": "user", "content": [ { "type": "input_text", "text": "Можете проверить, что с task_abc123? Он уже давно в состоянии pending." } ] },
    { "type": "function_call", "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b", "name": "get_task_status", "arguments": "{\"task_id\":\"task_abc123\"}" },
    { "type": "function_call_output", "call_id": "call_e4a8a52c6db04cafb6a744f3727c456b", "output": "{\"status\":\"failed\",\"error\":\"INVALID_REQUEST: image url could not be downloaded\",\"created_at\":\"2026-10-17T06:12:00Z\"}" }
  ],
  "tools": [ { "type": "function", "name": "get_task_status", "description": "Запрашивает статус асинхронной задачи генерации по id.", "parameters": { "type": "object", "properties": { "task_id": { "type": "string" } }, "required": ["task_id"], "additionalProperties": false } } ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Получив результат, она отвечает простым языком (дословно):

Задача task_abc123 больше не в состоянии pending — она завершилась с ошибкой, потому что URL изображения не удалось загрузить (INVALID_REQUEST). Проверьте, что URL изображения общедоступен, и отправьте задачу заново.

call_id — это связующее звено: ваш function_call_output должен повторять точный call_id из function_call модели, иначе следующий ход не будет к нему привязан.

Рецепт 5 — обоснованные ответы на длинном контексте

Окно в 1,05M токенов предназначено для того, чтобы подавать реальный материал — логи, changelog, спецификации — и отвечать на вопросы по нему. Шаблон промпта, который заставляет его быть честным, находится в instructions: обяжите отвечать только по предоставленному тексту и ссылаться на источник каждого факта.

{
  "model": "gpt-6.1-sol",
  "instructions": "Отвечайте строго по предоставленному CHANGELOG. Если факта там нет, скажите 'not in the changelog'. Указывайте дату каждого использованного факта.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "<вставьте сюда CHANGELOG>\nВопрос: вчера выходной URL одной видеозадачи вернул мой файл, а сегодня он отдаёт 404, плюс мои вызовы изображений только что начали возвращать 402. Какие две записи changelog это объясняют и что мне изменить?" }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Получив короткий changelog платформы, она точно извлекла две релевантные записи, указала их даты и отделила «что произошло» от «что изменить» (дословно):

Эти проблемы объясняют две записи:

1. 2026-10-02 — временные выходные URL истекают. Выходные URL на temp.hiapi.ai действительны 7 дней, после чего возвращают 404… Изменение: немедленно скачивайте байты и храните свою собственную копию; не делайте хотлинкинг. Отслеживайте истечение с помощью expireAt.

2. 2026-09-20 — нулевой баланс вызывает 402 на моделях изображений. Аккаунты с полностью нулевым балансом теперь получают HTTP 402 на всех моделях изображений… Изменение: проверьте, не равен ли ваш баланс аккаунта нулю, и если да, пополните его.

Инструкция «указывайте даты» — дешёвый приём для обоснованности: она делает галлюцинации видимыми (факт, на который нечем указать дату, — это факт, который она выдумала), и делает ответ проверяемым. Помните о ступенчатой тарификации — промпты с входом более 272K токенов тарифицируются по более высокой ставке для длинного контекста.

Одна ловушка этого запуска: декодирование потока как UTF-8

Модели рассуждений любят длинные тире и фигурные кавычки. На момент написания статьи наш первый SSE-ридер разорвал многобайтовый символ UTF-8 между двумя сетевыми блоками, превратив чистое длинное тире («—») в мусор («â»). Вывод модели был в порядке; это клиент слишком нетерпеливо декодировал построчно. Решение — буферизовать сырые байты, разделять по символу новой строки и декодировать каждую полную строку как UTF-8 — не декодируйте неполные блоки. Если в вашем выводе gpt-6.1-sol sporadически появляются символы Ã/â, причина здесь, а не в модели.

Частые вопросы

Чем это отличается от руководства по настройке gpt-6.1-sol? Руководство по настройке рассказывает о том, как вызывать модель — аутентификация, почему нужна потоковая передача, разбор SSE. Эта страница рассказывает о том, как писать промпты для неё — шаблоны instructions/input/effort для конкретных задач и вывод, который они дают.

Можно ли просто поднять reasoning.effort до max, чтобы получить лучший ответ? Не бесплатно и часто не лучше. На нашей тестовой задаче xhigh и max оба вышли на плато около 620 токенов рассуждений и вернули тот же ответ, что и high. Токены рассуждений тарифицируются как выходные, поэтому выкручивание простого промпта на максимум стоит больше за тот же результат. Оставляйте high+ для действительно сложных рассуждений.

Как заставить модель выдавать валидный JSON, а не просто просить об этом в промпте? Передайте text.format с strict json_schema (рецепт 3). Модель будет ограничена типами и обязательными ключами схемы. Разбирайте по именам ключей, поскольку strict не фиксирует порядок ключей.

Почему я не могу установить temperature или top_p? Эта конфигурация выполнения отключает оба параметра (а также max_output_tokens). Формируйте вывод через instructions, ваш input и reasoning.effort.

Работает ли вызов инструментов так же, как в чат-моделях? Контракт немного отличается: инструменты объявляются в верхнеуровневом массиве tools, модель отвечает элементом function_call (а не сообщением), и вы продолжаете, добавляя function_call_output с совпадающим call_id (рецепт 4).

gpt-6.1-sol — то же самое, что gpt-5.6-sol? Они из семейства Sol, разделяют этот контракт Responses-API только с потоковой передачей; gpt-6.1-sol — более новое поколение. См. сравнение gpt-6 Astra и gpt-5.6 Sol, чтобы понять, как поколения соотносятся друг с другом.

С чего начать

Скопируйте любой рецепт выше в тело запроса из руководства по настройке, замените на свою задачу и подстройте reasoning.effort под сложность. Описание возможностей и поле для онлайн-проб находятся на странице модели gpt-6.1-sol; эндпоинты и общий формат запросов — в документации API; ставки за токен — на странице цен. Один ключ hiapi открывает доступ к gpt-6.1-sol и всем остальным моделям на платформе.