Raciocínio (thinking)

Peça ao modelo que pense antes de responder, escolha o esforço, receba o raciocínio junto da resposta e descubra quais modelos aceitam o controle.

Atualizado em 16 de set. de 2026

Modelos com raciocínio pensam antes de responder: geram um rascunho interno, o raciocínio, e só então a resposta final. Isso melhora tarefas de várias etapas, matemática, código e decisões com muitas restrições, ao custo de mais tokens e mais tempo.

Na API o controle é o mesmo para todos os modelos, seja qual for a tecnologia por trás: você pede o raciocínio com o objeto reasoning, escolhe o esforço, decide se quer ver o traço e recebe tudo no mesmo formato. Os modelos HINOW de texto (hinow/himax, hinow/hinova, hinow/hicode, hinow/higenesis e os demais) aceitam o controle, e a lista completa sai de GET /v1/models, no campo supported_parameters.

Ligar o raciocínio

Basta o objeto reasoning na chamada. O effort diz quanto o modelo pode pensar; medium é um bom começo.

curl https://api.hinow.ai/v1/chat/completions \
  -H "Authorization: Bearer $HINOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "hinow/himax",
    "messages": [{ "role": "user", "content": "Quanto é 17 x 23? Responda só o número." }],
    "reasoning": { "effort": "medium" }
  }'

from openai import OpenAI

client = OpenAI(base_url="https://api.hinow.ai/v1", api_key="HINOW_API_KEY")

resposta = client.chat.completions.create(
    model="hinow/himax",
    messages=[{"role": "user", "content": "Quanto é 17 x 23? Responda só o número."}],
    extra_body={"reasoning": {"effort": "medium"}},
)

mensagem = resposta.choices[0].message
print(mensagem.content)                 # a resposta
print(getattr(mensagem, "reasoning", None))  # o raciocínio, quando o modelo devolve

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.hinow.ai/v1", apiKey: process.env.HINOW_API_KEY });

const resposta = await client.chat.completions.create({
  model: "hinow/himax",
  messages: [{ role: "user", content: "Quanto é 17 x 23? Responda só o número." }],
  reasoning: { effort: "medium" },
} as any);

const mensagem = resposta.choices[0].message as any;
console.log(mensagem.content);    // a resposta
console.log(mensagem.reasoning);  // o raciocínio, quando o modelo devolve

Com o SDK da OpenAI, o objeto reasoning entra em extra_body (Python) ou direto no corpo (JavaScript, com o tipo relaxado): o SDK só repassa o JSON, e a API entende.

Os campos

O objeto reasoning tem quatro campos, todos opcionais:

effortstring

Quanto o modelo pode pensar: `none`, `minimal`, `low`, `medium`, `high`, `xhigh` ou `max`. Informar um nível liga o raciocínio; `none` desliga.

enabledboolean

Liga (`true`) ou desliga (`false`) sem escolher nível. Ligado sem nível usa o padrão do modelo.

excludeboolean

Com `true`, o modelo pensa, mas o raciocínio não volta na resposta: só o `content`.

max_tokensinteger

Orçamento de tokens para o raciocínio, nos modelos que trabalham com orçamento em vez de nível. Informar um orçamento também liga o raciocínio.

Há dois atalhos, para quem já usa outro dialeto:

Campo	Equivale a	Quando usar
`reasoning_effort: "low"`	`reasoning: { effort: "low" }`	Código escrito para o SDK da OpenAI, que expõe esse campo nativamente
`include_reasoning: false`	`reasoning: { exclude: true }`	Integrações antigas no padrão OpenRouter
`thinking: "on"` ou `"off"`	`reasoning: { enabled: true }` ou `{ enabled: false }`	Clientes HINOW anteriores a esta versão; continua aceito

Se mais de um vier na mesma chamada, thinking explícito vence; depois o objeto reasoning; por último reasoning_effort.

Níveis de esforço

O vocabulário é único para toda a API. Cada modelo aplica a escala que tem: alguns trabalham com três degraus, outros com orçamento de tokens, e a API traduz o nível pedido para o controle nativo de cada um.

Nível	Para quê
`minimal` e `low`	Perguntas objetivas, classificação, extração. Pouco custo extra e resposta rápida
`medium`	O padrão para o dia a dia: código, análise de texto, decisões com algumas restrições
`high`	Problemas de várias etapas, revisão de arquitetura, matemática, planejamento de agentes
`xhigh` e `max`	O máximo que o modelo oferece. Reserve para os casos em que a qualidade compensa o tempo

Nos modelos HINOW

Os modelos HINOW trabalham com três degraus: low, medium e high. minimal é tratado como low, e xhigh e max como o degrau mais alto. Ligar o raciocínio sem escolher nível equivale a low.

O que volta

A resposta é o chat.completion de sempre, com o raciocínio ao lado do conteúdo. A chamada acima devolveu:

{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "model": "hinow/himax",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "391",
        "reasoning": "17×23=391",
        "reasoning_details": [
          { "type": "reasoning.text", "text": "17×23=391", "format": "unknown", "index": 0 }
        ]
      },
      "finish_reason": "stop",
      "native_finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 137,
    "completion_tokens": 10,
    "total_tokens": 147,
    "prompt_tokens_details": { "cached_tokens": 0 },
    "completion_tokens_details": { "reasoning_tokens": 6 }
  }
}

