Den vollständigen Index der Dokumentation findest du in llms.txt. Die Markdown-Version einer Dokumentationsseite erhältst du, indem du .md an die URL der Seite anhängst.
Hauptnavigation
Design

Delegation und Tools in GPT-Live

Binde einen Backend-Agenten an und gib geprüfte Ergebnisse an das Live-Gespräch zurück.

GPT-Live führt das Sprachgespräch und delegiert Reasoning und Tool-Aufrufe an ein Backend. Die Aufgaben im Backend kann das konfigurierte Responses-Modell übernehmen. Bei der Client-Delegation kannst du dafür jedes Modell, jeden Agenten oder jeden Dienst einsetzen, den deine Anwendung betreibt. In beiden Modi verwaltet deine Anwendung die Berechtigungen, Bestätigungen, Geschäftsdaten und den Aufgabenstatus.

Im Prompting-Leitfaden erfährst du, wie du die Delegation und den Tool-Einsatz des Live-Modells steuerst.

Die Ereignisbeispiele auf dieser Seite verwenden connection. Das ist eine bestehende Verbindung über den primären Live-WebSocket oder einen Sideband-WebSocket, wie in den Verbindungsleitfäden beschrieben. Warte bei einer primären Verbindung auf session.started, bevor du eine Hilfsfunktion für Ereignisse aufrufst. Eine angebundene Sideband-Verbindung gehört bereits zu einer laufenden Sitzung.

Delegationsmodus wählen

Bei der Responses-Delegation ruft GPT-Live das von dir gewählte Responses-Modell auf, übergibt den Gesprächskontext und gibt die Backend-Ergebnisse an das Live-Gespräch zurück. Bei der Client-Delegation stellt deine Anwendung den Kontext zusammen, führt einen Agenten oder Workflow aus und sendet die Ergebnisse an GPT-Live zurück.

Beginne mit der Responses-Delegation, wenn GPT-Live die Anfragen verwalten soll. Wähle die Client-Delegation, wenn du einen eigenen Workflow ausführen oder die Ergebnisse prüfen musst, bevor du sie an GPT-Live sendest.

Kriterium Die Responses-Delegation passt, wenn … Die Client-Delegation passt, wenn …
Implementierungsaufwand GPT-Live Backend-Anfragen vorbereiten, Verbindungen verwalten und Ergebnisse an das Gespräch zurückgeben soll. du diese Komponenten selbst entwickeln und betreiben möchtest.
Prüfung der Backend-Ergebnisse das Backend seine Ergebnisse direkt an GPT-Live zurückgeben kann. deine Anwendung Ergebnisse prüfen, sensible Inhalte schwärzen, Ergebnisse zusammenführen oder verwerfen muss, bevor sie GPT-Live erreichen.
Backend-Funktionen die von GPT-Live unterstützten Responses-Einstellungen und Tools für deinen Workflow ausreichen. du ein anderes Backend, mehrere Modelle oder API-Funktionen außerhalb der verwalteten Konfiguration brauchst.
Kontrolle über den Kontext der von GPT-Live bereitgestellte Gesprächskontext für deine Anwendung ausreicht. du für jede Backend-Anfrage genau auswählen musst, welche Teile des Verlaufs, welche Erinnerungen und welchen Anwendungszustand sie erhält.
Steuerung der Ausführung das konfigurierte Modell und die Schleife für Tool-Aufrufe zur Aufgabe passen. du ein eigenes Routing zwischen Code und Modellen, Ausweichstrategien, Prüfpunkte oder schrittübergreifende Budgets im Backend brauchst.

Ein Reiseassistent kann beispielsweise Fragen zum Flugstatus an einen Dienst der Fluggesellschaft und Änderungen am Reiseplan an einen separaten Planungsagenten senden. Die Anwendung entscheidet, welches Backend sie aufruft und welches geprüfte Ergebnis sie an GPT-Live zurückgibt.

In beiden Modi verfolgt deine Anwendung den Aufgabenfortschritt und prüft vor der Ausführung eigener Tools die Berechtigungen und die erforderlichen Bestätigungen der Person im Gespräch. GPT-Live kann weitersprechen, während deine Anwendung ein Backend-Ergebnis prüft. Wenn deine Anwendung steuern muss, wann die Person die Audioausgabe hört, ergänze eine Wiedergabesteuerung.

Bei der Client-Delegation muss deine Anwendung außerdem den Gesprächskontext pflegen. Das Delegationsereignis enthält Metadaten, aber keinen Aufgabentext. Bereite die Backend-Anfrage anhand der Transkriptereignisse und des Anwendungszustands vor.

Vergleiche bei der Evaluation deines Sprachagenten Latenz, Aufgabenerfolg und Kosten anhand deiner eigenen Aufgaben. Hinweise für deine bestehende Architektur findest du im Leitfaden zur Migration auf GPT-Live.

Wähle den Modus beim Erstellen der Sitzung. Um den Modus zu wechseln, starte eine neue Sitzung.

Delegationsmodus

Responses-Delegation konfigurieren

