API Responses OpenAI : réussir la migration vers GPT-6 Astra

En pratique, il faut déterminer l’effort d’ingénierie à consacrer à cette migration et vérifier si les nouveaux contrôles réduisent vraiment le coût de l’attente, des corrections et des redémarrages des agents.

Ce que l’API Responses OpenAI change réellement

Avant son lancement, Astra se présentait comme un modèle de recherche encore inaccessible. La version de septembre lui donne un identifiant public, gpt-6-astra, une tarification et une disponibilité dans Chat Completions comme dans Responses. L’accès commence par les entreprises inscrites au Trusted Access Program d’OpenAI ; l’API et d’autres offres doivent suivre dans les jours qui viennent.

Le choix de l’endpoint dépend du fonctionnement de l’application. Une intégration Chat Completions limitée au texte peut utiliser Astra. Dès qu’Astra doit appeler vos fonctions ou des outils hébergés par OpenAI, il faut passer par l’API Responses.

Responses impose un autre contrat applicatif. Chat Completions reçoit une liste de messages et renvoie une liste de choix. Responses échange des Items typés : un message constitue un Item, un function_call en constitue un autre, puis le résultat de l’outil revient sous forme de function_call_output avec le call_id d’origine.

Deux pièges sont faciles à manquer pendant la migration. Les instructions de premier niveau ne sont pas reprises lors d’un chaînage avec previous_response_id : il faut donc les renvoyer. Structured Outputs passe aussi de response_format à text.format. Le guide de migration détaille l’ensemble des changements touchant le parseur, l’état, les outils et le streaming.

Pourquoi il faut désormais prévoir deux budgets

Le premier concerne le temps d’ingénierie. En production, une boucle d’outils touche l’endpoint, le schéma de requête, le parseur de sortie, les définitions de fonctions, la corrélation des résultats, la gestion de l’état, les événements de streaming, les logs, les nouvelles tentatives et les évaluations. Changer uniquement le nom du modèle laisse l’essentiel du chantier en suspens.

Le second porte sur le coût de chaque tâche achevée. Aux tarifs Standard de contexte court, GPT-6 Astra coûte $10.00 par 1 million de tokens en entrée, $1.00 pour les entrées mises en cache, $12.50 pour les écritures en cache et $50.00 pour la sortie. Les tarifs promotionnels actuels de GPT-5.6 Sol sont respectivement de $4.00, $0.40, $5.00 et $20.00. À volume de tokens identique, le coût d’Astra est multiplié par 2.5 sur chaque ligne.

L’endpoint n’entraîne aucun surcoût propre. La facture vient des tokens du modèle, des outils intégrés payants, de votre infrastructure d’outils, des nouvelles tentatives et du travail abandonné. Au-delà de 272,000 tokens en entrée, toute la requête Astra passe également au double du tarif d’entrée et de cache, ainsi qu’à 1.5 fois le tarif de sortie. Ce sont les chiffres à intégrer au budget du pilote, tirés de la page de tarification actuelle.

Une compensation est possible, mais seules vos propres données permettront de la confirmer. OpenAI indique que Responses améliore de 40% à 80% l’utilisation du cache par rapport à Chat Completions dans ses tests internes. L’entreprise estime aussi qu’Astra revient moins cher par tâche dans plusieurs évaluations API, car il génère moins de tokens de sortie malgré un prix unitaire supérieur. Aucune de ces affirmations ne garantit une économie dans tous les cas.

Mesurez plutôt ceci :

cost per completed job = model tokens + built-in tool fees + your tool costs + retries + operator time

Le dénominateur est décisif. Une exécution moins chère qui doit repartir de zéro après une correction tardive peut coûter davantage par résultat terminé qu’une exécution plus onéreuse qui conserve le travail utile.

Les outils asynchrones changent la gestion de l’attente

Un appel de fonction classique met le modèle en pause jusqu’au retour d’un résultat par l’application. Avec Astra, une fonction exécutée par l’application ou un outil personnalisé peut inclure async: true. Le modèle peut alors lancer l’appel, poursuivre son raisonnement, invoquer un autre outil indépendant ou traiter une partie autonome de la demande pendant que l’application exécute la tâche.

Le travail reste à la charge de votre serveur. Celui-ci doit démarrer la tâche, tenir un registre, conserver le call_id d’origine et transmettre le résultat dans une requête Responses ultérieure. Si d’autres tours interviennent avant l’arrivée du résultat, la suite doit utiliser l’identifiant de réponse le plus récent, tandis que la sortie de l’outil continue de pointer vers l’identifiant d’appel initial.