Campo	O que diz
`message.reasoning`	O raciocínio como texto. Ausente quando o modelo não devolve traço ou quando você pediu `exclude`
`message.reasoning_details[]`	A forma estruturada: `type` (`reasoning.text`, `reasoning.summary` ou `reasoning.encrypted`), `text`, `format` e `index`. Modelos que assinam o raciocínio trazem `signature`
`message.reasoning_content`	Cópia de `reasoning`, mantida para os clientes que já liam este nome
`native_finish_reason`	O motivo de parada como o modelo reportou, antes da normalização em `finish_reason`
`usage.completion_tokens_details.reasoning_tokens`	Quantos tokens de saída foram raciocínio. Quando o modelo não reporta, a API estima pelo texto
`usage.prompt_tokens_details.cached_tokens`	Tokens de entrada servidos do cache do modelo, quando houver

Para reaproveitar o raciocínio numa próxima chamada, como fazem alguns agentes, devolva a mensagem do assistente com reasoning_details intacto no histórico. Se não precisar dele, mande só content.

Streaming

Com stream: true, o raciocínio chega primeiro, em delta.reasoning (e delta.reasoning_details), e só depois começa delta.content. É o que permite mostrar o "pensando…" ao usuário antes da resposta.

data: {"object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","reasoning":"17","reasoning_details":[{"type":"reasoning.text","text":"17","format":"unknown","index":0}]},"finish_reason":null}]}

data: {"object":"chat.completion.chunk","choices":[{"index":0,"delta":{"reasoning":"×23=391"},"finish_reason":null}]}

data: {"object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"391"},"finish_reason":null}]}

data: {"object":"chat.completion.chunk","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":137,"completion_tokens":11,"total_tokens":148,"completion_tokens_details":{"reasoning_tokens":7}}}

data: [DONE]

stream = client.chat.completions.create(
    model="hinow/himax",
    messages=[{"role": "user", "content": "Quanto é 17 x 23? Responda só o número."}],
    extra_body={"reasoning": {"effort": "low"}},
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta if chunk.choices else None
    if delta is None:
        continue
    pensamento = getattr(delta, "reasoning", None)
    if pensamento:
        print(pensamento, end="", flush=True)      # o raciocínio chega primeiro
    if delta.content:
        print(delta.content, end="", flush=True)   # depois, a resposta

Tokens no fim

O usage vem só no último evento, com reasoning_tokens incluído. Quem fecha a conexão ao ver a resposta perde a contagem.

Esconder o raciocínio

Em produtos onde o usuário não deve ver o rascunho, peça exclude: true. O modelo pensa do mesmo jeito e a resposta vem sem reasoning e sem reasoning_details, em streaming ou não.

const resposta = await client.chat.completions.create({
  model: "hinow/hinova",
  messages: [{ role: "user", content: "Resuma o texto a seguir em três frases: ..." }],
  reasoning: { effort: "high", exclude: true },  // pensa bastante, devolve só a resposta
} as any);

Desligar

Para uma pergunta simples, o raciocínio só adiciona latência. Desligue com enabled: false (ou effort: "none"):

curl https://api.hinow.ai/v1/chat/completions \
  -H "Authorization: Bearer $HINOW_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "hinow/higenesis",
    "messages": [{ "role": "user", "content": "Bom dia! Que dia é hoje?" }],
    "reasoning": { "enabled": false }
  }'

Alguns modelos raciocinam sempre e não têm como desligar; neles o pedido é ignorado e a resposta vem com o raciocínio do mesmo jeito. Use exclude: true se não quiser vê-lo.

Descobrir quais modelos aceitam

Não há lista fixa: o catálogo diz. Em GET /v1/models, cada modelo de chat traz supported_parameters, e quem aceita o controle lista reasoning, reasoning_effort e include_reasoning. O mesmo item traz context_length, o tamanho da janela de contexto.

modelos = client.models.list()

com_raciocinio = [
    m.id for m in modelos.data
    if "reasoning" in (getattr(m, "supported_parameters", None) or [])
]
print(com_raciocinio)

Mandar reasoning para um modelo que não o suporta não dá erro: o campo é ignorado e a chamada segue normalmente.

Compatibilidade

SDK da OpenAI: reasoning_effort funciona como no original; o objeto reasoning entra por extra_body.
Clientes no padrão OpenRouter (opencode, agentes e SDKs compatíveis): o objeto reasoning e os campos de resposta são os mesmos, sem adaptação.
Clientes HINOW anteriores: thinking: "on" e "off" continuam valendo, e reasoning_content segue na resposta. Para escolher o nível, migre para reasoning.effort.

No chat e no HiNow Code

É este mesmo controle que aparece como nível de raciocínio (baixo, médio, alto) no chat.hinow.ai e no terminal com o HiNow Code.

Próximos passos

Geração de textoMensagens, papéis, controle da saída e streaming.Abrir Chat CompletionsA referência do endpoint, campo a campo.Abrir Listar modelosO catálogo, com preços, contexto e parâmetros aceitos.Abrir

Esta página foi útil?