API OpenAI Decisions

Faça ao GPT-6 Luna Decisions perguntas de classificação e pontuação sobre texto, imagemns ou JSON e obtenha respostas tipadas que o seu código pode usar: a probabilidade de uma afirmação ser verdadeira, qual dos seus valores se adequa melhor, ou onde se situa na sua escala, cada uma com as respetivas probabilidades. Muitas perguntas num único pedido, normalmente em menos de um segundo, através da Decisions API e dos SDKs da própria OpenAI.

O GPT-6 Luna Decisions é o modelo de decisão da OpenAI. Lê a sua entrada e responde às perguntas que definir sobre ela, e não escreve texto, pelo que não é um modelo de conversa: envie-o para /v1/decisions, não para /v1/chat/completions. Neste endpoint, gpt-6-luna também funciona como ID do modelo, tal como na documentação do SDK da própria OpenAI, por isso o código de exemplo da OpenAI funciona sem alterações; o model da resposta indica gpt-6-luna-decisions. Para o Jev, o modelo de decisão da TypeSafe, consulte Decisões (Jev).

Fazer perguntas

# pip install --upgrade openai
import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
decision = client.decisions.create(
    model="gpt-6-luna-decisions",
    input="My headphones stopped charging two days after they arrived. I want a refund.",
    questions=[
        {
            "type": "predicate",
            "name": "refund",
            "instructions": "Is the customer asking for a refund?",
        },
        {
            "type": "choice",
            "name": "topic",
            "instructions": "What is the ticket about?",
            "choices": [
                {"value": "billing", "description": "Charges and invoices"},
                {"value": "hardware", "description": "A device that is broken or faulty"},
                {"value": "shipping", "description": "Delivery and tracking"},
            ],
        },
        {
            "type": "score",
            "name": "sentiment",
            "instructions": "How does the customer feel?",
            "levels": [
                {"label": "very negative"},
                {"label": "negative"},
                {"label": "neutral"},
            ],
        },
    ],
)
# One answer per question, in the order asked
for answer in decision.answers:
    if answer.type == "refusal":
        print(answer.name, "refused")
    elif answer.type == "predicate":
        print(answer.name, answer.probability)
    elif answer.type == "choice":
        print(answer.name, answer.choice, answer.confidence)
    else:
        print(answer.name, answer.score, answer.confidence)
print(decision.usage.input_tokens, "input tokens")

Aponte o SDK da OpenAI para https://api.zurelay.com/v1, com /v1 como para todos os modelos da OpenAI na Zurelay, use a sua chave Zurelay e chame client.decisions.create. Em Node.js, precisa da versão 7.30.0 ou posterior de openai; em Python, de um pacote openai suficientemente recente para ter client.decisions (a 3.41 já o tem). Qualquer cliente HTTP funciona da mesma forma: faça POST do JSON com a sua chave como token Bearer.

A resposta

{
  "id": "req_3Fh8sLq0vW2nTc7yRb5kZp1M",
  "model": "gpt-6-luna-decisions",
  "answers": [
    { "type": "predicate", "name": "refund", "probability": 1 },
    {
      "type": "choice",
      "name": "topic",
      "choice": "hardware",
      "confidence": 1,
      "probabilities": [
        { "value": "billing", "probability": 0 },
        { "value": "hardware", "probability": 1 },
        { "value": "shipping", "probability": 0 }
      ]
    },
    {
      "type": "score",
      "name": "sentiment",
      "score": 0.18,
      "confidence": 0.85,
      "probabilities": [
        { "value": 0, "label": "very negative", "probability": 0.82 },
        { "value": 1, "label": "negative", "probability": 0.18 },
        { "value": 2, "label": "neutral", "probability": 0 }
      ]
    }
  ],
  "usage": {
    "input_tokens": 325,
    "input_tokens_details": { "cached_tokens": 0, "cache_write_tokens": 0 },
    "output_tokens": 0,
    "output_tokens_details": { "reasoning_tokens": 0 },
    "total_tokens": 325,
    "cost": 0.000013
  }
}

answers tem uma resposta por pergunta, pela ordem em que as fez, cada uma com o seu type e, se tiver indicado um, o seu name. usage é aquilo em que o pedido foi faturado: input_tokens, com output_tokens sempre a 0, e cost o que custou em dólares americanos. O cabeçalho x-request-id da resposta permite encontrá-lo no registo de pedidos, e x-zurelay-input-tokens repete aquilo em que foi faturado.

Parâmetros

Tipos de pergunta

Um único pedido pode combinar os três. A entrada é lida uma só vez para todos, por isso fazer várias perguntas num só pedido custa menos do que fazer cada uma no seu próprio pedido.

Predicado

Uma afirmação ou pergunta de sim/não sobre o texto de entrada. A probability da resposta indica a probabilidade de ser verdadeira: próxima de 1 para sim, próxima de 0 para não, e um valor intermédio quando a entrada não é clara.

{ "type": "predicate", "name": "refund", "instructions": "Is the customer asking for a refund?" }
{ "type": "predicate", "name": "refund", "probability": 1 }

Escolha

Escolhe um dos valores que indicar e devolve a probabilidade de cada um. Uma descrição explica o significado de um valor, o que ajuda quando o valor, por si só, é um código. Os valores também podem ser true e false, e o texto "true" e o booleano true são valores diferentes.

{
  "type": "choice",
  "name": "language",
  "instructions": "Which language is the message written in?",
  "choices": [
    { "value": "en", "description": "English" },
    { "value": "es", "description": "Spanish" },
    { "value": "other", "description": "Any other language" }
  ]
}

