Receitas de prompts do gpt-6.1-sol: codificação, raciocínio, JSON e chamada de ferramentas (com saídas reais)

gpt-6.1-sol é um modelo de texto de nível de raciocínio na hiapi — conversa, codificação e raciocínio passo a passo, tudo servido pela Responses API (POST /v1/responses). Se você já sabe como chamá-lo, esta página é o próximo passo: um conjunto de receitas de prompts prontas para copiar e colar, cobrindo os quatro tipos de tarefa que as pessoas mais usam na prática — codificação, raciocínio, JSON estrito e chamada de ferramentas — cada receita acompanhada da saída exata que obtivemos ao executá-la de fato para este artigo. Para autenticação, streaming e parsing de SSE, comece pelo guia de configuração; aqui focamos apenas nos prompts em si.

Cada receita abaixo é um corpo de requisição que você pode colocar diretamente nessa configuração. O prompt é carregado por dois campos: o instructions de nível superior (definição de papel e regras de formato) e o array input (a tarefa em si). Não há nada de teórico aqui — as saídas foram coladas literalmente de eventos reais de response.completed.

Três alavancas que moldam como você escreve prompts para o gpt-6.1-sol

Antes de entrar nas receitas, três coisas sobre este modelo moldam cada prompt que você escrever. Todas as três foram confirmadas contra o contrato em tempo real do modelo na hiapi.

1. Não há temperature nem top_p. Esta configuração de execução desabilita ambos (e também max_output_tokens). Você não pode ajustar determinismo ou criatividade via amostragem — o único botão ajustável é o seu instructions, o seu input e reasoning.effort. Se você quer uma saída concisa que pareça determinística, diga isso em instructions; você não pode definir temperature: 0.
2. reasoning.effort tem cinco níveis: low, medium, high, xhigh, max (padrão medium). Um effort mais alto consome mais tokens de raciocínio ocultos — e eles são cobrados como tokens de saída. A receita 2 mostra a curva real.
3. Janela de contexto de cerca de 1,05M de tokens (saída máxima de 128K). A cobrança por token é escalonada: quando a entrada de uma única requisição ultrapassa 272K tokens, as tarifas de entrada/saída praticamente dobram. Para prompts do dia a dia você fica longe dessa linha; para tarefas de contexto longo (receita 5), vale saber disso.

Receita 1 — Codificação: gerar uma função a partir de uma especificação

Coloque o papel de engenharia e a forma da saída em instructions, e a especificação em input. Restringir a forma ("um único bloco de código cercado, depois uma frase") é justamente o que impede um modelo de raciocínio de embrulhar o código em três parágrafos de preâmbulo.

{
  "model": "gpt-6.1-sol",
  "instructions": "Você é um engenheiro Python sênior. Retorne um único bloco de código Python cercado e, em seguida, uma frase explicando a complexidade. Sem preâmbulo.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Escreva `merge_intervals(intervals: list[list[int]]) -> list[list[int]]`, que mescla intervalos fechados sobrepostos e os retorna ordenados pelo ponto inicial. Trate a lista vazia. Inclua docstring." }
    ] }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

O que ele retornou (literalmente):

def merge_intervals(intervals: list[list[int]]) -> list[list[int]]:
    """Mescla intervalos fechados sobrepostos e os retorna ordenados pelo ponto inicial.

    A lista de entrada e os intervalos dentro dela não são modificados.
    """
    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

Complexidade de tempo O(n log n), complexidade de espaço O(n).

Note o que a restrição trouxe: ele tratou corretamente o caso de lista vazia, copiou cada intervalo antes de modificar (ordered[0].copy()) para que os dados do chamador não fossem alterados, e parou exatamente após uma frase de análise. Para codificação mecânica como essa, effort: low é suficiente — ele usou zero tokens de raciocínio e ainda assim gerou código correto e sem modificação in-place.

Receita 2 — Raciocínio: controlar o orçamento de pensamento com effort

Como você não pode definir temperature, reasoning.effort é o seu principal botão para problemas difíceis. Mantenha o prompt igual e apenas mude o effort:

{
  "model": "gpt-6.1-sol",
  "instructions": "Pense passo a passo e termine com uma linha `Answer: <value>`.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Uma padaria vende biscoitos em caixas de 6 e de 11. Qual é a maior quantidade de biscoitos que não pode ser comprada exatamente? Mostre o raciocínio." }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Executamos o mesmo prompt em todos os cinco níveis de effort. Todos os níveis retornaram a resposta correta 49. O que mudou foi quanto pensamento ele gastou para chegar lá:

reasoning.effort	Tokens de raciocínio	Total de tokens de saída	Custo aproximado*
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

*Com base nas tarifas do nível básico ($0.50 / 1M entrada, $2.50 / 1M saída); tokens de raciocínio são cobrados como saída. Dados desta execução, referentes a 2026-10. Para tarifas atuais, consulte a página de preços.

