Délégation et outils dans GPT-Live

Configurez la délégation à Responses

Ajoutez cette configuration de délégation lors de la création de votre session Live. Choisissez le modèle Responses indépendamment du modèle vocal :

1
2
3
4
5
6
7
8
9
10export const session = {
  model: "gpt-live-1",
  delegation: {
    type: "responses",
    responses: {
      model: "gpt-5.6-terra",
      instructions: "[Your backend prompt]",
    },
  },
};

1
2
3
4
5
6
7
8
9
10
11
12from openai.types.live.session_config_param import SessionConfigParam

session: SessionConfigParam = {
    "model": "gpt-live-1",
    "delegation": {
        "type": "responses",
        "responses": {
            "model": "gpt-5.6-terra",
            "instructions": "[Your backend prompt]",
        },
    },
}

Commencez avec GPT-5.6 Terra, ou essayez GPT-5.6 Luna pour les charges de travail où le coût est déterminant. Comparez la qualité des réponses et la latence sur vos tâches avant de choisir un modèle pour le backend.

Déclarez les outils pris en charge dans delegation.responses.tools. Utilisez delegation.responses.tool_choice pour contrôler les outils que le backend peut utiliser : "auto" le laisse choisir, "required" impose un appel d’outil et "none" l’interdit. Vous pouvez aussi sélectionner une fonction par son nom. Définissez delegation.responses.parallel_tool_calls sur true pour autoriser les recherches indépendantes en parallèle, ou sur false lorsque les appels doivent s’exécuter séquentiellement. Votre application reste responsable de l’exécution de ses fonctions personnalisées et du respect des dépendances et des approbations. Ces paramètres ne forcent pas le modèle vocal à déléguer.

La configuration Responses exige de définir le paramètre model du backend à la création. Elle prend en charge les définitions function et les entrées web_search dans tools. Elle expose également max_output_tokens (au moins 16 si ce paramètre est défini), service_tier, ainsi que les paramètres reasoning et text pris en charge par le modèle de backend sélectionné. Consultez Réduisez la latence du backend pour connaître les paramètres que vous pouvez ajuster.

Si le mode Rapide est disponible pour votre modèle et votre projet, envisagez de l’utiliser pour les appels sensibles à la latence. Pour GPT-Live, sélectionnez-le avec delegation.responses.service_tier: "priority".

À mesure que la conversation évolue, envoyez session.update avec les modifications dans session.delegation.responses pour mettre à jour le modèle du backend, les instructions, les outils disponibles, tool_choice ou d’autres paramètres pris en charge sans démarrer une nouvelle session Live. Les paramètres omis conservent leur valeur. Définir delegation sur null sélectionne le mode client et ne permet pas de réinitialiser une session Responses en cours ; le changement de mode échoue avec immutable_field_update.

Ces paramètres reprennent des concepts familiers de Responses, mais Live ne prend en charge qu’un sous-ensemble de l’API Responses autonome. Live fournit le contexte de la conversation et lance les tâches déléguées. Configurez le backend via la session ; la commande Live response.create utilise cette configuration et n’accepte pas de corps de requête Responses autonome.

Orientez la conversation en direct depuis votre application

La délégation à Responses gère le workflow du backend, mais votre application peut toujours envoyer du contexte directement au modèle GPT-Live. Si vous suivez l’appel via une connexion WebSocket auxiliaire ou la connexion principale aux événements, vous pouvez utiliser session.instructions.append, session.thinking.append ou session.commentary.append avec delegation_id: null. Par exemple, un garde-fou fondé sur la transcription peut ajouter une instruction pour réorienter la conversation. Cela oriente le modèle vocal, sans modifier le prompt du backend Responses ni annuler les tâches déjà en cours.

Gérez la délégation à Responses

Pour les tâches exécutées via Responses, session.delegation.created contient target: "responses" et un response_id. Les événements Responses suivants arrivent dans une enveloppe response.event :

1234567891011121314{
  "type": "response.event",
  "event_id": "event_response_1",
  "delegation_id": "item_9tA2cB6n2V8c4X1z7Q5r9",
  "event": {
    "type": "response.output_text.delta",
    "sequence_number": 4,
    "item_id": "msg_123",
    "output_index": 0,
    "content_index": 0,
    "delta": "The forecast is",
    "logprobs": []
  }
}

Aiguillez les événements selon envelope.event.type et conservez le champ delegation_id de l’enveloppe externe. Ne traitez pas chaque valeur response.* de premier niveau comme un événement Responses sans enveloppe. Prévoyez la réception d’événements imbriqués supplémentaires du cycle de vie Responses.

