Como chamar o gpt-6.1 Sol via HiAPI: curl, Python e streaming na prática (tutorial em chinês)

Objetivo e pré-requisitos deste artigo

Depois de ler este artigo, você vai conseguir executar o gpt-6.1 Sol com uma única requisição HTTP — ele é o modelo de texto da família GPT-6.1 Sol na HiAPI, voltado para programação complexa, análise de documentos e raciocínio em várias etapas — e receber o texto em streaming. Você terá exemplos de curl e Python prontos para copiar, além dos três pontos mais propensos a erro: a interface é /v1/responses (não /v1/chat/completions), o streaming é obrigatório e input precisa ser um array.

Pré-requisitos: uma API Key da HiAPI. Crie e guarde com cuidado na página de chaves de API; envie-a em cada requisição via Authorization: Bearer sk-<sua key>.

O gpt-6.1 Sol é um modelo apenas de texto (conversa / raciocínio / programação) e não gera imagens. Para detalhes de capacidade e teste online, veja a página do modelo gpt-6.1 Sol.

Exemplo mínimo funcional

A família Sol usa a Responses API: POST /v1/responses. Duas regras rígidas; faltar uma delas resulta em erro 400:

1. "stream": true — o modelo só suporta streaming; stream:false será rejeitado.
2. input é um array de objetos de mensagem — com o streaming ativado, enviar uma string simples gera input: has incorrect type.

curl

curl -N https://api.hiapi.ai/v1/responses \
  -H "Authorization: Bearer sk-<sua key>" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.1-sol",
    "input": [
      {
        "type": "message",
        "role": "user",
        "content": [
          { "type": "input_text", "text": "Explique em uma frase o que é limite de taxa de API." }
        ]
      }
    ],
    "stream": true
  }'

-N desativa o buffer de saída do curl, para que você veja os Server-Sent Events (SSE) chegando em tempo real. O stream é uma sequência de linhas event: / data:; o texto desejado aparece nos fragmentos response.output_text.delta e é repetido por completo no evento final response.completed.

A forma abreviada "input": [{"role":"user","content":"……"}] também funciona; a forma canônica com type/input_text acima é mais estável ao montar multimodal ou múltiplos turnos, e é recomendável usá-la por padrão.

Python

Não é necessário SDK; a HiAPI é HTTP comum, então basta usar requests com stream=True:

import json
import requests

API_KEY = "sk-<sua key>"

payload = {
    "model": "gpt-6.1-sol",
    "input": [
        {
            "type": "message",
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Explique em uma frase o que é limite de taxa de API."}
            ],
        }
    ],
    "stream": True,
}

with requests.post(
    "https://api.hiapi.ai/v1/responses",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json=payload,
    stream=True,
    timeout=120,
) as resp:
    resp.raise_for_status()

    text = ""
    for line in resp.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        event = json.loads(line[len("data:"):].strip())
        etype = event.get("type")
        if etype == "response.output_text.delta":
            text += event["delta"]
        elif etype == "response.completed":
            usage = event["response"]["usage"]
            print(f"\n[tokens: in={usage['input_tokens']} "
                  f"out={usage['output_tokens']} total={usage['total_tokens']}]")

print(text)

É mais estável despachar pelo campo type presente no próprio JSON (em vez de analisar a linha event:): cada quadro SSE tem duas linhas — event: <type> e data: <json> —, então filtrar apenas as linhas data: e ler event["type"] já basta.

Pontos para produção

• Só existe o modo streaming. Não há variante não-streaming; stream:false retorna 400 diretamente. O cliente deve ser projetado em torno de SSE desde o início: adicione timeout de leitura e reconexão / retry após queda do stream.
• Não envie max_output_tokens. Este perfil de execução não aceita esse parâmetro (retorna not supported by this execution profile). Para controlar o comprimento, restrinja no prompt ou nas instruções de sistema. O modelo pode gerar no máximo cerca de 128 mil tokens por vez, mas esse limite não pode ser definido por parâmetro.
• Coloque o prompt de sistema no instructions de nível superior (string), em vez de enfiá-lo em alguma message:

{
  "model": "gpt-6.1-sol",
  "instructions": "Você é um assistente conciso e responde apenas com uma frase.",
  "input": [
    { "type": "message", "role": "user",
      "content": [{ "type": "input_text", "text": "O que é um webhook?" }] }
  ],
  "reasoning": { "effort": "low" },
  "stream": true
}