A lição prática está nas duas últimas linhas: o effort sobe suavemente de low a high e então entra em platô — xhigh e max ficam ambos em cerca de 620 tokens de raciocínio, porque esse problema simplesmente não é difícil o suficiente para exigir mais pensamento. Levar o effort de um prompt simples ao máximo não compra uma resposta melhor; apenas gasta cerca de 2,5× mais tokens de saída pelo mesmo "49". Combine o effort com a dificuldade: low/medium para a maioria dos prompts, e só use high ou acima quando a tarefa realmente exigir uma busca mais profunda.

A seguir está a saída de medium, para você ver que forma o prompt produziu:

O maior número é 49 biscoitos.

1. Prova de que 49 não pode ser comprado exatamente. Suponha 49 = 6a + 11b, com a e b inteiros não negativos. Tomando ambos os lados módulo 6, obtemos 5b ≡ 1 (mod 6), logo b ≡ 5 (mod 6). Portanto b é no mínimo 5, mas cinco caixas de 11 já contêm 55 biscoitos. Impossível.

2. Prova de que todo número acima de 49 pode ser comprado. … todo inteiro de pelo menos 50 é um entre seis totais consecutivos alcançáveis somados a um múltiplo não negativo de 6.

Answer: 49

A linha Answer: <value> em instructions realmente faz seu trabalho: ela permite que você simplesmente faça parsing da última linha (text.rsplit("Answer:", 1)[-1].strip()) sem forçar o modelo a descartar seu raciocínio.

Receita 3 — JSON estrito com schema

Não peça JSON em prosa e depois reze. O gpt-6.1-sol suporta saídas estruturadas estritas: passe um text.format com json_schema e o modelo fica restrito a emitir JSON que atenda aos requisitos — sem cercas de código, sem prosa extra.

{
  "model": "gpt-6.1-sol",
  "instructions": "Classifique o ticket de suporte. Responda apenas com o objeto JSON.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Ticket: 'Desde hoje de manhã, o endpoint de upscale 4K retorna 500 em toda chamada. Temos lançamento amanhã e isso está nos bloqueando.'" }
    ] }
  ],
  "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
}

O que ele retornou (literalmente, em uma linha):

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

Duas coisas a internalizar. Primeiro, strict: true garante tipos e chaves obrigatórias, mas não garante a ordem das chaves — note que action_required aparece primeiro, embora esteja listada por último no schema; portanto faça parsing por chave, nunca por posição. Segundo, você ainda precisa acumular a resposta a partir dos blocos response.output_text.delta como em qualquer outra resposta; o schema molda o conteúdo, não o transporte.

Receita 4 — Chamada de ferramentas e continuação com resultado

O gpt-6.1-sol pode chamar funções e — o que importa — continuar depois que você retorna o resultado. Declare um array tools; quando o modelo decide chamar, ele emite um item function_call em vez de texto.