Füge beim Erstellen deiner Live-Sitzung diese Delegationskonfiguration hinzu. Wähle das Responses-Modell unabhängig vom Modell für das Sprachgespräch:

export const session = {
  model: "gpt-live-1",
  delegation: {
    type: "responses",
    responses: {
      model: "gpt-6-luna",
      instructions: "[Your backend prompt]",
    },
  },
};

Beginne mit gpt-6-luna oder probiere für komplexere Backend-Aufgaben gpt-6-sol aus. Vergleiche Antwortqualität und Latenz anhand deiner Aufgaben, bevor du dich für ein Backend-Modell entscheidest.

Registriere die unterstützten Tools in delegation.responses.tools. Setze delegation.responses.tool_choice auf "auto", damit das Backend ein Tool auswählen kann, auf "required", um einen Tool-Aufruf vorzuschreiben, oder auf "none", um Tool-Aufrufe zu deaktivieren. Du kannst auch eine Funktion anhand ihres Namens auswählen.

Setze delegation.responses.parallel_tool_calls auf true, um mehrere Tool-Aufrufe in einer Antwort zuzulassen, oder auf false für aufeinanderfolgende Aufrufe. Deine Anwendung führt eigene Funktionen aus und prüft deren Abhängigkeiten und erforderliche Genehmigungen. Diese Einstellungen greifen, sobald GPT-Live eine Aufgabe delegiert hat. Über den Live-Prompt steuerst du, wann GPT-Live delegieren soll.

Beim Erstellen der Responses-Konfiguration musst du das Backend-Modell im Feld model angeben. Neben den unten aufgeführten Tools stehen max_output_tokens (falls gesetzt, mindestens 16), service_tier sowie die vom gewählten Backend-Modell unterstützten Einstellungen für reasoning und text zur Verfügung. Welche Einstellungen du anpassen kannst, erfährst du im Abschnitt Backend-Latenz senken.

Wenn der Schnellmodus für dein Modell und Projekt verfügbar ist, ziehe ihn für zeitkritische Aufrufe in Betracht. Für GPT-Live wählst du ihn mit delegation.responses.service_tier: "priority" aus.

Sende session.update mit den Änderungen in session.delegation.responses, um während des Gesprächs das Backend-Modell, die Anweisungen, die Tools, tool_choice oder andere unterstützte Einstellungen zu aktualisieren. Einstellungen, die du weglässt, behalten ihren aktuellen Wert.

Erstelle eine neue Live-Sitzung, um zwischen Responses- und Client-Delegation zu wechseln. Wenn du delegation auf null setzt, wählst du den Client-Modus. Sendest du diese Änderung an eine laufende Responses-Sitzung, schlägt sie mit immutable_field_update fehl.

Die Einstellungen verwenden vertraute Responses-Konzepte. Live unterstützt allerdings nur einen Teil der eigenständigen Responses API. Live stellt den Gesprächskontext bereit und stößt delegierte Aufgaben an. Konfiguriere das Backend über die Sitzung. Der Live-Befehl response.create verwendet diese Konfiguration und akzeptiert keinen separaten Anfragebody für die Responses API.

Gehostete Tools hinzufügen

Füge die Websuche, die Dateisuche, den Code Interpreter, die Hosted Shell oder die Bildgenerierung zu delegation.responses.tools hinzu. Die verlinkten Leitfäden beschreiben die Konfiguration, die unterstützten Modelle und die benötigten Ressourcen. Responses führt diese Tools aus und gibt ihre Ergebnisse automatisch zurück.

Verwende für die Shell einen gehosteten Container, optional mit Skills. Wenn du einen Skill neu hochgeladen hast, warte, bis die referenzierte Version lesbar ist, bevor du die Live-Sitzung startest. Bei einer lokalen Shell muss deine Anwendung die Aufrufe ausführen. Live unterstützt domain_secrets für die Shell nicht.

MCP und weitere Tools hinzufügen

Die Responses-Delegation unterstützt außerdem MCP, die Tool-Suche, programmatische Tool-Aufrufe, Funktionen und eigene Tools, die Computernutzung, die lokale Shell und das Anwenden von Patches. Folge für das Setup den verlinkten Leitfäden. Gib die Ergebnisse deiner Anwendung und ihre Genehmigungsentscheidungen über den Live-Ablauf zur Fortsetzung der Verarbeitung zurück.

Live leitet die von dir angegebenen MCP-Felder authorization und headers an Responses weiter. Die Sitzungskonfiguration, die Live an deine Anwendung zurücksendet, enthält diese Werte nicht. Wenn du andere Einstellungen wie die Anweisungen aktualisierst, musst du die Werte nicht erneut senden. Wenn du delegation.responses.tools ersetzt, gib die MCP-Zugangsdaten erneut an.

Konfigurationsfehler behandeln

