API OpenAI Decisions

Posez à GPT-6 Luna Decisions des questions de classification et de notation sur du texte, des images ou du JSON, et obtenez des réponses typées que votre code peut exploiter : la probabilité qu'une affirmation soit vraie, laquelle de vos valeurs convient, ou sa position sur votre échelle, chacune avec ses probabilités. Plusieurs questions dans une seule requête, généralement en moins d'une seconde, via l'API Decisions et les SDK d'OpenAI.

GPT-6 Luna Decisions est le modèle de décision d'OpenAI. Il lit votre entrée et répond aux questions que vous posez à son sujet, mais n'écrit aucun texte : ce n'est donc pas un modèle de chat. Envoyez-le à /v1/decisions, pas à /v1/chat/completions. Sur ce endpoint, gpt-6-luna fonctionne aussi comme ID de modèle, comme dans la documentation des SDK d'OpenAI, si bien que le code d'exemple d'OpenAI fonctionne sans modification ; le model de la réponse indique gpt-6-luna-decisions. Pour Jev, le modèle de décision de TypeSafe, voir Décisions (Jev).

Poser des questions

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

Faites pointer le SDK d'OpenAI vers https://api.zurelay.com/v1, avec /v1 comme pour tous les modèles OpenAI sur Zurelay, utilisez votre clé Zurelay et appelez client.decisions.create. En Node.js, cela nécessite openai 7.30.0 ou une version ultérieure ; en Python, un paquet openai assez récent pour inclure client.decisions (la version 3.41 l'inclut). Tout client HTTP fonctionne de la même façon : envoyez le JSON en POST avec votre clé comme jeton Bearer.

La réponse

{
  "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 contient une réponse par question, dans l'ordre où vous les avez posées, chacune avec son type et, si vous en avez fourni un, son name. usage correspond à ce sur quoi la requête a été facturée : input_tokens, avec output_tokens toujours à 0, et cost son coût en dollars US. L'en-tête x-request-id de la réponse permet de la retrouver dans votre journal de requêtes, et x-zurelay-input-tokens rappelle ce sur quoi elle a été facturée.

Paramètres

Types de questions

Une seule requête peut combiner les trois. L'entrée n'est lue qu'une fois pour l'ensemble, donc poser plusieurs questions dans une même requête coûte moins cher que de les poser chacune dans une requête distincte.

Prédicat

Une affirmation ou une question oui/non portant sur l'entrée. Pour la réponse, probability indique la probabilité que ce soit vrai : proche de 1 pour oui, proche de 0 pour non, et entre les deux quand l'entrée n'est pas claire.

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

Choix

Choisit l'une des valeurs que vous listez et donne la probabilité de chacune. Une description précise ce que signifie une valeur, ce qui est utile quand la valeur seule n'est qu'un code. Les valeurs peuvent aussi être true et false, et le texte "true" et le booléen true sont des valeurs différentes.

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

Score

Classe l’entrée sur vos niveaux, du plus bas au plus élevé. score correspond au niveau attendu : l’indice de chaque niveau, en comptant à partir de 0, pondéré par sa probabilité. Il peut donc se situer entre deux niveaux : dans l’exemple de réponse ci-dessus, 0.18 correspond surtout au premier niveau, avec un peu du deuxième. Chaque entrée de probabilities contient l’indice du niveau dans value et son 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" }
  ]
}

Images

Envoyez des images dans l'entrée, comme parties d'un message utilisateur, à côté de tout texte. Fournissez une URL de données en base64, ou un lien public https que Zurelay télécharge puis transmet : PNG, JPEG, WebP ou GIF. Envoyez les images volumineuses sous forme de liens.

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)

Une image ajoute des tokens selon sa taille et detail : une image de 1200 × 630 représente environ 750 tokens avec high ou auto, et environ 150 avec low. Utilisez low quand la question porte sur l’image dans son ensemble plutôt que sur les petits caractères. Les images se placent uniquement dans l’entrée : les instructions d’une question n’acceptent que du texte.

Entrée JSON

Vous pouvez envoyer des données structurées telles quelles, dans une partie input_json, à côté de texte ou d'images. Le modèle les lit sous forme de texte JSON compact, et elles sont facturées comme ce texte.

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

Refus

Toute question peut renvoyer un refus au lieu d'une réponse, tandis que les autres questions de la requête reçoivent bien leur réponse. Vérifiez le type de chaque réponse avant de lire ses champs. Lors de nos tests, l'entrée « Refund requested 38 hours ago. » avec le prédicat « Page on-call? » a donné un refus.

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

Un refus arrive dans une réponse normale, dont usage indique sur quelle base la requête a été facturée. Posez à nouveau la question en étant plus clair, ou transmettez le cas à une personne.

Limites

• Jusqu'à 1.05M tokens par requête : l'entrée et toutes les questions réunies. Une entrée de 918K tokens a fonctionné lors de nos tests.
• 1 à 64 questions. Un choice accepte de 2 à 255 valeurs uniques et un score de 2 à 10 niveaux.
• Seuls les messages utilisateur sont acceptés : les messages système, développeur et assistant, ainsi que les éléments d’appel de fonction ou d’outil, sont refusés. Placez le contexte dans un message utilisateur, ou dans les instructions d’une question.
• Pas de streaming : stream est refusé, et les réponses reviennent en un seul bloc.
• Une requête mal formée, ou contenant un champ que l’API n’accepte pas, est refusée avec un 400 qui nomme le champ (par exemple questions[2].choices) avant d’atteindre le modèle, et ne coûte rien.
• Une clé limitée à certains modèles doit avoir gpt-6-luna-decisions dans sa liste, y compris pour les requêtes qui indiquent gpt-6-luna. Voir Limites et règles des clés.

Vitesse

Dans nos tests, les réponses arrivent en général en 0,3 à 1 seconde, et en environ une seconde avec une image. Une entrée de 900K tokens a pris environ 10 secondes.

Facturation des décisions

GPT-6 Luna Decisions coûte $0.04 par 1M de tokens en entrée, et ses réponses sont gratuites. Les tokens comptés sont votre entrée, comptée une seule fois, plus environ 110 à 160 tokens propres au modèle pour chaque question : un prédicat court sur un texte court représente environ 160 tokens au total, deux environ 320, et une entrée de 2 600 tokens avec quatre questions environ 3 200. Les images ajoutent leurs tokens comme indiqué plus haut. Ainsi, une vérification à une question sur un texte court coûte environ $0.0000064, et un million d’entre elles environ $6.40.

Les en-têtes usage et x-zurelay-input-tokens de chaque réponse indiquent ce qui a été facturé, chaque requête figure dans votre journal de requêtes, et les requêtes en échec ne coûtent rien.

Erreurs

Les clés, le crédit, les budgets et les limites de débit renvoient les mêmes erreurs que tous les autres endpoints : voir Erreurs. Les SDK d’OpenAI relancent automatiquement celles qui valent la peine d’être relancées.