La parole en direct et les tâches déléguées se poursuivent indépendamment. Une réponse du backend terminée ne signifie pas à elle seule que l’utilisateur a entendu la réponse. Utilisez la transcription de sortie et l’audio de Live pour la partie orale de l’interaction.

Menez à terme un appel de fonction à exécuter par le client

Récupérez les appels de fonction complets dans les événements response.output_item.done imbriqués. L’élément de fonction finalisé contient call_id, name et arguments ; un événement signalant la fin des arguments ne suffit pas à lui seul à identifier l’appel.

Suivez l’identifiant de réponse issu de l’événement response.created imbriqué, ainsi que le champ delegation_id de l’enveloppe externe, et collectez les appels de fonction de cette réponse à partir de response.output_item.done. Les instantanés du cycle de vie transmis contiennent délibérément response.output: [], y compris lors de response.completed ; leur tableau tools est vide, instructions vaut null et input est omis. Une liste de sortie vide à l’état final ne signifie pas qu’aucun appel de fonction n’est en attente. Utilisez les appels collectés pour déterminer quels résultats doivent être envoyés avant de poursuivre.

Après avoir exécuté l’opération autorisée, ajoutez le résultat sous forme d’élément Responses :

1
2
3
4
5
6
7
8
9
10
11export function sendUpdate(connection) {
  connection.send({
    type: "response.item.create",
    event_id: "tool_result_1",
    item: {
      type: "function_call_output",
      call_id: "call_123",
      output: '{"status":"confirmed","order_id":"order_123"}',
    },
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17from openai.resources.live.live import AsyncLiveConnection
from openai.resources.live.sideband import AsyncSidebandConnection
from openai.types.responses.response_input_item_param import ResponseInputItemParam


async def send_update(
    connection: AsyncLiveConnection | AsyncSidebandConnection,
) -> None:
    item: ResponseInputItemParam = {
        "type": "function_call_output",
        "call_id": "call_123",
        "output": '{"status":"confirmed","order_id":"order_123"}',
    }
    await connection.response.item.create(
        event_id="tool_result_1",
        item=item,
    )

Déclenchez ensuite explicitement la poursuite de la réponse :

1
2
3
4
5
6export function sendUpdate(connection) {
  connection.send({
    type: "response.create",
    event_id: "continue_1",
  });
}

1
2
3
4
5
6
7
8
9
10from openai.resources.live.live import AsyncLiveConnection
from openai.resources.live.sideband import AsyncSidebandConnection


async def send_update(
    connection: AsyncLiveConnection | AsyncSidebandConnection,
) -> None:
    await connection.response.create(
        event_id="continue_1",
    )

Envoyez tous les résultats requis pour les appels d’outils en attente avant de poursuivre. L’ajout d’un résultat de fonction ne relance pas automatiquement la réponse. response.item.create n’émet pas d’accusé de réussite distinct ; continuez à traiter les erreurs et les événements imbriqués du cycle de vie de la réponse qui suivent.

response.create est une commande Live qui permet de créer ou de poursuivre des tâches déléguées à Responses en utilisant le backend configuré pour la session. Ne joignez à cet événement ni corps de requête de création de l’API Responses, ni remplacement du modèle de backend, ni delegation_id. Les deux commandes nécessitent la délégation à Responses.

Configurez la délégation au client

Définissez delegation lors de la création de votre session Live :

1
2
3
4
5
6export const session = {
  model: "gpt-live-1",
  delegation: {
    type: "client",
  },
};

1
2
3from openai.types.live.session_config_param import SessionConfigParam

session: SessionConfigParam = {"model": "gpt-live-1", "delegation": {"type": "client"}}

Cela sélectionne la délégation au client pour la session. Configurez le backend séparément : votre application choisit son modèle ou service, ses instructions, ses outils et la façon d’acheminer les tâches. Si vous utilisez l’API Responses pour ce backend, définissez son modèle et ses outils dans vos propres requêtes Responses. La session Live ne configure ni n’exécute ces outils du backend.

Lorsque GPT-Live demande de l’aide, votre application construit la requête destinée au backend à partir du contexte de la conversation et de l’application, exécute la tâche et décide des résultats à renvoyer. Faites respecter les autorisations et les confirmations requises avant d’exécuter vos outils. Conservez l’historique complet de la conversation dans votre application afin de pouvoir fournir le contexte pertinent pour chaque requête au backend.

Conservez le contexte de la conversation dans votre application

Pour la délégation au client, collectez les transcriptions et conservez vous-même l’état actuel de la tâche.

Écoutez les événements session.input_transcript.delta et session.output_transcript.delta. Ces événements contiennent le texte de transcription dans delta, ainsi que les horodatages start_ms et end_ms. Conservez suffisamment d’historique pour comprendre les réponses brèves comme « oui », les corrections comme « jeudi, pas vendredi » et les détails fournis précédemment. Un fragment de transcription ne constitue pas un tour de parole complet de l’utilisateur, et les transcriptions peuvent contenir des erreurs.

L’événement distinct session.delegation.created contient un horodatage offset_ms et des métadonnées de délégation, notamment delegation.id et delegation.target. Il ne contient pas les propos de l’utilisateur ni le texte de la tâche. Utilisez les événements de transcription et l’état de l’application pour déterminer ce que souhaite l’utilisateur. Enregistrez delegation.id pour pouvoir associer les mises à jour à cette demande.

Conservez les enregistrements volumineux et les sorties complètes des outils dans le backend. Si vous créez une session de remplacement, restaurez le contexte pertinent depuis votre application et vérifiez quelles actions ont déjà été exécutées avant de répéter une opération.

Recevez une délégation côté client

session.delegation.created identifie une délégation :

12345678910{
  "type": "session.delegation.created",
  "event_id": "event_delegation",
  "offset_ms": 1000,
  "delegation": {
    "id": "item_9tA2bF3h7K9m2P5q8R1s4",
    "type": "delegation",
    "target": "client"
  }
}

Lisez event.delegation.id. L’objet de délégation contient des métadonnées, pas le texte de la tâche. Conservez la transcription et le contexte de l’application dont votre gestionnaire de tâches déléguées a besoin. Les identifiants actuels commencent par le préfixe item_, comme dans cet exemple ; traitez l’identifiant complet comme une valeur opaque et renvoyez-le tel quel, sans chercher à en construire un ni à en analyser la structure.

Renvoyez un résultat en utilisant cet identifiant :

1
2
3
4
5
6
7
8export function sendUpdate(connection) {
  connection.send({
    type: "session.commentary.append",
    event_id: "result_123",
    delegation_id: "item_9tA2bF3h7K9m2P5q8R1s4",
    content: "The order shipped today and should arrive tomorrow.",
  });
}

1
2
3
4
5
6
7
8
9
10
11
12from openai.resources.live.live import AsyncLiveConnection
from openai.resources.live.sideband import AsyncSidebandConnection


async def send_update(
    connection: AsyncLiveConnection | AsyncSidebandConnection,
) -> None:
    await connection.session.commentary.append(
        event_id="result_123",
        delegation_id="item_9tA2bF3h7K9m2P5q8R1s4",
        content="The order shipped today and should arrive tomorrow.",
    )

Utilisez session.thinking.append pour ajouter des informations au raisonnement interne du modèle sans qu’il les énonce à voix haute au moment de l’ajout. Utilisez session.commentary.append pour un résultat que le modèle doit énoncer à voix haute ; le modèle est entraîné à reformuler le texte ajouté. Tous les ajouts contiennent une simple chaîne de caractères et nécessitent delegation_id, y compris lorsque sa valeur est null. Un identifiant non nul doit désigner une délégation côté client connue.

Des ajouts successifs de résultats peuvent poursuivre la même délégation côté client. Un accusé de réception de l’ajout arrive après le moment estimé de l’injection du contexte ; il ne prouve ni que le modèle a pris en compte ou énoncé le résultat, ni qu’une action externe a réussi.

Avec la délégation via Responses, mettez en file d’attente un message utilisateur destiné au backend :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16export function sendUpdate(connection) {
  connection.send({
    type: "response.item.create",
    event_id: "typed_order_number",
    item: {
      type: "message",
      role: "user",
      content: [
        {
          type: "input_text",
          text: "My order number is A0042.",
        },
      ],
    },
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17from openai.resources.live.live import AsyncLiveConnection
from openai.resources.live.sideband import AsyncSidebandConnection
from openai.types.responses.response_input_item_param import ResponseInputItemParam


async def send_update(
    connection: AsyncLiveConnection | AsyncSidebandConnection,
) -> None:
    item: ResponseInputItemParam = {
        "type": "message",
        "role": "user",
        "content": [{"type": "input_text", "text": "My order number is A0042."}],
    }
    await connection.response.item.create(
        event_id="typed_order_number",
        item=item,
    )

Envoyez response.create lorsque vous êtes prêt à lancer ou à poursuivre le traitement du backend. Si celui-ci attend des résultats de fonctions, renvoyez d’abord tous les résultats requis. La mise en file d’attente de texte n’annule pas à elle seule le travail déjà en cours.

Avec la délégation au client, envoyez la valeur saisie directement au backend qui gère la conversation. Si elle corrige une tâche en cours, mettez cette tâche à jour au lieu de relancer le même travail. Vous pouvez transmettre un bref résumé factuel à la session en direct avec session.thinking.append, ou utiliser session.commentary.append pour un résultat que l’utilisateur doit entendre.

Avec la délégation à Responses, configurez un modèle backend doté de capacités de vision. Mettez en file d’attente un élément d’entrée image pris en charge par Responses avec response.item.create, puis envoyez response.create pour lancer ou reprendre le traitement du backend. Renvoyez tous les résultats de fonctions requis encore en attente avant de continuer. Consultez Gérez la délégation à Responses.

Avec la délégation au client, envoyez les données visuelles au backend qui traite les requêtes déléguées, accompagnées des éléments pertinents de la conversation et de l’état de l’application. Renvoyez des conclusions concises en suivant le processus de retour des résultats du client.

Délégation à Responses

Live gère les connexions WebSocket persistantes à Responses, prépare à l’avance la connexion et les paramètres connus de la requête, et réutilise l’état des réponses précédentes lorsqu’il est disponible. Vous n’avez pas besoin d’implémenter ces étapes pour le backend hébergé. La réutilisation dépend de la connexion active et de la compatibilité de l’état ; elle ne garantit ni un accès au cache réussi ni une latence précise.

Ajustez les paramètres du backend via delegation.responses :

• model : choisissez le modèle chargé du raisonnement et de la sélection des outils indépendamment du modèle vocal.
• reasoning.effort : trouvez le bon équilibre entre le temps de raisonnement et la qualité d’exécution de la tâche, en utilisant les valeurs prises en charge par ce modèle.
• service_tier : utilisez auto, default, flex ou priority, selon la prise en charge par le modèle et les accès du projet. auto suit la configuration du projet. Évaluez les performances et le coût de l’offre choisie.

Mettez à jour les paramètres pris en charge pendant la session avec session.update. Vos outils personnalisés s’exécutent toujours dans votre application : les appels lents aux services, les files d’attente et la mise en mémoire tampon des résultats d’outils peuvent donc retarder la réponse, même lorsque Live gère la connexion à Responses. Renvoyez rapidement chaque résultat d’outil requis et poursuivez la réponse du backend.

Délégation au client

Votre application gère l’ensemble du traitement, de la réception de la délégation au retour du résultat. Préparez ce traitement pendant que la session vocale est en cours :

• Réutilisez les connexions au backend. Gardez le client API et son pool de connexions actifs d’une délégation à l’autre. Pour des appels répétés à Responses, envisagez une connexion WebSocket à Responses persistante.
• Préparez les paramètres connus. Initialisez les instructions, les outils et les connexions avant que la première requête en ait besoin. Le mode WebSocket de Responses permet aussi de préparer à l’avance l’état connu de la requête avant la génération ; suivez ses consignes de configuration.
• Transmettez les résultats utiles en streaming. Renvoyez des segments cohérents et vérifiés avec session.commentary.append. Utilisez session.thinking.append pour transmettre l’avancement sans le faire énoncer. Conservez l’identifiant de délégation au client et respectez la limite de 500 tokens par ajout. Gardez le raisonnement privé dans le backend et vérifiez que les actions ont bien abouti avant d’annoncer leur réussite.
• Gardez les entrées réutilisables stables. Conservez les instructions, les définitions des outils et leur ordre, ainsi que les préfixes d’historique inchangés. Ajoutez les nouvelles informations après le contenu réutilisable lorsque votre backend prend en charge la mise en cache et la poursuite du traitement.
• Évitez la mise en mémoire tampon inutile. Transmettez un résultat utile dès qu’il est prêt. Ne mettez en mémoire tampon que ce qui est nécessaire pour classer la sortie et former un segment cohérent. Privilégiez des métadonnées de phase structurées ; si vous utilisez des préfixes textuels pour distinguer l’avancement des résultats, attendez que le préfixe soit complet avant de transmettre le texte.

Mesurez le délai jusqu’à la première réponse vocale utile lorsque vous comparez ce traitement à la délégation à Responses.