GetAPI.ONE

Diffuser Responses depuis GetAPI.ONE

Consommez un flux d’événements envoyés par le serveur, ajoutez uniquement les deltas de texte et traitez les événements terminés, échoués et incomplets comme des résultats terminaux distincts.

Choisir un chemin compatible

Utilisez un modèle actuel du catalogue dont le point de terminaison déclaré est Responses.
Conservez la clé API dans un serveur ou un processus local de confiance.
Décidez comment l’appelant affichera le texte partiel et récupérera après l’interruption d’un flux.

text

POST https://www.getapi.one/v1/responses
Accept: text/event-stream
Authorization: Bearer $GETAPI_ONE_API_KEY

Lire le cycle de vie des événements

Envoyez stream=true au moyen d’un SDK côté serveur ou d’un client HTTP dont les nouvelles tentatives automatiques sont désactivées pour la première requête contrôlée.
Ajoutez uniquement les charges utiles response.output_text.delta au texte visible.
Arrêtez-vous à response.completed et conservez les métadonnées de réponse finales nécessaires à votre application.
Présentez response.failed et response.incomplete comme des résultats non réussis ; ne qualifiez pas un texte partiel de complet.
Traitez un événement d’erreur, une exception de transport, une fin de flux avant achèvement ou une annulation locale comme un échec, puis fermez le flux.

python

import os
from openai import OpenAI

terminal_event = None
try:
    with OpenAI(
        api_key=os.environ["GETAPI_ONE_API_KEY"],
        base_url="https://www.getapi.one/v1",
        timeout=30.0,
        max_retries=0,
    ) as client:
        with client.responses.create(
            model="<RESPONSES_MODEL_ID_FROM_CURRENT_CATALOG>",
            input="Give three concise deployment checks.",
            stream=True,
        ) as stream:
            for event in stream:
                if event.type == "response.output_text.delta":
                    print(event.delta, end="", flush=True)
                elif event.type == "response.completed":
                    terminal_event = event.type
                    print("\ncompleted")
                    break
                elif event.type in {"response.failed", "response.incomplete", "error"}:
                    terminal_event = event.type
                    raise RuntimeError(f"stream ended with {event.type}: {event}")
except KeyboardInterrupt:
    raise SystemExit("cancelled locally; the stream and client were closed")

if terminal_event != "response.completed":
    raise RuntimeError("stream ended before response.completed")

Associer les événements à l’état de l’interface

Événement	Action de l’application
response.output_text.delta	Ajouter event.delta sans remplacer le texte déjà rendu.
response.completed	Marquer la réussite et fermer l’état de chargement.
response.failed	Afficher l’erreur structurée et une action de nouvelle tentative sûre.
response.incomplete	Conserver la sortie partielle visiblement incomplète et examiner les détails de l’incomplétude.

Vérifier le résultat attendu

Le texte apparaît progressivement sans deltas dupliqués.
Le chargement ne se termine qu’après un événement terminal ou une erreur de transport.
Une connexion interrompue n’affiche jamais un faux état de réussite.

Gérer les erreurs de transport et de protocole

Si aucun événement n’arrive, vérifiez la route exacte /v1/responses, stream=true, la mise en mémoire tampon du proxy et la déclaration du point de terminaison du modèle.
Si la sortie se répète, ajoutez chaque delta une seule fois et ne combinez pas la sortie accumulée du SDK avec les événements bruts.
Ne réessayez qu’avant tout effet secondaire visible ou avec une idempotence au niveau de l’application ; une déconnexion ne prouve pas que la requête en amont n’a rien effectué.

Conserver le streaming côté serveur