{
  "model": "gpt-6.1-sol",
  "instructions": "Você pode chamar ferramentas. Quando o usuário perguntar sobre uma tarefa, chame get_task_status.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "Você pode verificar o que aconteceu com task_abc123? Está pending há muito tempo." }
    ] }
  ],
  "tools": [
    {
      "type": "function",
      "name": "get_task_status",
      "description": "Consulta o status de uma tarefa assíncrona de geração de imagem/vídeo pelo id.",
      "parameters": {
        "type": "object",
        "properties": { "task_id": { "type": "string", "description": "Id da tarefa, por exemplo 'task_abc123'." } },
        "required": ["task_id"],
        "additionalProperties": false
      }
    }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

A resposta não trouxe texto — apenas uma chamada de ferramenta, entregue como um item function_call no evento final (seus argumentos chegam em streaming por blocos response.function_call_arguments.delta):

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

Agora vem a segunda metade que a configuração básica não cobre: execute sua função e devolva o resultado — anexe o function_call do modelo e o seu function_call_output (associado pelo mesmo call_id) ao array input e chame novamente:

{
  "model": "gpt-6.1-sol",
  "instructions": "Você pode chamar ferramentas. Resuma o resultado da ferramenta para o usuário em uma ou duas frases.",
  "input": [
    { "type": "message", "role": "user", "content": [ { "type": "input_text", "text": "Você pode verificar o que aconteceu com task_abc123? Está pending há muito tempo." } ] },
    { "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": "Consulta o status de uma tarefa assíncrona de geração pelo id.", "parameters": { "type": "object", "properties": { "task_id": { "type": "string" } }, "required": ["task_id"], "additionalProperties": false } } ],
  "reasoning": { "effort": "low" },
  "stream": true
}

Com o resultado em mãos, ele responde em linguagem simples (literalmente):

A tarefa task_abc123 não está mais pending — ela falhou porque a URL da imagem não pôde ser baixada (INVALID_REQUEST). Verifique se a URL da imagem está acessível publicamente e reenvie a tarefa.

O call_id é o elo: seu function_call_output deve ecoar o call_id exato do function_call do modelo, caso contrário o turno seguinte não se vincula a ele.

Receita 5 — Respostas fundamentadas em contexto longo

A janela de 1,05M tokens existe para você alimentar material real — logs, changelogs, documentos de especificação — e responder perguntas com base nele. O padrão de prompt que o mantém honesto está em instructions: force-o a responder apenas com base no texto fornecido e a citar a fonte de cada fato.

{
  "model": "gpt-6.1-sol",
  "instructions": "Responda estritamente com base no CHANGELOG fornecido. Se um fato não existir, diga 'não está no changelog'. Cite a data de cada fato que usar.",
  "input": [
    { "type": "message", "role": "user", "content": [
      { "type": "input_text", "text": "<cole o CHANGELOG aqui>\nPergunta: a URL de saída de uma tarefa de vídeo me retornou meu arquivo ontem, mas hoje deu 404, e além disso minhas chamadas de imagem começaram a retornar 402. Quais duas entradas do changelog explicam isso e o que devo mudar?" }
    ] }
  ],
  "reasoning": { "effort": "medium" },
  "stream": true
}

Dado um changelog curto da plataforma, ele extraiu com precisão as duas entradas relevantes, citou suas datas e separou "o que aconteceu" de "o que mudar" (literalmente):

Duas entradas explicam esses problemas:

1. 2026-10-02 — URLs de saída temporárias expiram. As URLs de saída em temp.hiapi.ai são válidas por 7 dias e depois retornam 404… Mudança: baixe os bytes imediatamente e armazene sua própria cópia; não faça hotlink. Use expireAt para acompanhar a expiração.

2. 2026-09-20 — saldo zerado dispara 402 nos modelos de imagem. Contas com saldo totalmente zerado agora recebem HTTP 402 em todos os modelos de imagem… Mudança: verifique se o saldo da sua conta está totalmente zerado e, se estiver, faça uma recarga.

A instrução "cite a data" é um truque barato de fundamentação: ela torna as alucinações visíveis (um fato sem data para citar é um fato que ele inventou) e torna a resposta auditável. Lembre-se do preço escalonado — prompts com mais de 272K tokens de entrada são cobrados pela tarifa mais alta de contexto longo.

Uma armadilha desta execução: decodificar o stream como UTF-8

Modelos de raciocínio adoram travessões longos e aspas curvas. Ao escrever este artigo, nosso primeiro leitor de SSE dividiu um caractere UTF-8 multibyte entre dois blocos de rede, transformando um travessão limpo ("—") em lixo ("â"). A saída do modelo estava correta; foi o cliente que decodificou por linha cedo demais. A correção é armazenar em buffer os bytes brutos, dividir por quebras de linha e decodificar cada linha completa como UTF-8 — nunca decodifique blocos incompletos. Se a sua saída do gpt-6.1-sol mostrar caracteres esporádicos como Ã/â, a causa está aqui, não no modelo.

Perguntas frequentes

Qual é a diferença entre esta página e o guia de configuração do gpt-6.1-sol? O guia de configuração trata de chamar o modelo — autenticação, por que o streaming é obrigatório, parsing de SSE. Esta página trata de promptar o modelo — os padrões de instructions/input/effort para tarefas específicas e as saídas que eles produzem.

Posso simplesmente definir reasoning.effort como max para obter as melhores respostas? Não de graça, e muitas vezes nem para melhorar. No nosso problema de teste, tanto xhigh quanto max entraram em platô, com cerca de 620 tokens de raciocínio, retornando a mesma resposta que high. Tokens de raciocínio são cobrados como saída, então levar um prompt simples ao máximo gasta mais dinheiro pelo mesmo resultado. Deixe high ou acima para raciocínios realmente difíceis.

Como forçar um JSON válido em vez de pedi-lo no prompt? Passe um text.format com json_schema e strict (receita 3). O modelo fica restrito aos tipos e chaves obrigatórias do schema. Faça parsing pelo nome da chave, porque strict não fixa a ordem das chaves.

Por que não posso definir temperature ou top_p? Esta configuração de execução desabilita ambos (e também max_output_tokens). Molde a saída por meio de instructions, do seu input e de reasoning.effort.

A chamada de ferramentas funciona como nos modelos de chat? O contrato é um pouco diferente: as ferramentas são declaradas no array tools de nível superior, o modelo responde com um item function_call (não com uma mensagem) e você continua anexando um function_call_output com o call_id correspondente (receita 4).

O gpt-6.1-sol é o mesmo que o gpt-5.6-sol? Eles pertencem à mesma família Sol e compartilham este contrato de Responses API, somente streaming; o gpt-6.1-sol é uma geração mais nova. Veja gpt-6 Astra vs gpt-5.6 Sol para entender como as gerações se correspondem.

Comece por aqui

Copie qualquer receita acima para o corpo da requisição do guia de configuração, troque pela sua própria tarefa e ajuste reasoning.effort conforme a dificuldade. A visão geral das capacidades e o playground online ficam na página do modelo gpt-6.1-sol; o endpoint e o formato de requisição compartilhado estão na documentação da API; as tarifas por token estão na página de preços. Uma única chave hiapi dá acesso ao gpt-6.1-sol e a todos os outros modelos da plataforma.