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.
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.
Client-Delegation konfigurieren
Setze delegation beim Erstellen deiner Live-Sitzung:
export const session = {
model: "gpt-live-1",
delegation: {
type: "client",
},
};Deine Anwendung konfiguriert und betreibt das Backend. Wähle das Modell oder den Dienst, die Anweisungen, die Tools und das Routing. Wenn das Backend die Responses API nutzt, gib Modell und Tools in den Responses-Anfragen deiner Anwendung an.
Wenn GPT-Live Unterstützung anfordert, erstelle die Backend-Anfrage aus dem gespeicherten Gesprächsverlauf und dem aktuellen Aufgabenstatus. Prüfe die Berechtigungen und die erforderlichen Bestätigungen, führe die Aufgabe aus und entscheide, welche Ergebnisse du zurückgibst.
Den Gesprächskontext in deiner Anwendung pflegen
Bei der Client-Delegation sammelst du die Transkripte und hältst den Aufgabenstatus selbst aktuell.
Achte auf session.input_transcript.delta und session.output_transcript.delta. Diese Ereignisse enthalten den Transkripttext in delta sowie die Zeitstempel start_ms und end_ms. Bewahre genug Gesprächsverlauf auf, um kurze Antworten wie „Ja“, Korrekturen wie „Donnerstag, nicht Freitag“ und bereits genannte Einzelheiten einordnen zu können. Ein Transkriptfragment ist kein vollständiger Gesprächsbeitrag. Transkripte können Fehler enthalten.
Das separate Ereignis session.delegation.created enthält einen Zeitstempel in offset_ms und Delegationsmetadaten, darunter delegation.id und delegation.target. Es enthält weder die Äußerung der Person noch den Aufgabentext. Ermittle anhand der Transkriptereignisse und des Anwendungszustands, was die Person möchte. Speichere delegation.id, damit du spätere Aktualisierungen dieser Anfrage zuordnen kannst.
Bewahre umfangreiche Datensätze und vollständige Tool-Ausgaben im Backend auf. Wenn du eine Ersatzsitzung erstellst, stelle den relevanten Kontext aus deiner Anwendung wieder her. Prüfe vor einer Wiederholung, welche Aktionen bereits ausgeführt wurden.
Eine Client-Delegation empfangen
session.delegation.created identifiziert eine Delegation:
{
"type": "session.delegation.created",
"event_id": "event_delegation",
"offset_ms": 1000,
"delegation": {
"id": "item_9tA2bF3h7K9m2P5q8R1s4",
"type": "delegation",
"target": "client"
}
}Speichere event.delegation.id und übernimm die ID unverändert in alle Aktualisierungen zu dieser Aufgabe.
Gib mit dieser ID ein Ergebnis zurück:
import type { ClientEvent } from "openai/resources/live/live";
export function sendUpdate(connection: { send: (event: ClientEvent) => void }) {
connection.send({
type: "session.commentary.append",
event_id: "result_123",
delegation_id: "item_9tA2bF3h7K9m2P5q8R1s4",
content: "The order shipped today and should arrive tomorrow.",
});
}Verwende session.commentary.append für Ergebnisse, die GPT-Live aussprechen soll. Das Modell ist darauf trainiert, den Text in eigenen Worten wiederzugeben. Verwende session.thinking.append für Fakten oder Zwischenstände, die GPT-Live in späteren Antworten berücksichtigen kann, ohne sie beim Empfang auszusprechen. Du kannst mehrere Aktualisierungen mit derselben Client-Delegations-ID senden.
Inhaltsgrenzen und Pflichtfelder findest du im Abschnitt Die passende Aktualisierung senden. Wie du eine gesprochene Bestätigung vermeidest, während dein Backend arbeitet, erfährst du im Abschnitt Automatische Bestätigungen während der Tool-Ausführung unterdrücken.
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.
Sende bei der Client-Delegation den eingetippten Wert direkt an das Backend, das das Gespräch verarbeitet. Korrigiert der Wert eine laufende Aufgabe, aktualisiere diese, statt dieselbe Aufgabe erneut zu starten. Eine kurze sachliche Zusammenfassung kannst du mit session.thinking.append auch an die Live-Sitzung senden. Für ein Ergebnis, das die Person hören soll, nutze session.commentary.append.
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.
Sende bei der Client-Delegation die visuellen Eingaben zusammen mit dem relevanten Gesprächskontext und Anwendungszustand an das Backend, das die delegierten Anfragen bearbeitet. Gib die Erkenntnisse knapp über den Ablauf für Client-Ergebnisse zurück.
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: Verwendeauto,default,flexoderpriority, je nachdem, was das Modell unterstützt und worauf dein Projekt Zugriff hat. Beiautogilt 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.
Client-Delegation
Deine Anwendung steuert den gesamten Ablauf vom Empfang der Delegation bis zur Rückgabe des Ergebnisses. Bereite diesen Ablauf vor, während die Sprachsitzung läuft:
- Backend-Verbindungen wiederverwenden. Halte den API-Client und seinen Verbindungspool über einzelne Delegationen hinweg aktiv. Ziehe für wiederholte Responses-Aufrufe einen dauerhaften Responses-WebSocket in Betracht.
- Bekannte Konfiguration vorbereiten. Initialisiere Anweisungen, Tools und Verbindungen, bevor die erste Anfrage sie benötigt. Im WebSocket-Modus von Responses kannst du einen bekannten Anfragezustand bereits vor der Generierung vorbereiten. Folge dazu der Setup-Anleitung.
- Verwertbare Ergebnisse fortlaufend senden. Gib mit
session.commentary.appendgeprüfte, in sich verständliche Teilergebnisse zurück. Nutzesession.thinking.appendfür Fortschrittsmeldungen ohne Sprachausgabe. Behalte die Client-Delegations-ID bei und halte die Grenze von 500 Token pro Ergänzung ein. Belasse interne Überlegungen im Backend und prüfe den Erfolg einer Aktion, bevor du ihn meldest. - Wiederverwendbare Eingaben stabil halten. Behalte Anweisungen, Tool-Definitionen und deren Reihenfolge sowie unveränderte Anfangsabschnitte des Verlaufs bei. Wenn dein Backend Caching und Fortsetzungen unterstützt, hänge neue Informationen hinter dem wiederverwendbaren Inhalt an.
- Vollständige, hilfreiche Aktualisierungen weiterleiten. Sende jedes Ergebnis, sobald genug Text vorliegt, um es für sich genommen zu verstehen. Lass das Backend jede Aktualisierung als Fortschrittsmeldung oder Ergebnis kennzeichnen, damit deine Anwendung das passende Ereignis zum Anhängen wählen kann. Wenn das Backend die Kategorien durch ein Textpräfix kennzeichnet, warte vor dem Weiterleiten auf das vollständige Präfix.
Miss beim Vergleich dieses Ablaufs mit der Responses-Delegation die Zeit bis zur ersten hilfreichen gesprochenen Antwort.
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_callskann 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.