Live prüft die Responses-Einstellungen nach dem Start und bei Änderungen asynchron. session.started und session.updated warten diese Prüfung nicht ab. Achte auf ein error-Ereignis mit dem Code responses_validation_failed. In der Fehlermeldung steht, welche Einstellung nicht unterstützt wird oder auf welche Ressource kein Zugriff möglich ist. Die Sitzung bleibt geöffnet. Live setzt die Einstellungen nicht zurück. Korrigiere sie mit session.update.

Gibst du beispielsweise die version eines Skills als Zahl an, etwa als 1, erhältst du den Fehler responses_validation_failed, ohne dass die Sitzung beendet wird. Das gilt sowohl für session.start als auch für session.update. Die Fehlermeldung nennt das ungültige Feld und den erwarteten Typ, ohne auf response.create zu warten. Ordne error.client_event_id dem Ereignis zu, mit dem du die Einstellungen gesendet hast. Um in derselben Sitzung fortzufahren, entferne die ungültige Tool-Konfiguration mit session.update. Gib Versionen als Zeichenfolge an, beispielsweise als "1".

Auch nach erfolgreicher Prüfung kann die spätere Tool-Ausführung fehlschlagen. Der Zugriff auf Ressourcen und die Verfügbarkeit von Tools können sich ändern. Behandle Backend-Fehler daher auch während der Ausführung delegierter Aufgaben. Beim Konfigurieren gehosteter Tools können bereits während der Prüfung Ressourcen wie Container initialisiert werden.

Das Live-Gespräch aus deiner Anwendung steuern

Bei der Responses-Delegation verwaltet GPT-Live den Backend-Workflow. Deine Anwendung kann trotzdem Kontext direkt an das GPT-Live-Modell senden. Wenn du das Gespräch über einen Sideband-WebSocket oder die primäre Ereignisverbindung verfolgst, kannst du session.instructions.append, session.thinking.append oder session.commentary.append mit delegation_id: null verwenden. Eine Schutzregel, die das Transkript prüft, kann beispielsweise eine Anweisung ergänzen, um das Gespräch umzulenken. Das steuert das Live-Modell. Der Prompt des Responses-Backends bleibt dabei unverändert und laufende Aufgaben werden fortgesetzt.

Responses-Delegationen verarbeiten

Bei Aufgaben, die Responses übernimmt, enthält session.delegation.created den Wert target: "responses" und eine response_id. Nachfolgende Responses-Ereignisse sind in ein response.event-Ereignis eingebettet:

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

Wenn das äußere Ereignis den Typ response.event hat, wähle die Verarbeitung anhand von envelope.event.type. Speichere die äußere delegation_id, um das Backend-Ereignis seiner Delegation zuzuordnen. Dein Handler kann weitere eingebettete Responses-Ereignisse zum Lebenszyklus einer Antwort empfangen.

Diese eingebetteten Ereignisse liefern Fortschrittsmeldungen gehosteter Tools, Quellenangaben, Dateien und generierte Bilder. Werte die einzelnen Ereignisse für Ausgabeelemente und Teilbilder aus, um die Ergebnisse zu sammeln. In den weitergeleiteten Momentaufnahmen des Lebenszyklus fehlen die Inhalte der Ausgabe-Arrays. Lade Dateien über die entsprechenden Datei- oder Container-APIs von Responses herunter. Nutze für große Bild- oder Artefaktereignisse eine WebSocket- oder Sideband-Verbindung, da ein WebRTC-Datenkanal eine niedrigere Obergrenze für die Nachrichtengröße haben kann.

Die Sprachausgabe und die delegierte Aufgabe laufen unabhängig voneinander weiter. Auch wenn die Backend-Antwort abgeschlossen ist, hat die Person im Gespräch die Antwort möglicherweise noch nicht gehört. Nutze für den gesprochenen Teil der Interaktion das Ausgabetranskript und die Audioausgabe von Live.

Tool-Ergebnisse und Genehmigungen zurückgeben

Bei Tools, die Eingaben deiner Anwendung benötigen, erfasse die abgeschlossenen Aufrufe aus den eingebetteten response.output_item.done-Ereignissen. Führe die autorisierte Aktion aus oder prüfe die Genehmigung. Sende dann das passende Element mit response.item.create:

Empfangenes Element Ergebniselement
function_call function_call_output
custom_tool_call custom_tool_call_output
computer_call computer_call_output
Lokaler shell_call shell_call_output
apply_patch_call apply_patch_call_output
tool_search_call mit execution: "client" tool_search_output mit execution: "client" und den gefundenen tools
mcp_approval_request mcp_approval_response

Ordne die Ergebnisse über call_id den Aufrufen zu. Setze bei MCP-Genehmigungsentscheidungen stattdessen approval_request_id auf die id der Genehmigungsanfrage und approve auf true oder false. Ein abgeschlossener mcp_call erfordert für sich genommen kein Ergebnis vom Client. Halte dich an das Ergebnisschema des jeweiligen Tools. Dazu gehören die caller-Metadaten bei programmatischen Funktionsaufrufen und alle erforderlichen Sicherheitsbestätigungen bei der Computernutzung.

