API OpenAI Decisions

Hazle a GPT-6 Luna Decisions preguntas de clasificación y puntuación sobre texto, imágenes o JSON, y obtén respuestas tipadas con las que tu código puede actuar: qué tan probable es que una afirmación sea cierta, cuál de tus valores encaja o dónde se sitúa en tu escala, cada una con sus probabilidades. Muchas preguntas en una sola solicitud, normalmente en menos de un segundo, a través de la API Decisions y los SDK de OpenAI.

GPT-6 Luna Decisions es el modelo de decisión de OpenAI. Lee tu entrada y responde las preguntas que le plantees sobre ella, pero no escribe texto, así que no es un modelo de chat: envíalo a /v1/decisions, no a /v1/chat/completions. En este endpoint, gpt-6-luna también funciona como ID del modelo, igual que en la documentación del SDK de OpenAI, por lo que el código de ejemplo de OpenAI funciona sin cambios; el model de la respuesta indica gpt-6-luna-decisions. Para Jev, el modelo de decisión de TypeSafe, consulta Decisiones (Jev).

Haz preguntas

# 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")

Apunta el SDK de OpenAI a https://api.zurelay.com/v1, con /v1 como en cualquier modelo de OpenAI en Zurelay, usa tu clave de Zurelay y llama a client.decisions.create. En Node.js necesitas openai 7.30.0 o posterior; en Python, un paquete openai lo bastante reciente para incluir client.decisions (la 3.41 lo tiene). Cualquier cliente HTTP funciona igual: envía el JSON por POST con tu clave como token Bearer.

La respuesta

{
  "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 contiene una respuesta por pregunta, en el orden en que las hiciste, cada una con su type y, si la indicaste, su name. usage es la base sobre la que se facturó la solicitud: input_tokens, con output_tokens siempre en 0, y cost lo que costó en dólares estadounidenses. El encabezado x-request-id de la respuesta te permite encontrarla en tu registro de solicitudes, y x-zurelay-input-tokens repite sobre qué se facturó.

Parámetros

Tipos de pregunta

Una sola solicitud puede combinar las tres. La entrada se lee una sola vez para todas, así que hacer varias preguntas en una misma solicitud cuesta menos que hacer cada una en una solicitud independiente.

Predicado

Una afirmación o una pregunta de sí o no sobre la entrada. El probability de la respuesta indica la probabilidad de que sea verdadera: cercano a 1 para sí, cercano a 0 para no, y un valor intermedio cuando la entrada no lo deja claro.

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

Elección

Elige uno de los valores que enumeras y da la probabilidad de cada uno. Una descripción explica qué significa un valor, lo cual ayuda cuando el valor por sí solo es un código. Los valores también pueden ser true y false, y el texto "true" y el booleano true son valores distintos.

{
  "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" }
  ]
}

Puntuación

Ubica la entrada en tus niveles, ordenados de menor a mayor. score es el nivel esperado: el índice de cada nivel, contando desde 0, ponderado por su probabilidad. Por eso puede quedar entre dos niveles: en la respuesta de ejemplo de arriba, 0.18 es sobre todo el primer nivel con un poco del segundo. Cada entrada de probabilities tiene el índice del nivel como value y su 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" }
  ]
}

Imágenes

Envía imágenes en el input, como partes de un mensaje de usuario junto con cualquier texto. Usa una URL de datos en base64 o un enlace público https, que Zurelay descarga y reenvía. Formatos admitidos: PNG, JPEG, WebP o GIF. Envía las imágenes grandes como enlaces.

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)

Una imagen suma tokens según su tamaño y detail: una imagen de 1200 × 630 equivale a unos 750 tokens con high o auto, y a unos 150 con low. Usa low cuando la pregunta sea sobre la imagen completa y no sobre letra pequeña. Las imágenes van solo en la entrada: las instrucciones de una pregunta admiten solo texto.

Entrada JSON

Los datos estructurados pueden enviarse tal cual, en una parte input_json, junto con texto o imágenes. El modelo los lee como texto JSON compacto y se facturan como tal.

"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" }
      }
    ]
  }
]

Rechazos

Cualquier pregunta puede devolver un rechazo en lugar de una respuesta, mientras que las demás de la solicitud sí se responden. Revisa el type de cada respuesta antes de leer sus campos. En nuestras pruebas, la entrada “Refund requested 38 hours ago.” con el predicado “Page on-call?” devolvió un rechazo.

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

Una negativa llega en una respuesta normal, en la que usage indica en qué se basó la facturación de la solicitud. Vuelve a preguntar con una pregunta más clara o pasa el caso a una persona.

Límites

• Hasta 1.05M tokens por solicitud: la entrada y todas las preguntas juntas. En nuestras pruebas funcionó una entrada de 918K tokens.
• De 1 a 64 preguntas. Un choice admite de 2 a 255 valores únicos y un score de 2 a 10 niveles.
• Solo se admiten mensajes de usuario: los mensajes de sistema, de desarrollador y de asistente, así como los elementos de llamada a funciones o herramientas, se rechazan. Pon el contexto en un mensaje de usuario o en las instrucciones de una pregunta.
• Sin streaming: stream se rechaza y las respuestas llegan completas.
• Una solicitud mal formada, o con un campo que la API no admite, se rechaza con un 400 que indica el campo (por ejemplo questions[2].choices) antes de llegar al modelo, y no tiene costo.
• Una clave limitada a algunos modelos necesita gpt-6-luna-decisions en su lista, también para las solicitudes que indican gpt-6-luna. Consulta Límites y reglas de las claves.

Velocidad

En nuestras pruebas, las respuestas suelen llegar en 0,3 a 1 segundo, y en cerca de un segundo si hay una imagenn. Una entrada de 900K tokens tardó unos 10 segundos.

Pagar por las decisiones

GPT-6 Luna Decisions cuesta $0.04 por 1M de tokens de entrada, y sus respuestas son gratuitas. Los tokens son tu entrada, contada una sola vez, más unos 110 a 160 propios del modelo por cada pregunta: un predicado corto sobre un texto corto son unos 160 tokens en total, dos son unos 320, y una entrada de 2,600 tokens con cuatro preguntas, unos 3,200. Las imágenes suman sus tokens como se indicó antes. Así, una comprobación de una sola pregunta sobre un texto corto cuesta alrededor de $0.0000064, y un millón de ellas, alrededor de $6.40.

Los encabezados usage y x-zurelay-input-tokens de cada respuesta indican sobre qué se facturó, todas las solicitudes aparecen en tu registro de solicitudes, y las que fallan no tienen costo.

Errores

Las claves, el crédito, los presupuestos y los límites de frecuencia dan los mismos errores que cualquier otro endpoint: consulta Errores. Los SDK de OpenAI reintentan los que vale la pena reintentar.