• Use reasoning.effort para equilibrar profundidade de raciocínio e custo. O gpt-6.1 Sol é um modelo de raciocínio; reasoning.effort aceita cinco níveis: low / medium / high / xhigh / max, com padrão medium. Quanto menor o nível, menos tokens de raciocínio são gastos — e tokens de raciocínio são cobrados como saída, aparecendo em usage.output_tokens_details.reasoning_tokens no evento final. Não use nível alto em tarefas que um nível baixo resolve.
• Quando precisar de saída estruturada, use text.format. O modelo suporta JSON Schema em modo estrito (strict), ideal para fazê-lo emitir JSON parseável de forma estável, em vez de torcer pelo formato via prompt.
• Suporta chamada de ferramentas (function calling). tools + tool_choice de nível superior estão disponíveis, e é possível devolver o resultado de ferramentas à conversa para continuar o raciocínio, ideal para cenários de agent.
• Conversa multi-turno: basta acrescentar as mensagens anteriores de user e assistant em ordem ao array input e enviar a próxima requisição.
• Falha de autenticação é 401. Key errada ou revogada retorna 401, código permission_denied ("This API key is invalid."). Nesse caso, lance o erro imediatamente e não faça retry — retry não conserta uma key errada; o request_id no corpo da resposta serve para o suporte técnico investigar.
• A cobrança é por token. input e output são precificados separadamente, com o preço do output bem acima do input; tokens de entrada que acertam o cache são mais baratos; tokens de raciocínio entram no output e são cobrados junto (portanto, baixar reasoning.effort economiza diretamente); quando a entrada única passa de cerca de 272 mil tokens, entra-se na faixa de preço mais alta de contexto longo. Os números concretos valem conforme a página de preços em tempo real; não fixe preços no código.

Registro de teste: uma requisição real executada com sucesso

Os exemplos deste artigo não foram copiados da documentação — chamamos de fato /v1/responses uma vez com o curl acima (reasoning.effort: low, prompt "Explique em uma frase o que é limite de taxa de API") e observamos:

• usage do evento final response.completed: input_tokens=31, output_tokens=28, total_tokens=59, com output_tokens_details.reasoning_tokens=0 — com nível baixo + pergunta simples, os tokens de raciocínio podem ser 0, e o custo fica quase só na parte de saída visível.
• O texto chega em incrementos response.output_text.delta no stream; no estado final é possível obter o resultado completo de uma vez em response.output[0].content[0].text; as duas formas funcionam.
• O corpo da resposta traz campos como eco de reasoning.effort, service_tier, prompt_cache_retention, confirmando que o effort e o cache estão realmente em efeito.

Também provocamos de fato alguns erros comuns, para facilitar seu diagnóstico (todos retornos reais):

O que você fez de errado	HTTP	code	message
Enviou para /v1/chat/completions	400	unsupported_protocol	Model does not support this protocol
Enviou stream:false	400	invalid_parameter	stream: must be true
Enviou max_output_tokens	400	invalid_parameter	max_output_tokens: is not supported by this execution profile
input enviado como string	400	invalid_parameter	input: has incorrect type
key inválida	401	permission_denied	This API key is invalid. (com request_id)

Mantra de diagnóstico em uma frase: ao receber 400, verifique primeiro estas três coisas — se a interface é /v1/responses, se stream é true e se input é um array. A grande maioria dos "não funciona" é uma dessas três.

Links relacionados

• Página do modelo gpt-6.1 Sol — capacidades, parâmetros e teste online
• Documentação da HiAPI — visão geral da interface e mais modelos
• Página de preços — preços unitários em tempo real por uso
• Ainda escolhendo? Veja GPT-6 Astra vs GPT-5.6 Sol: como escolher, e também a página do modelo GPT-6 Astra, que usa a mesma Responses API

Perguntas frequentes

Posso conectar diretamente com o SDK oficial da OpenAI? O gpt-6.1 Sol usa o protocolo Responses API, e o formato da interface é compatível; mas os exemplos deste artigo usam o HTTP cru mais leve (requests + stream=True), sem depender de SDK algum, e funcionam ao copiar. O essencial é apontar a base URL para https://api.hiapi.ai e usar a key da HiAPI.

Por que recebo 400 sempre que envio stream:false? É por design, não é bug. A família Sol só suporta streaming; stream precisa ser true, caso contrário retorna invalid_parameter (stream: must be true). Basta alterar o cliente para ler SSE.

Como controlar o comprimento da saída? Não posso usar max_output_tokens? Não pode; enviá-lo retorna 400. Especifique o requisito de comprimento em instructions (ex.: "responda apenas com uma frase") ou restrinja no prompt.

Como reduzir o custo? Priorize baixar reasoning.effort (tokens de raciocínio são cobrados como saída; nível baixo economiza diretamente); reutilize o prompt de sistema para que a entrada acerte o cache e fique mais barata; evite enfiar contextos longuíssimos de uma vez, o que aciona a faixa de preço alta. Preços em tempo real na página de preços.