Dans un produit de recherche, une requête lente auprès d’un fournisseur de données peut ainsi s’exécuter pendant qu’Astra organise les sources déjà disponibles. Pour un agent chargé des opérations internes, deux consultations de compte indépendantes peuvent démarrer tôt, tandis que le modèle rédige la partie du rapport qui n’en dépend pas. Le gain tient à la réduction du temps d’inactivité, pas à une exécution gratuite.

Le pilotage en cours de tour change la logique de redémarrage

Le pilotage en cours de tour permet à un utilisateur de corriger une tâche pendant qu’Astra travaille encore. L’application envoie un événement response.steer sur le même WebSocket Responses, le rattache à la réponse active avec previous_response_id et fournit la nouvelle instruction. Le serveur termine l’Item de sortie en cours et le travail des outils hébergés déjà lancés, puis crée une suite qui intègre la mise à jour.

Ce mécanisme aide, par exemple, un responsable d’agence qui constate que le rapport vise le mauvais marché, ou un responsable technique qui doit réduire le périmètre d’un plan de migration en cours. La correction peut intervenir avant la fin du tour complet.

Le travail déjà consommé le reste. Le pilotage ne réécrit pas la sortie déjà transmise, n’annule pas une action antérieure et n’interrompt pas un outil déjà lancé. Les limites de tokens et d’appels d’outils s’appliquent séparément à la réponse initiale et à sa suite. L’intérêt économique réside dans la réduction des redémarrages complets lorsqu’une correction arrive tard ; encore faut-il mesurer si ce cas se produit assez souvent.

Le pilotage est réservé à Astra et nécessite le WebSocket Responses. Les instructions en attente n’existent que sur cette connexion : l’application doit donc enregistrer chaque mise à jour acceptée et prévoir une reprise rigoureuse après une déconnexion. OpenAI limite une connexion WebSocket à 60 minutes. Pour les déploiements WebSocket comptant 20 appels d’outils ou plus, le guide WebSocket fait état d’une exécution de bout en bout jusqu’à environ 40% plus rapide ; il s’agit toutefois d’un résultat lié au transport, pas d’une économie promise grâce au pilotage.

Une migration à tester pas à pas

Commencez par un seul flux de fonctions à faible risque. Ne choisissez pas d’emblée l’agent le plus sollicité en production.

Installez la version actuelle du SDK Python et définissez la variable d’environnement comme indiqué dans le guide de démarrage d’OpenAI :

pip install openai
export OPENAI_API_KEY="your_api_key_here"

Voici l’exemple exécutable d’OpenAI pour les outils asynchrones, avec des données météo de démonstration. Lancez-le une fois que votre projet API dispose d’un accès à Astra :

import json
from concurrent.futures import ThreadPoolExecutor

from openai import OpenAI
from openai.types.responses import FunctionToolParam

def get_weather(city):
    # Demo data. Replace this function with your weather service.
    weather = {
        "Paris": {
            "city": "Paris",
            "temperature_c": 22,
            "condition": "Clear",
            "source": "demo weather snapshot",
        }
    }
    return weather[city]

worker = ThreadPoolExecutor()

def main():
    client = OpenAI()
    model = "gpt-6-astra"
    tools: list[FunctionToolParam] = [
        {
            "type": "function",
            "name": "get_weather",
            "description": "Read the demo weather snapshot for a city.",
            "async": True,
            "strict": True,
            "parameters": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
                "additionalProperties": False,
            },
        },
    ]

    instructions = (
        "Start the weather lookup and answer the independent packing "
        "question without waiting. Use the actual tool result when it "
        "arrives; never invent it. Identify the weather as demo data."
    )
    response = client.responses.create(
        model=model,
        tools=tools,
        instructions=instructions,
        input=(
            "Check the demo weather in Paris. Meanwhile, "
            "list three essentials for any city trip."
        ),
    )

    call = next(item for item in response.output if item.type == "function_call")
    arguments = json.loads(call.arguments)
    if call.name != "get_weather" or arguments != {"city": "Paris"}:
        raise ValueError("Expected a weather lookup for Paris")

    latest_response_id = response.id
    if call.async_:
        job = worker.submit(get_weather, **arguments)
        print(response.output_text)
        # Independent work or conversation turns can happen here.
        # Update latest_response_id after each continuation.
        result = job.result()
    else:
        result = get_weather(**arguments)

    response = client.responses.create(
        model=model,
        tools=tools,
        instructions=instructions,
        previous_response_id=latest_response_id,
        input=[
            {
                "type": "function_call_output",
                "call_id": call.call_id,
                "output": json.dumps(result),
            },
        ],
    )
    print(response.output_text)