Übermittle für jeden ausstehenden Aufruf das Ergebnis und sende anschließend response.create. Das Anhängen eines Elements allein setzt die Verarbeitung im Backend nicht fort. Fehlen Ergebnisse, erhältst du tool_outputs_required. Fehlen ausschließlich Funktionsergebnisse, erhältst du function_call_outputs_required. Doppelte Ergebnisse und Ergebnisse mit unpassendem Typ werden abgelehnt.

Du kannst Ergebnisse übermitteln und die Fortsetzung anfordern, bevor die aktuelle Backend-Antwort abgeschlossen ist. Ein akzeptiertes response.create wartet auf diesen Abschluss. Sende es nicht erneut. Gibt das Backend anschließend weitere Aufrufe aus, übermittle deren Ergebnisse und sende ein weiteres response.create.

Eine eigene Funktion ausführen und ihr Ergebnis zurückgeben

Lies abgeschlossene Funktionsaufrufe aus den eingebetteten response.output_item.done-Ereignissen. Das fertige Funktionselement enthält call_id, name und arguments. Ein Ereignis, das lediglich die Vollständigkeit der Argumente meldet, reicht nicht aus, um den Aufruf zu identifizieren.

Erfasse die Antwort-ID aus dem eingebetteten response.created zusammen mit der äußeren delegation_id. Sammle die Funktionsaufrufe der Antwort aus response.output_item.done. Ermittle anhand dieser Aufrufe, welche Tool-Ergebnisse du vor der Fortsetzung übermitteln musst.

Die weitergeleiteten Lebenszyklusereignisse, einschließlich response.completed, enthalten response.output: [], auch wenn für Funktionsaufrufe noch Ergebnisse ausstehen. Diese Ereignisse enthalten außerdem ein leeres tools-Array, instructions: null und kein input-Feld. Lies die Funktionsaufrufe aus den einzelnen Ereignissen für Ausgabeelemente.

Hänge nach der Ausführung der autorisierten Aktion das Ergebnis als Responses-Element an:

import type { ClientEvent } from "openai/resources/live/live";

export function sendUpdate(connection: { send: (event: ClientEvent) => void }) {
  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"}',
    },
  });
}

Fordere anschließend ausdrücklich die Fortsetzung der Antwort an:

import type { ClientEvent } from "openai/resources/live/live";

export function sendUpdate(connection: { send: (event: ClientEvent) => void }) {
  connection.send({
    type: "response.create",
    event_id: "continue_1",
  });
}

Sende für jeden ausstehenden Funktionsaufruf ein Ergebnis mit response.item.create. Sende dann response.create, um die Backend-Antwort fortzusetzen. Für response.item.create gibt es keine separate Erfolgsbestätigung. Verarbeite weiterhin Fehler und eingebettete Responses-Lebenszyklusereignisse.

Beide Befehle setzen die Responses-Delegation voraus. Der Live-Befehl response.create verwendet die in der Sitzung gespeicherte Backend-Konfiguration. Nutze die oben gezeigten Ereignisdaten und konfiguriere das Backend-Modell und die übrigen Einstellungen über die Sitzung.

Mit deinem bestehenden Backend-Prompt beginnen

Nutze den vorhandenen Prompt deines textbasierten Agenten als Ausgangspunkt. Belasse die Aufgabenanweisungen und Geschäftsregeln im Backend. Passe Anweisungen an, die einen Textchat oder die direkte Kontrolle über die Sprachausgabe voraussetzen. Beschreibe, wie der Agent mit Gesprächstranskripten umgehen und nützliche Ergebnisse zurückgeben soll. Setze Berechtigungen und erforderliche Bestätigungen in deiner Anwendung durch.

## Voice conversation context
You are helping an assistant in a live voice conversation. Transcripts
can contain mistakes, unfinished phrases, and later corrections. Use
the latest context and verified records. If a needed detail is still
unclear, ask for that detail instead of guessing.

## Task instructions
[Your task instructions, business rules, available tools,
and confirmation requirements.]

## Return the result
Return the relevant facts, the task's current status, and the next step.
Report an action as complete after the tool or service confirms success.
If the outcome is unclear, state that and explain what needs to be checked.

Belasse große strukturierte Datenmengen, lange Tool-Ausgaben und Markdown für die Anzeige im Backend. Gib GPT-Live die relevanten Fakten und überlasse dem Modell die Formulierung. Für ein knappes Tool-Ergebnis brauchst du keinen weiteren Modellaufruf, nur um es für die Sprachausgabe umzuformulieren.

Bei der Client-Delegation gibst du das Ergebnis direkt an GPT-Live zurück. Bei der Responses-Delegation gibst du die erforderlichen Tool-Ergebnisse oder Genehmigungen zurück, damit das Backend weiterarbeiten kann. Gehostete Tools arbeiten auch ohne Ergebnisse aus deiner Anwendung weiter.

Die passende Aktualisierung senden

Wähle das Ereignis danach aus, wie GPT-Live den Inhalt verwenden soll:

Was du senden möchtest Ereignis
Anweisungen für ein laufendes Live-Gespräch, etwa einen Hinweis, den das Modell geben soll, oder die Anweisung, nicht weiterzusprechen session.instructions.append
Informationen für das interne Reasoning, die das Modell beim Empfang nicht ausspricht, aber bei passenden Fragen berücksichtigen kann session.thinking.append
Informationen, die das Modell laut in eigenen Worten wiedergeben soll session.commentary.append

Alle drei Ereignisse erwarten in content eine einfache Zeichenfolge mit höchstens 500 Token pro Ergänzung. Gib delegation_id an. Verwende für eine Aktualisierung zu einer bestimmten Aufgabe die ursprüngliche Client-Delegations-ID und für allgemeinen Sitzungskontext null. Jeder andere Wert muss eine bekannte Client-Delegation identifizieren. Anweisungen gelten weiterhin für die Live-Sitzung. Durch die ID entsteht kein separater Backend-Prompt.

Für eine Begrüßung zu Gesprächsbeginn hinterlegst du die Begrüßungsanweisungen beim Erstellen der Sitzung in einer developer-Nachricht in session.input. Sende dieselben Anweisungen nach session.started einmal über session.commentary.append. Die Audioeingabe muss dabei aktiv sein. Verwende eine eindeutige event_id und delegation_id: null. Das Modell kann den Text umformulieren. Die Empfangsbestätigung belegt weder die Sprachausgabe noch die Wiedergabe. Der Abschnitt Begrüßung vor dem ersten Gesprächsbeitrag beschreibt den gesamten Ablauf und die Wiedergabesteuerung durch deine Anwendung, falls du einen exakten Wortlaut oder einen Nachweis der Wiedergabe brauchst.

Eine ergänzte Anweisung kann die aktuelle Sprachausgabe oder das aktuelle Verhalten des Modells unterbrechen. Nutze sie, wenn deine Anwendung das Gespräch umlenken muss. Setze damit verbundene Sperren für Tools oder Aktionen im Anwendungszustand durch.

So übermittelst du bei einer vom Client verwalteten Aufgabe den Fortschritt ohne Sprachausgabe:

import type { ClientEvent } from "openai/resources/live/live";

export function sendUpdate(connection: { send: (event: ClientEvent) => void }) {
  connection.send({
    type: "session.thinking.append",
    event_id: "availability_progress",
    delegation_id: "item_123",
    content: "Checking Thursday availability. No appointment has been booked.",
  });
}

Sende bei einer bestätigten Buchung das Ergebnis, das die Person hören soll:

import type { ClientEvent } from "openai/resources/live/live";

export function sendUpdate(connection: { send: (event: ClientEvent) => void }) {
  connection.send({
    type: "session.commentary.append",
    event_id: "appointment_result",
    delegation_id: "item_123",
    content: "Your appointment is confirmed for Thursday at 2:00 PM",
  });
}

Sende dieses Ergebnis erst, wenn die Buchung tatsächlich erfolgreich war. Für eine sitzungsweite Anweisung verwende session.instructions.append mit delegation_id: null.

Wenn deine Anwendung beispielsweise eine Anfrage aufgrund ihrer Schutzregeln blockiert hat, kannst du das Gespräch umlenken:

import type { ClientEvent } from "openai/resources/live/live";

export function sendUpdate(connection: { send: (event: ClientEvent) => void }) {
  connection.send({
    type: "session.instructions.append",
    event_id: "guardrail_block_17",
    delegation_id: null,
    content:
      "Stop speaking about that request. Briefly explain that you cannot help with it, then wait for the user.",
  });
}

Die Anweisung bricht die Verarbeitung im Backend nicht ab. Blockiere die betroffene Aktion und kümmere dich um bereits laufende Aufgaben in deiner Anwendung.

Die zugehörigen Empfangsbestätigungen lauten session.thinking.appended, session.commentary.appended und session.instructions.appended. Gleiche deren client_event_id mit deiner gesendeten event_id ab. Die Bestätigung erfolgt zu dem Zeitpunkt, zu dem der Kontext voraussichtlich im Modell verfügbar ist. Sie wartet nicht auf das Ende der Sprachausgabe oder der Wiedergabe. Details zum zeitlichen Ablauf und zur Fehlerbehandlung findest du im Abschnitt Wann der Kontext das Modell erreicht.

Sende Fakten und kurze Zwischenstände, die GPT-Live im Gespräch nutzen kann. Inhalte, die du mit session.thinking.append sendest, können spätere gesprochene Antworten beeinflussen. Bewahre Geheimnisse und interne Überlegungen des Backends in deiner Anwendung auf.

Automatische Bestätigungen während der Tool-Ausführung unterdrücken

Bei der Client-Delegation kannst du eine ausstehende automatische Bestätigung abbrechen. Sende dazu eine stille Kontextaktualisierung, bevor das Modell die Bestätigung generiert.

Setze beim Erstellen der Sitzung delegation.acknowledgement_delay_ms, damit deine Anwendung Zeit hat, die Aktualisierung zu senden. Verwende beispielsweise diese Konfiguration für die Client-Delegation:

{
  "delegation": {
    "type": "client",
    "acknowledgement_delay_ms": 800
  }
}

Sobald du session.delegation.created empfängst, sende session.thinking.append mit leerem content. Verwende eine eindeutige event_id und kopiere event.delegation.id in delegation_id. Sende das Ereignis, bevor du auf das Backend-Ergebnis wartest:

{
  "type": "session.thinking.append",
  "event_id": "event_quiet_progress_1",
  "delegation_id": "item_9tA2bF3h7K9m2P5q8R1s4",
  "content": ""
}

Setze die Backend-Aufgabe fort. Sobald das geprüfte Ergebnis zur Sprachausgabe bereit ist, sende es über session.commentary.append mit derselben Delegations-ID. Wenn du den Fortschritt als Kontext übermitteln möchtest, kannst du beim Ergänzen des Reasoning-Kontexts auch eine sachliche Meldung wie "Lookup in progress." senden. Damit brichst du die ausstehende Bestätigung ebenfalls ab, ohne das Modell zur Sprachausgabe dieser Meldung aufzufordern.

Jede Ergänzung des Reasoning-Kontexts oder des Kommentars bricht alle ausstehenden automatischen Bestätigungen der Sitzung ab, auch die anderer Delegationen. Bereits generierte Audioausgaben werden dadurch nicht gestoppt. Das Modell kann auch unabhängig davon sprechen. Die Verzögerung legt fest, wann die automatische Bestätigung angefordert wird. Das Modell kann schon vorher sprechen. Die Ereignisspezifikation findest du in der Referenz zur Client-Delegation und zur Ergänzung des Reasoning-Kontexts.

Wenn du session.thinking.appended empfängst, ordne das Ereignis anhand seiner client_event_id deinem gesendeten Ereignis zu. Das bestätigt die Zustellung des Kontexts. Ob das Modell tatsächlich schweigt, musst du anhand der Audioausgabe für deine Aufgaben testen. Nutze die Wiedergabesteuerung durch die Anwendung, wenn du Stille garantieren musst.

Präzise und hilfreiche Aktualisierungen senden

Sende bei längeren Aufgaben eine Aktualisierung, wenn sich etwas Relevantes ändert, etwa wenn ein Schritt abgeschlossen ist, eine Verzögerung ins Gewicht fällt oder du eine Rückfrage stellen musst.

Nutze session.thinking.append im Client-Modus für Fortschrittsmeldungen im Hintergrund. Nutze session.commentary.append, wenn die Person im Gespräch die Meldung hören sollte.

Sende für gesprochene Aktualisierungen session.commentary.append mit einem Inhalt, der dem geprüften Aufgabenstatus entspricht:

Status Beispielinhalt
In Bearbeitung „Ich prüfe gerade, welche Termine frei sind.“
Abgeschlossen „Dein Termin für Donnerstag um 14 Uhr ist gebucht.“
Fehlgeschlagen „Dieser Termin ist nicht mehr verfügbar.“
Stornierung bestätigt „Dein Termin wurde storniert.“

Wenn die Person ihre Anfrage ändert, aktualisiere die aktive Aufgabe in deiner Anwendung. Ändert sie beispielsweise Freitag in Donnerstag, verwende für die weitere Bearbeitung Donnerstag und ignoriere Ergebnisse aus der überholten Anfrage für Freitag. Wickle einen Abbruch im Backend ab und prüfe, ob er erfolgreich war, bevor du der Person mitteilst, dass die Aufgabe abgebrochen wurde. Eine Unterbrechung des Sprachgesprächs lässt die Backend-Aufgabe weiterlaufen.

Prüfe vor dem erneuten Versuch eines fehlgeschlagenen Tool-Aufrufs, ob die ursprüngliche Aktion bereits ausgeführt wurde. Eine verloren gegangene Antwort darf beispielsweise keine zweite Buchung auslösen. Ist das Ergebnis unklar, sag das und biete einen sinnvollen nächsten Schritt an.

Kontext aus der Benutzeroberfläche bereitstellen

Gib GPT-Live eine kurze Zusammenfassung der aktuellen Seite oder Aufgabe, der relevanten Auswahl und der Fakten, die helfen, Verweise wie „diese Option“ zu verstehen. Erstelle die Zusammenfassung direkt aus dem Anwendungszustand. Für die Formatierung brauchst du keinen zusätzlichen Modellaufruf.

Sende den Kontext der Benutzeroberfläche beim Sitzungsstart und bei relevanten Zustandsänderungen. Überspringe Aktualisierungen ohne Änderungen. Fasse rasch aufeinanderfolgende Änderungen zu einem kurzen Überblick über den neuesten Stand zusammen. Benenne Änderungen an einer früheren Auswahl ausdrücklich:

  • Anfangskontext: „Die Person prüft die Angaben für eine Tischreservierung am 6. August um 19 Uhr für zwei Gäste. Es wurde noch nicht reserviert.“
  • Korrektur: „Ausgewählt ist jetzt 20 Uhr. Zuvor war 19 Uhr ausgewählt.“