Pontuação

Coloca a entrada nos seus níveis, do mais baixo para o mais alto. score é o nível esperado: o índice de cada nível, a contar a partir de 0, ponderado pela respetiva probabilidade. Por isso, pode situar-se entre dois níveis: na resposta de exemplo acima, 0.18 corresponde sobretudo ao primeiro nível, com um pouco do segundo. Cada entrada em probabilities tem o índice do nível como value e a sua label.

{
  "type": "score",
  "name": "relevance",
  "instructions": "How well does the passage answer the search query?",
  "levels": [
    { "label": "irrelevant" },
    { "label": "related", "description": "On the topic, but doesn't answer it" },
    { "label": "answers it" }
  ]
}

Imagens

Envie imagens no input, como partes de uma mensagem do utilizador, junto com qualquer texto. Indique um data URL em base64 ou uma ligação https pública, que a Zurelay descarrega e reencaminha: PNG, JPEG, WebP ou GIF. Envie imagens grandes como ligações.

import base64, os
from openai import OpenAI
client = OpenAI(base_url="https://api.zurelay.com/v1", api_key=os.environ["ZURELAY_API_KEY"])
with open("return-photo.jpg", "rb") as file:
    photo = "data:image/jpeg;base64," + base64.b64encode(file.read()).decode()
decision = client.decisions.create(
    model="gpt-6-luna-decisions",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Photo sent with a return request for a blender."},
                {"type": "input_image", "image_url": photo, "detail": "low"},
            ],
        }
    ],
    questions=[
        {
            "type": "predicate",
            "name": "damaged",
            "instructions": "Does the photo show visible damage to the product?",
        },
        {
            "type": "choice",
            "name": "product",
            "instructions": "What product is in the photo?",
            "choices": [
                {"value": "blender"},
                {"value": "kettle"},
                {"value": "other", "description": "Anything else, or no product"},
            ],
        },
    ],
)
print(decision.answers)

Uma imagem acrescenta tokens consoante o seu tamanho e detail: uma imagem de 1200 × 630 equivale a cerca de 750 tokens em high ou auto, e a cerca de 150 em low. Use low quando a pergunta for sobre a imagem como um todo, e não sobre texto pequeno. As imagens só podem ir na entrada: as instruções de uma pergunta aceitam apenas texto.

Entrada JSON

Os dados estruturados podem ser enviados tal como estão, numa parte input_json, ao lado de texto ou imagens. O modelo lê-os como texto JSON compacto e são faturados como esse texto.

"input": [
  {
    "role": "user",
    "content": [
      { "type": "input_text", "text": "A sign-up from our app:" },
      {
        "type": "input_json",
        "data": { "name": "Free Gift Card Giveaway", "email": "win-now@example.net", "bio": "Click my link" }
      }
    ]
  }
]

Recusas

Qualquer pergunta pode devolver uma recusa em vez de uma resposta, enquanto as restantes do pedido continuam a ser respondidas. Verifique o type de cada resposta antes de ler os respetivos campos. Nos nossos testes, a entrada “Refund requested 38 hours ago.” com o predicado “Page on-call?” devolveu refused.

{ "type": "refusal", "name": "page_on_call" }

Uma recusa vem numa resposta normal, cujo usage indica em que se baseou a faturação do pedido. Volte a perguntar de forma mais clara ou encaminhe o caso para uma pessoa.

Limites

• Até 1.05M tokens por pedido: o input e todas as perguntas em conjunto. Nos nossos testes, um input de 918K tokens funcionou.
• 1 a 64 perguntas. Um choice aceita de 2 a 255 valores únicos e um score de 2 a 10 níveis.
• Só são aceites mensagens de utilizador: mensagens de sistema, de programador e de assistente, bem como itens de chamada de função ou de ferramenta, são recusadas. Coloque o contexto numa mensagem de utilizador ou nas instruções de uma pergunta.
• Sem streaming: stream é recusado e as respostas chegam sempre completas.
• Um pedido malformado, ou com um campo que a API não aceita, é recusado com um 400 que indica o campo (por exemplo, questions[2].choices) antes de chegar ao modelo, e não tem custo.
• Uma chave limitada a alguns modelos precisa de gpt-6-luna-decisions na respetiva lista, também nos pedidos que indicam gpt-6-luna. Consulte Limites e regras das chaves.

Velocidade

Nos nossos testes, as respostas chegam normalmente em 0,3 a 1 segundo e, com uma imagemm, em cerca de um segundo. Uma entrada de 900K tokens demorou cerca de 10 segundos.

Pagamento das decisões

O GPT-6 Luna Decisions custa $0.04 por 1M de tokens de entrada e as respostas são gratuitas. Os tokens são a sua entrada, contada uma só vez, mais cerca de 110 a 160 do próprio modelo por cada pergunta: um predicado curto sobre um texto curto dá cerca de 160 tokens no total, dois dão cerca de 320, e uma entrada de 2600 tokens com quatro perguntas dá cerca de 3200. As imagens acrescentam os seus tokens, como indicado acima. Assim, uma verificação com uma só pergunta sobre um texto curto custa cerca de $0.0000064, e um milhão delas cerca de $6.40.

Os cabeçalhos usage e x-zurelay-input-tokens de cada resposta indicam com base em quê foi faturada, todos os pedidos ficam no seu registo de pedidos e os pedidos que falham não têm custo.

Erros

As chaves, o crédito, os orçamentos e os limites de taxa dão os mesmos erros que os restantes endpoints: consulte Erros. Os SDKs da OpenAI repetem automaticamente os pedidos que vale a pena repetir.