if __name__ == "__main__":
    try:
        main()
    finally:
        worker.shutdown(wait=True)

La ligne qui risque de passer inaperçue est call_id: call.call_id. Le résultat ultérieur appartient à l’appel d’outil initial, même si de nouveaux tours de conversation ont modifié l’identifiant de réponse le plus récent.

À quelle équipe chaque fonction est-elle destinée ?

Une équipe backend qui appelle déjà des fonctions

Avant d’adopter Astra sur ce parcours, budgétez la migration vers Responses. Vous obtiendrez ainsi une bascule maîtrisée, appuyée sur des logs et des évaluations comparables, au lieu de devoir déboguer simultanément un changement d’endpoint, de parseur et de modèle.

Un agent SaaS qui attend des services lents

Réservez le mode asynchrone aux travaux réellement indépendants. Une consultation CRM, une recherche interne ou un export de document peut démarrer pendant qu’Astra traite une autre branche. Si une dépendance bloque la décision suivante, elle doit rester synchrone ou passer par un outil d’attente explicite.

Une équipe opérationnelle ou une agence qui supervise des tâches longues

Proposez le pilotage pour les corrections qui provoqueraient autrement une annulation suivie d’un redémarrage. Mesurez le nombre de redémarrages effectivement évités et la quantité de travail achevé que chaque correction permet de conserver. Vous disposerez alors d’un dossier économique, pas seulement d’une démonstration de fonctionnalité.

Une entreprise réglementée soumise à la Zero Data Retention

Le mode WebSocket de Responses fonctionne avec store: false et la Zero Data Retention, mais la gestion de l’état vous revient. Conservez les Items de raisonnement chiffrés lorsque c’est nécessaire, rejouez le contexte complet lorsqu’un identifiant de réponse n’est plus disponible et concevez ce parcours de reprise avant d’ouvrir le pilotage aux utilisateurs.

Ce qu’il faut regarder en face

L’accès à Astra est toujours en cours de déploiement. La migration peut être préparée dès maintenant, mais le passage complet en production doit attendre que le projet ait accès au modèle et que les évaluations propres à la charge de travail soient terminées.

Les outils asynchrones imposent un registre de tâches et des résultats susceptibles d’arriver dans le désordre. Le pilotage ajoute l’état de la connexion, la gestion des suites et la reprise. Ces deux fonctions peuvent réduire le temps perdu en attente ou en redémarrages, mais elles ajoutent aussi du code susceptible de tomber en panne.

L’équation tarifaire restera incertaine sans votre télémétrie. À nombre de tokens identique, le coût d’Astra équivaut à 2.5 fois celui de GPT-5.6 Sol aux tarifs promotionnels. Une meilleure mise en cache, moins de tokens en sortie et moins de redémarrages peuvent combler l’écart pour certaines tâches. Placez le pilote derrière une limite de dépenses stricte, puis évaluez Astra selon le coût par tâche achevée et le temps opérateur.

Les actions à lancer lundi

• Si votre application utilise les appels d’outils de Chat Completions et que vous voulez adopter Astra, recensez un flux de production et financez cette semaine un parcours Responses parallèle.
• Si votre application se limite au texte, ne la modifiez pas pendant le déploiement des accès. Ce parcours n’est soumis à aucune migration forcée d’endpoint.
• Si les outils lents concentrent l’essentiel du temps écoulé, testez une fonction asynchrone et mesurez le temps d’inactivité, les échecs et le coût par tâche achevée.
• Si les corrections humaines tardives provoquent des redémarrages, ne prototypez le pilotage qu’après avoir validé les tests de reconnexion WebSocket et de rejeu.
• Si le tarif par token d’Astra, multiplié par 2.5, détruit l’économie unitaire avant même tout gain mesuré, conservez cette charge de travail sur GPT-5.6 Sol, Terra ou Luna.

Pour recevoir le prochain changement de plateforme, traduit en workflow et en décision budgétaire, inscrivez-vous à la newsletter.