Verwende in beiden Delegationsmodi session.thinking.append mit delegation_id: null für Kontextaktualisierungen im Hintergrund. Bewahre vollständiges HTML, DOM-Bäume, große JSON-Datenmengen und Interaktionsprotokolle in deiner Anwendung oder im Backend auf. Behandle Seiteninhalte als Referenzdaten. Sie sind keine Anweisungen.

Texteingaben entgegennehmen

Sende eingetippte Werte wie Bestellnummern als Nutzereingaben an das Backend, damit es den exakten Text verwenden kann.

Stelle bei der Responses-Delegation eine Nutzernachricht für das Backend in die Warteschlange:

import type { ClientEvent } from "openai/resources/live/live";

export function sendUpdate(connection: { send: (event: ClientEvent) => void }) {
  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.",
        },
      ],
    },
  });
}

Sende response.create, sobald das Backend die Verarbeitung starten oder fortsetzen soll. Wartet es auf Funktionsergebnisse, gib zuerst alle erforderlichen Ergebnisse zurück. Durch das Einreihen von Text werden laufende Aufgaben nicht abgebrochen.

Bilder und visuellen Kontext hinzufügen

Damit eine Person im Gespräch ein Foto oder einen Bildschirminhalt besprechen kann, sende das Bild zusammen mit dem relevanten Kontext aus deiner Anwendung an ein Backend, das Bilder verarbeiten kann. Das Backend interpretiert das Bild und gibt die relevanten Informationen als Text an GPT-Live zurück, damit das Modell sie im Gespräch nutzen kann. Das Audio-Frontend von Live nimmt Bilder nicht direkt entgegen.

Konfiguriere bei der Responses-Delegation ein Backend-Modell, das Bilder verarbeiten kann. Stelle mit response.item.create ein unterstütztes Responses-Eingabeelement für das Bild in die Warteschlange. Sende dann response.create, um die Backend-Aufgabe zu starten oder fortzusetzen. Gib vor der Fortsetzung alle erforderlichen ausstehenden Tool-Ergebnisse und Genehmigungen zurück. Siehe Responses-Delegationen verarbeiten.

Halte Bildeingaben für das Backend von session.input getrennt. Dieses Feld versorgt das Live-Frontend beim Start mit dem bisherigen Textverlauf. Unterstützte Bildformate und Einschränkungen der Modelle findest du im Leitfaden zur Bildverarbeitung.

Backend-Latenz senken

Verkürze die Zeit zwischen der Anforderung einer Backend-Aufgabe und einem für das Gespräch verwertbaren Ergebnis. Miss die Latenz in jeder Phase, um Verzögerungen zu lokalisieren. Vergleiche die Zeit bis zu einer hilfreichen gesprochenen Antwort und den Aufgabenerfolg anhand derselben Szenarien. Hinweise zur Evaluation findest du im Cookbook zur Evaluation von Sprachagenten.

Responses-Delegation

Live verwaltet dauerhafte WebSocket-Verbindungen zu Responses und bereitet bekannte Teile der Anfragekonfiguration im Voraus vor. Wenn die aktive Verbindung und der Zustand es zulassen, kann Live auch den Zustand einer früheren Antwort wiederverwenden. Miss für deine Aufgaben die Antwortzeit und die gemeldete Cache-Nutzung, um die Auswirkungen zu beurteilen.

Passe das Backend über delegation.responses an:

  • model: Wähle das Modell für Reasoning und Tool-Auswahl unabhängig vom Modell für das Sprachgespräch.
  • reasoning.effort: Wäge die Zeit für das Reasoning gegen die Qualität des Ergebnisses ab. Verwende Werte, die das gewählte Modell unterstützt.
  • service_tier: Verwende auto, default, flex oder priority, je nachdem, was das Modell unterstützt und worauf dein Projekt Zugriff hat. Bei auto gilt die Projektkonfiguration. Prüfe Leistung und Kosten der gewählten Servicestufe.

Aktualisiere unterstützte Einstellungen während der Sitzung mit session.update. Deine eigenen Tools laufen weiterhin in deiner Anwendung. Langsame Dienstaufrufe, Warteschlangen und das Puffern von Tool-Ergebnissen können die Antwort daher auch dann verzögern, wenn Live die Responses-Verbindung verwaltet. Gib jedes erforderliche Tool-Ergebnis zügig zurück und setze die Backend-Antwort fort.

Auf Transkriptfragmente reagieren

Ob deine Anwendung Transkriptfragmente verarbeitet, entscheidest du selbst. Das funktioniert in beiden Delegationsmodi. Die Transkriptfragmente beider Gesprächsseiten treffen über WebSocket oder den WebRTC-Datenkanal ein. Du kannst sie mit Anwendungslogik oder einem schlanken Modell verarbeiten, um schon vor Eingang eines Delegationsereignisses mit einer Aufgabe zu beginnen. Du kannst das Transkript auch direkt als Auslöser für Aufgaben nutzen, die deine Anwendung selbst steuert.

So kannst du dieses Verfahren einsetzen:

  • Wartezeiten verkürzen. Starte eine vorsorgliche Abfrage, sobald genügend Informationen vorliegen. Prüfe beispielsweise schon die Verfügbarkeit, während die Person ihre Wünsche weiter beschreibt.
  • Schutzregeln anwenden. Prüfe das fortlaufende Transkript auf Anfragen oder Antworten, bei denen du eingreifen musst. Siehe Schutzregeln für Gespräche anwenden.
  • Das Gespräch anpassen. Achte auf Formulierungen, die auf Unklarheit oder Frustration hindeuten. Passe dann den Gesprächsablauf an oder sende eine gezielte Anweisung.
  • Die Benutzeroberfläche aktualisieren. Hebe relevante Bedienelemente hervor, fülle vorgeschlagene Felder aus oder zeige Ergebnisse an, sobald sie vorliegen.

Nutze in Browseranwendungen den WebRTC-Datenkanal für Untertitel und lokale Aktualisierungen der Benutzeroberfläche. Wenn du Transkripte auf deinem Server verarbeitest, etwa für Schutzregeln, Prüfungen mit einem schlanken Modell oder vorsorgliche Tool-Aufrufe, verwende einen Sideband-WebSocket. Damit empfängst du Ereignisse und steuerst dieselbe GPT-Live-Sitzung direkt.

Verarbeite den bisher gesammelten Text, sobald relevante neue Informationen hinzukommen. Ein Fragment kann unvollständig sein und spätere Äußerungen können die Anfrage verändern. Verwirf überholte Ergebnisse und stimme die Verarbeitung mit später delegierten Aufgaben ab, um doppelte Aktionen zu vermeiden. Prüfe vor folgenreichen Aktionen wie gewohnt die Berechtigungen und erforderlichen Bestätigungen.

Sende Erkenntnisse oder Anweisungen mit dem zur Aktualisierung passenden Ereignis an GPT-Live zurück. Verwende für Aufgaben, die außerhalb einer Client-Delegation gestartet wurden, delegation_id: null. Deine Anwendung setzt Änderungen an der Benutzeroberfläche um und steuert die Ausführung und den Abbruch von Tool-Aufrufen.

Optimierungen für beide Modi

Beide Delegationsmodi profitieren von denselben Verbesserungen am Backend:

  • Modell und Reasoning-Aufwand passend zur Aufgabe wählen. Vergleiche Konfigurationen, die deine Anforderungen an die Genauigkeit erfüllen. Wähle einen geringeren Reasoning-Aufwand, wenn das Modell die Aufgabe damit zuverlässig erledigt.
  • Antworten knapp halten. Gib die Fakten und den Status zurück, die GPT-Live zur Fortsetzung des Gesprächs braucht. Vermeide lange Erklärungen und zusätzliche Modellaufrufe, die Ergebnisse lediglich für die Sprachausgabe umformulieren.
  • Verzögerungen und unnötige Tool-Aufrufe reduzieren. Starte autorisierte Aufgaben, sobald die Eingaben vorliegen. Verwende Ergebnisse erneut, solange sie gültig sind, und vermeide es, eine abgeschlossene Abfrage zu wiederholen.
  • Unabhängige Aufgaben parallel ausführen. Unabhängige Abfragen können gleichzeitig laufen. Beachte bei Aktionen die Abhängigkeiten und erforderlichen Bestätigungen. Mit parallel_tool_calls kann ein Modell mehrere Aufrufe anfordern. Die Planung und Ausführung eigener Funktionen übernimmt weiterhin deine Anwendung.

Allgemeine Hinweise zu Responses findest du im Leitfaden zur Latenzoptimierung. Wie du unveränderte Eingaben wiederverwendest, erfährst du im Leitfaden zum Prompt-Caching.

Die gesamte Interaktion überprüfen

Prüfe, ob das Backend die beabsichtigte Aktion abgeschlossen und der Client die erwartete gesprochene Antwort wiedergegeben hat. Prüfe beispielsweise nach einer erfolgreichen Reservierung sowohl den Buchungseintrag als auch die tatsächlich wiedergegebene Audioausgabe. Das Backend kann die Aufgabe abschließen, obwohl die gesprochene Antwort unterbrochen wird. Teste die beiden Ergebnisse deshalb getrennt.

Erfasse neben der GPT-Live-Delegations-ID für jede Aktion deiner Anwendung eine eigene Vorgangs-ID und für jede geänderte Anfrage eine neue Aufgabenversion. Anhand dieser Daten kannst du nach einem Verbindungsneuaufbau oder einem erneuten Versuch bereits abgeschlossene Aufgaben erkennen und Ergebnisse überholter Anfragen verwerfen.

Nutze den Leitfaden zur Evaluation von Sprachagenten für wiederholbare Tests. Wenn du bereits eine Realtime-Schleife für Tool-Aufrufe oder ein Backend mit verketteten Verarbeitungsschritten einsetzt, folge dem Leitfaden zur Migration auf GPT-Live.