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

Zu GPT-Live migrieren

Stelle deine Realtime-App, deinen Textagenten oder deine mehrstufige Sprachpipeline auf GPT-Live um.

GPT-Live hört zu und spricht. Ein Backend entscheidet, wie es Aufgaben erledigt und welche Tools es dafür aufruft. Behalte deine Tool-Implementierungen, Berechtigungsprüfungen und gespeicherten Aufgabendaten bei. Verbinde das Backend bei der Migration mit GPT-Live und lege fest, welches Modell welche Anweisungen erhält.

Als Beispiel dient ein Terminassistent. Er prüft, welche Termine frei sind, bittet um Bestätigung eines Termins und bucht ihn anschließend. Stelle zunächst wie in der Einstiegsanleitung beschrieben eine Verbindung zu einer Sitzung her. Speichere typische Gespräche aus deiner bisherigen Anwendung für den späteren Vergleich.

Vor der Migration

Halte fest, welche Anforderungen deine Anwendung auch nach der Migration erfüllen muss:

  • Tools und Geschäftsregeln: Liste die vorhandenen Prompts, Tools und Abläufe auf. Halte für jede Aktion fest, unter welchen Bedingungen sie ausgeführt werden darf.
  • Eingabearten: Ermittle, wo deine Anwendung Audio, Texteingaben und Bilder entgegennimmt und welches Backend sie benötigt. Siehe Bilder und visuellen Kontext hinzufügen.
  • Entscheidungen anhand des Audiosignals: Ermittle, für welche Entscheidungen der Wortlaut des Transkripts nicht ausreicht und der Originalton nötig ist. Siehe Entscheidungen anhand des Audiosignals beibehalten.
  • Sprachausgabe und Wiedergabe: Lege fest, wann der Assistent anfangen darf zu sprechen, wann er aufhören muss und welche Prüfungen vor der Audiowiedergabe abgeschlossen sein müssen.
  • Berechtigungen und Schutzmaßnahmen: Halte fest, wie deine Anwendung Berechtigungen, Bestätigungen, Eingaben und Ausgaben prüft und an welchen Stellen sie diese Prüfungen durchsetzt. Siehe Schutzmaßnahmen anpassen.
  • Dauerhaft gespeicherter Zustand: Ermittle, welche Datensätze, Fortschrittsinformationen und ausstehenden Aktionen deine Anwendung bei Verbindungsabbrüchen und über Sitzungen hinweg erhalten muss.
  • Gespräche als Vergleichsbasis: Speichere typische Gespräche aus deiner bisherigen Anwendung. Halte jeweils den Ausgangszustand, die erwarteten Tool-Aktionen, den Endzustand der Anwendung und die gesprochenen Antworten fest.

Nutze die Einstiegsanleitung, um die Sitzung einzurichten, und das Cookbook zur Evaluation von Sprachagenten, um den Vergleich zu planen.

Delegationsmodus wählen

Entscheide, wer das Backend betreibt:

  • Responses-Delegation: Konfiguriere ein gehostetes Responses-Modell, das Aufgaben analysiert und Tools auswählt. Deine Anwendung führt benutzerdefinierte Funktionen aus und gibt deren Ergebnisse zurück. Dieser Modus bietet sich an, wenn bisher dein Realtime-Modell diese Funktionen auswählt.
  • Client-Delegation: Behalte deinen vorhandenen Agenten oder Orchestrator bei. Deine Anwendung stellt ihm den Gesprächskontext bereit, startet die Verarbeitung und entscheidet, welche Ergebnisse sie an GPT-Live sendet.

Beide Modi eignen sich für beide Migrationspfade. Eine Realtime-Anwendung mit einem separaten Backend-Agenten kann diesen Agenten beispielsweise per Client-Delegation weiterverwenden. Den vollständigen Vergleich findest du unter Delegationsmodus wählen.

Migrationspfad wählen

Beginne mit Von der Realtime API migrieren, wenn dein bisheriges Sprachmodell die Tools auswählt. Beginne mit Von einem Textagenten oder einer mehrstufigen Pipeline migrieren, wenn du deinen Agenten beibehältst und GPT-Live als Sprachschnittstelle hinzufügst.

Von der Realtime API migrieren

Beginne mit dem Prompt-Leitfaden für GPT-Live. Teile deinen vorhandenen Prompt zwischen Sprachmodell und Backend auf, statt ihn vollständig in session.instructions zu kopieren. Behalte den Gesprächsstil und die Regeln zur Delegation im Sprach-Prompt. Verschiebe detaillierte Abläufe und Anweisungen zur Tool-Nutzung ins Backend.

Vorher: Das Realtime-Modell übernimmt die Sprachverarbeitung und wählt Funktionen wie check_availability und book_appointment aus. Deine Anwendung führt sie aus und gibt ihre Ergebnisse zurück.

Nachher: GPT-Live führt das Gespräch und delegiert die Aufgaben. Das Backend wählt dieselben Funktionen aus. Deine Anwendung prüft die Aufrufe weiterhin und führt sie aus. Die folgenden Schritte verwenden die Responses-Delegation. Wenn du einen externen Agenten beibehältst, verwende den Client-Adapter.

So funktioniert die Responses-Delegation

Konfiguriere das Backend-Modell, seine Anweisungen und seine Tools in delegation.responses. Wenn GPT-Live feststellt, dass eine Anfrage das Backend erfordert, ruft der Live-Dienst das Responses-Modell auf und übermittelt den relevanten Gesprächskontext. Das Backend analysiert die Aufgabe und wählt Tools aus. Deine Anwendung führt weiterhin die benutzerdefinierten Funktionen aus, setzt Berechtigungen durch und gibt die Ergebnisse zurück.

Beim Terminassistenten läuft das so ab:

  1. Eine Person fragt, welche Termine am Freitag frei sind. GPT-Live delegiert die Anfrage.
  2. Das Responses-Backend fordert den Aufruf von check_availability an.
  3. Deine Anwendung führt die Funktion aus, gibt das Ergebnis zurück und setzt die Antwort des Backends fort.
  4. GPT-Live nutzt die Antwort des Backends, um die freien Termine mit der Person zu besprechen.

GPT-Live kann weitersprechen, während das Backend arbeitet. Verfolge die Backend-Aufgabe und die Audiowiedergabe getrennt. Aktualisiere den Aufgabenstatus anhand der Tool-Ergebnisse. Ob du den Assistenten als sprechend anzeigst, richtet sich nach dem Zustand deines Audioplayers. Die Konfiguration und den vollständigen Ereignisablauf findest du unter Delegation und Tools.

Verbindung und Audioverarbeitung anpassen

Ersetze das bisherige Setup für Realtime-Sitzungen durch den Verbindungsaufbau für GPT-Live. Prüfe erneut, wie die Verbindung mit deinem Transportprotokoll startet und welches Audioformat es verwendet. WebRTC überträgt Audio über Medientracks und JSON-Ereignisse über den Datenkanal. Ein primärer WebSocket überträgt Audio in JSON-Ereignissen.

Wenn deine Realtime-Anwendung eine Serververbindung nutzt, um Anrufe zu überwachen oder Schutzmaßnahmen durchzusetzen, passe sie an die Sideband-Verbindung von GPT-Live an. Wie du Gesprächsprüfungen und Wiedergabe umstellst, erfährst du unter Schutzmaßnahmen anpassen.

Bisheriges Verhalten mit Realtime Anpassung für GPT-Live
Sende Audio über den WebSocket mit input_audio_buffer.append. Sende session.input_audio.append. Das Feld audio enthält Base64-kodierte Audiorohdaten.
Spiele bei response.output_audio.delta die Audiodaten aus dem Feld delta ab. Spiele bei session.output_audio.delta die Audiodaten aus dem Feld delta der Reihe nach ab.
Schließe bei manueller Steuerung die Audioeingabe ab oder erstelle eine Antwort, um einen Gesprächsbeitrag zu beginnen. Streame Audio kontinuierlich. GPT-Live entscheidet, wann es spricht. Entferne manuelle Audio-Commits und Auslöser für gesprochene Beiträge.
Verfolge die Audiogenerierung und den Abschluss der Antwort mit response.output_audio.done und response.done. GPT-Live sendet kein entsprechendes Ereignis für das Ende jeder gesprochenen Antwort. Verfolge die Wiedergabe im Client.
Zeige Untertitel für die anrufende Person anhand der Ereignisse zur Transkription der Eingabe an. Hänge den Text aus session.input_transcript.delta an die Untertitel der anrufenden Person an.
Zeige Untertitel für den Assistenten anhand von response.output_audio_transcript.delta an. Hänge den Text aus session.output_transcript.delta an die Untertitel des Assistenten an.

Generierung und Wiedergabe: Steuere die Sprechanzeige über deinen Audioplayer. Der Server kann die Generierung bereits abgeschlossen haben, obwohl im Player noch eine Sekunde Audio zur Wiedergabe ansteht. Bei Realtime markiert response.output_audio.done das Ende der Generierung und response.done das Ende des Antwortstreams. Prüfe response.status auf Unterbrechungen oder Fehler. GPT-Live sendet kein vergleichbares Ereignis für das Ende jeder gesprochenen Antwort.

Untertitel: Wenn die Transkription der Eingabe aktiviert ist, sendet Realtime Textfragmente über conversation.item.input_audio_transcription.delta und das endgültige Transkript über conversation.item.input_audio_transcription.completed. Hänge bei GPT-Live jedes Fragment an die Untertitel der anrufenden Person oder des Assistenten an. Beide Untertitel können sich gleichzeitig ändern. Deine Anwendung legt fest, wie sie Text gruppiert, und verfolgt die Wiedergabe über den Audioplayer. Siehe Untertitel anzeigen.

Verwende response.create, um eine delegierte Responses-Aufgabe zu starten oder fortzusetzen. GPT-Live hört dem Gespräch zu und entscheidet selbst, wann es spricht. Hinweise zum Start, zur Begrüßung, zu Unterbrechungen und zum Beenden einer Sitzung findest du unter Sitzungen verwalten.

Anweisungen für Gespräch und Backend aufteilen

Gehe bei der Migration eines Realtime-Assistenten zu GPT-Live von deinem vorhandenen Prompt aus. Verschiebe Anweisungen zum Sprechstil und zum Sprecherwechsel in den Live-Prompt. Ergänze Regeln dafür, wann Live delegieren soll. Anweisungen zur Aufgabe und zum Einsatz von Tools bleiben im Backend-Prompt.

Wenn du einen Textagenten um Sprache erweiterst, verwende seinen vorhandenen Backend-Prompt weiter und schreibe einen Live-Prompt für das Gespräch.

Das vertraute Gesprächsverhalten beibehalten

Behalte Rolle, Zielgruppe und Zweck des Assistenten bei. Achte auch auf die Details, die das Gespräch prägen:

  • Begrüßungen, Vorstellungen und gesprochene Hinweise einschließlich des vorgeschriebenen Wortlauts oder der vorgegebenen Reihenfolge.
  • Vorgaben zu Sprache und Aussprache, etwa „Sprich Englisch.“
  • Persönlichkeit, Herzlichkeit, Einfühlungsvermögen, Förmlichkeit und Sprechtempo.
  • Detailgrad der gesprochenen Antworten und Beispiele für den gewünschten Stil.
  • Wie der Assistent signalisiert, dass er zuhört, wann er zum Zuhören pausiert und wie er auf Unterbrechungen reagiert.

Auch ein kurzer Live-Prompt kann ausführliche gesprochene Antworten verlangen.

Den Live-Prompt schreiben

Nutze die empfohlene Prompt-Struktur, um Identität, Sprechstil und Gesprächsverhalten des Assistenten festzulegen. Behalte Backchannel policy und Interruption policy bei. Beschreibe dort, wie der Assistent beim Zuhören kurze Rückmeldungen gibt und wie er reagiert, wenn ihm jemand ins Wort fällt.

Damit Live Anfragen richtig delegiert, muss es wissen, was das Backend leisten kann. Beschreibe diese Funktionen in einfachen Worten. Funktionsnamen und Tool-Schemas gehören ins Backend, das die Tool-Aufrufe verarbeitet.

Passe unter Delegation policy die folgenden Abschnitte an deine Anwendung an:

  • Backend tools: Liste auf, was deine Anwendung unterstützt. Verwende dieselben Begriffe wie im vorhandenen Prompt. Beispiel: „Prüfe, welche Termine frei sind, und vereinbare Rückrufe.“
  • Delegate to the backend when: Gib an, wann Live diese Funktionen nutzen soll, etwa: „Delegiere die Anfrage, wenn jemand einen Rückruf vereinbaren möchte.“ Berücksichtige auch Korrekturen, Bestätigungen und neue Angaben, die für eine laufende Aufgabe nötig sind.
  • Do not delegate to the backend when: Beschreibe, was Live selbst erledigen kann, etwa jemanden begrüßen, eine kurze Rückfrage stellen oder Informationen aus dem Gespräch oder einem noch aktuellen Backend-Ergebnis wiederholen.

Beschreibe, wie Live über Fortschritte informieren, die nächste Frage des Backends stellen oder ein geprüftes Ergebnis mitteilen soll.

Wenn dein Assistent Anrufe beendet, gib Live Anweisungen für die Verabschiedung und dafür, wie es das Beenden des Anrufs an das Backend delegiert. Hinterlege das eigentliche Tool zum Beenden des Anrufs und den Ablauf im Backend. Ein Ablauf kann zum Beispiel vorgeben, dass die Anwendung erst die Verabschiedung vollständig abspielt, dann die Verbindung trennt, ausstehende Berechnungen abbricht und weitere Speichervorgänge verhindert. Live übernimmt die Verabschiedung und die Delegation. Backend und Anwendung führen die übrigen Schritte aus.

Den Backend-Prompt anpassen

Gehe vom ursprünglichen Prompt aus. Behalte Wortlaut, Reihenfolge, Beispiele und Struktur überall dort bei, wo sie weiterhin passen. Beschreibt der Prompt hauptsächlich Aufgaben, kannst du ihn größtenteils übernehmen.

Behalte im Backend die Anweisungen für folgende Aufgaben bei:

  • Die Anfrage interpretieren, Korrekturen übernehmen, fehlende Angaben einholen und den Aufgabenfortschritt verfolgen.
  • Fachwissen nutzen, Voraussetzungen prüfen und die Datensätze oder Dienste heranziehen, die für die Antwort maßgeblich sind.
  • Die vorgesehenen Abläufe für Suchen, Aktualisierungen, Bestätigungen, Weiterleitungen, Gesprächsübergaben, Rückrufe und andere unterstützte Aktionen einhalten.
  • Sicherheits-, Datenschutz- und Berechtigungsregeln anwenden, Fehler behandeln und Aktionen nach einer Gesprächsübergabe oder dem Ende eines Anrufs einschränken.
  • Korrekte Fakten, den Aufgabenstatus und die nächste Frage so aufbereiten, dass Live sie vermitteln kann.

Verschiebe Anweisungen zu Stimme, Begrüßung, Sprecherwechsel und Zeitpunkt der Delegation in den Live-Prompt. Passe Anweisungen, die ein direktes Gespräch zwischen Backend und anrufender Person voraussetzen, so an, dass das Backend die Informationen an Live zurückgibt. Behalte Sicherheits- und Datenschutzvorgaben in beiden Prompts bei, soweit sie bestimmen, was das jeweilige Modell sagen, fragen oder tun darf.

Behalte Funktionsnamen, Anforderungen an Argumente und Abläufe zur Tool-Nutzung in den Backend-Anweisungen bei. Hinterlege die Tool-Definitionen in der Tool-Konfiguration des Backends. Deine Anwendung führt ihre Tools aus. Anhand des aktuellen Aufgabenzustands prüft sie Berechtigungen und Argumente und stellt sicher, dass erforderliche Bestätigungen vorliegen.

Nutze das Backend-Modell, um Anfragen, Korrekturen und Bestätigungen im Gespräch zu verstehen. Reguläre Ausdrücke, Schlüsselwortlisten und Regeln für einen exakten Wortlaut erfassen Bedeutungen nicht zuverlässig, wenn diese von früheren Äußerungen oder einer Korrektur abhängen. Ein „Ja“ kann beispielsweise einen Termin bestätigen, signalisieren, dass die Person eine Frage gehört hat, oder sich auf einen früheren Vorschlag beziehen.

Behalte die Regeln für bereits laufende Aufgaben bei, wenn die anrufende Person den Assistenten unterbricht, der Anruf übergeben wird oder endet. Wenn die Sprachausgabe stoppt, läuft die Backend-Aufgabe weiter. Bittet die Person um einen Abbruch, müssen Backend und Anwendung diesen verarbeiten und Live das Ergebnis melden.

Widersprüchliche Anweisungen klären

Prüfe den ursprünglichen Prompt und die beiden neuen Prompts auf Widersprüche. Fasse wiederholte Anweisungen zusammen. Platziere Bedingungen und Ausnahmen direkt bei der jeweiligen Regel. Prüfe Berechtigungen, die zulässige Anzahl von Fragen, erforderliche Bestätigungen und die Aktionen, die nach Gesprächsende noch erlaubt sind.

Unterscheide zwischen dem Wunsch der anrufenden Person und dem tatsächlichen Stand. Ändert die Person den gewünschten Tag von Freitag auf Donnerstag, soll das Backend die Anfrage für Donnerstag bearbeiten. Ob der Freitag bereits gebucht wurde, steht im Buchungsdatensatz. Deine bestehenden Bestätigungs- und Berechtigungsregeln legen fest, welche Änderungen das Backend als Nächstes vornehmen darf.

Kläre offene Produktentscheidungen mit den Verantwortlichen, bevor du die Prompts einsetzt. Gibt eine Anweisung vor, eine Buchung fortzusetzen, während eine andere bei einer Unterbrechung durch die anrufende Person alle Aufgaben stoppen lässt, legt gemeinsam das gewünschte Verhalten fest. Halte die Entscheidung in den Prompts und in der Anwendungslogik fest, die sie durchsetzt.

Prüfe, ob jede erforderliche Aktion implementiert ist. Damit der Assistent auflegen kann, muss die Anwendung den Anruf beenden können. Eine gesprochene Verabschiedung allein lässt die Verbindung offen. Fehlt eine Funktion, entscheide, ob du sie implementierst, oder vereinbare mit dem für den Ablauf zuständigen Team eine unterstützte Alternative.

Beide Prompts überprüfen

Vergleiche beide Prompts mit dem ursprünglichen Prompt und prüfe, ob sie alle Verhaltensvorgaben abdecken:

  • Der Live-Prompt behält Identität, Wortwahl, Sprechstil, vorgeschriebene Hinweise und das Verhalten des Assistenten bei Unterbrechungen bei.
  • Der Backend-Prompt enthält weiterhin die Abläufe, Fakten, Bedingungen, Beispiele, Berechtigungen und Regeln zur Fehlerbehandlung für die Aufgaben.
  • Die Delegationsregeln decken neue Anfragen, Korrekturen, Bestätigungen und Anliegen ab, die Gesprächsbeiträge mit aufgabenbezogenen Angaben verbinden.
  • Beide Prompts stimmen darin überein, wie viele Fragen zulässig sind, wann eine Aktion als bestätigt gilt und wie laufende Aufgaben, Abbrüche, Gesprächsübergaben und das Gesprächsende zu behandeln sind.

Hinterlege den Live-Prompt in session.instructions. Bei der Responses-Delegation gehört der Backend-Prompt in session.delegation.responses.instructions. Bei der Client-Delegation bleibt er in der Konfiguration deines vorhandenen Agenten. Belasse die Tool-Definitionen beim Backend. Hinweise zur Konfiguration und zur Verarbeitung von Ergebnissen findest du unter Delegation und Tools.

Beispiel: Den Prompt eines Terminassistenten aufteilen

Dieser Terminassistent verfügt bereits über die Tools check_availability und book_appointment. Sein ursprünglicher Prompt kombiniert den Sprechstil mit dem Buchungsablauf. Auch nach der Aufteilung bleiben die Begrüßung, die erforderlichen Bestätigungen und der Umgang mit Korrekturen gleich.

Ursprünglicher Prompt

You are Rowan, the appointment assistant for Northstar Repairs.
Speak English, calmly and briefly. Greet the caller once with:
"Hello, this is Rowan from Northstar Repairs. How can I help?"
Use brief listening acknowledgments. Stop speaking when interrupted.

Help callers find and book appointments. Ask for the preferred date
and time zone if missing, then use check_availability.
Offer only returned slots. Ask the caller to confirm the exact slot
before calling book_appointment.
If the caller changes the date, time zone, or slot, discard the earlier
confirmation and check availability again.
Report a booking only after the tool confirms success. If the outcome
is unclear, say it is unconfirmed and do not retry automatically.

Live-Prompt

You are Rowan, the appointment assistant for Northstar Repairs.
Speak English, calmly and briefly. Greet the caller once with:
"Hello, this is Rowan from Northstar Repairs. How can I help?"

Backchannel policy: Use brief listening acknowledgments.

Interruption policy: Stop speaking when interrupted and listen.

Delegation policy:
Backend tools:
- Appointments: check available times and book appointments.

Delegate to the backend when:
- The caller wants to find or book an appointment.
- The caller supplies or corrects a date, time zone, or slot, or
  answers a booking question, including confirming a slot.

Do not delegate to the backend when:
- The caller greets you or asks you to repeat a still-current result.
- You need a brief clarification to understand what they are asking.

Relay the backend's questions and results. Offer only slots it returns.
Do not claim a booking is complete until the backend confirms success.
If the backend reports an unclear outcome, say it is unconfirmed.

Backend-Prompt

Help callers find and book appointments for Northstar Repairs.
Ask for the preferred date and time zone if missing, then use
check_availability. Offer only returned slots.
Ask the caller to confirm the exact slot before calling book_appointment.
If the caller changes the date, time zone, or slot, discard the earlier
confirmation and check availability again.
Report a booking only after the tool confirms success. If the outcome
is unclear, report it as unconfirmed and do not retry automatically.

Return the available slots, booking outcome, or next question for the
voice assistant to communicate. Interpret the caller's latest answers
and corrections using the conversation and current task state.

Funktionshandler anpassen

Behalte die Implementierung von check_availability und book_appointment bei. Verschiebe die Definitionen aus session.tools oder response.tools von Realtime nach delegation.responses.tools und verwende das Funktionsschema von Responses. Verschiebe die Einstellungen zur Tool-Auswahl nach delegation.responses.tool_choice und delegation.responses.parallel_tool_calls. Siehe Responses-Delegation konfigurieren.

Die Funktion gibt ihr Ergebnis weiterhin für die ursprüngliche call_id zurück. Es ändert sich, wo dein Handler den Aufruf empfängt und wohin er das Ergebnis sendet:

Schritt Realtime API GPT-Live mit Responses-Delegation
Vollständig übermittelten Funktionsaufruf empfangen. Lies response.output_item.done. Entpacke response.event und lies das darin enthaltene Ereignis response.output_item.done.
Vorgang identifizieren und ausführen. Lies name, arguments und call_id aus dem Element und führe den autorisierten Handler aus. Behalte den Handler und seine Prüfungen bei. Speichere die äußere delegation_id und die ID der Backend-Antwort in deiner Anwendung.
Jedes Funktionsergebnis zurückgeben. Sende conversation.item.create. Sende response.item.create.
Nach Übermittlung aller erforderlichen Ergebnisse fortfahren. Sende response.create. Sende response.create, damit das Backend weiterarbeitet.

Wenn check_availability beispielsweise einen verifizierten Termin zurückgibt, sende in deiner verbundenen Sitzung das folgende Ereignis. Ersetze call_availability durch die ID des empfangenen Aufrufs.

Vorher: Ergebnis für Realtime

{
  "type": "conversation.item.create",
  "item": {
    "type": "function_call_output",
    "call_id": "call_availability",
    "output": "{\"available\":true,\"slot_id\":\"slot_friday_14\",\"booked\":false}"
  }
}

Nachher: Ergebnis für GPT-Live

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

export function sendUpdate(connection: { send: (event: ClientEvent) => void }) {
  connection.send({
    type: "response.item.create",
    event_id: "availability_result_1",
    item: {
      type: "function_call_output",
      call_id: "call_availability",
      output: '{"available":true,"slot_id":"slot_friday_14","booked":false}',
    },
  });
}

Sobald du alle erforderlichen Funktionsergebnisse übermittelt hast, setze die Verarbeitung im Backend fort:

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

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

Setze parallel_tool_calls für die erste Migrationsphase auf false, damit du jeweils nur einen Tool-Aufruf verarbeitest. Erfasse jeden Funktionsaufruf aus dem inneren Ereignis response.output_item.done und speichere seinen Namen, seine Argumente und seine call_id. Behalte diesen Datensatz auch dann, wenn ein späteres Abschlussereignis output: [] enthält. Warte auf das vollständige Element, bevor du den Handler ausführst. Das Ereignis zum Abschluss der Argumentübermittlung enthält weder den Funktionsnamen noch die call_id. Wie du Aufrufe erfasst, Ausgaben übermittelst und Fehler behandelst, erfährst du im vollständigen Ablauf für Funktionsergebnisse.

Kontext erhalten und Korrekturen übernehmen

Bei der Responses-Delegation erhält das Backend den relevanten Kontext aus dem Gespräch. Speichere den maßgeblichen Buchungsstand in deiner Anwendung: ausgewählter Termin, bestätigter Termin, Berechtigungen, laufender Vorgang und Ergebnis. Der Live-Gesprächsverlauf kann verdichtet werden und ersetzt keinen Buchungsdatensatz.

Sagt die anrufende Person „Doch lieber Freitag“, speichere Freitag als aktuellen Wunsch und verwerfe jede Bestätigung für Donnerstag. Gib der Aufgabe eine neue Versionsnummer, etwa Revision 2. So kann deine Anwendung Ergebnisse erkennen, die noch zur früheren Anfrage gehören.

Prüfe vor der Buchung, ob Datum, Termin und Bestätigung noch zur aktuellen Anfrage passen. Lehnst du einen ausstehenden Funktionsaufruf ab, weil sich die Anfrage geändert hat, gib im Ergebnis an, ob du ihn tatsächlich übersprungen oder abgebrochen hast. Übermittle für jeden erforderlichen Aufruf ein Ergebnis, bevor du das Backend weiterarbeiten lässt.

War die Buchung für Donnerstag bereits erfolgreich, prüfe ihren aktuellen Status und bearbeite den Änderungswunsch, bevor du eine weitere Buchung versuchst.

Speichere jedes Transkriptfragment genau so, wie es ankommt, zusammen mit der Angabe, wer gesprochen hat, sowie start_ms und end_ms. Aktualisiere anhand dieser Angaben den passenden Untertitel oder die passende Chatblase der anrufenden Person oder des Assistenten. Das gilt auch, wenn ein Fragment verspätet eintrifft oder beide gleichzeitig sprechen. Lege in deiner Anwendung fest, wo eine Nachricht endet, und verfolge die Audiowiedergabe im Player. Aus den Zeitstempeln des Transkripts geht nicht exakt hervor, wann einzelne Wörter abgespielt werden. Frage bei wichtigen Datumsangaben, Namen und Zahlen nach, wenn unklar ist, was gemeint ist. Hinweise zum Umgang mit Transkripten und Kontext findest du unter Sitzungen verwalten.

Bilder und Bildschirminhalte: Wenn deine Realtime-Anwendung Bilder entgegennimmt, leite sie an ein Backend weiter, das Bilder verarbeiten kann, und gib relevante Informationen als Text an GPT-Live zurück. Das funktioniert sowohl mit Client- als auch mit Responses-Delegation. Siehe Bilder und visuellen Kontext hinzufügen.

Entscheidungen anhand des Audiosignals beibehalten

Für manche Entscheidungen ist der Originalton nötig, etwa um den Signalton einer Mailbox zu erkennen oder eine aufgezeichnete Ansage an ihrem zeitlichen Verlauf zu identifizieren. GPT-Live hört den Anruf, doch bei der Delegation wird das Audio nicht automatisch an dein Backend gesendet. Im Client-Modus enthält session.delegation.created eine ID und Zeitangaben. Deine Anwendung liefert den Kontext der Anfrage und alle Audiodaten, die das Backend benötigt.

Leite eingehende Audiodaten zur Anrufbeantwortererkennung ausdrücklich an einen Detektor weiter, der Audio auswerten kann. Du kannst beispielsweise eine Architektur testen, bei der deine Anwendung für einen Teil des Anrufs parallel zu GPT-Live eine separate Realtime-Sitzung betreibt:

  1. Sende eine Kopie der eingehenden Audiodaten des Anrufs an beide Sitzungen.
  2. Lass den Detektor seine Einstufung über einen strukturierten Funktionsaufruf melden. Prüfe jedes Ergebnis anhand deines Schemas, verwerfe veraltete Ergebnisse und behalte bei unzureichenden Anhaltspunkten den Status „unbekannt“ bei. Lass zu, dass sich die Einstufung aufgrund späterer Anhaltspunkte ändert.
  3. Sende relevanten, vertrauenswürdigen Kontext an GPT-Live und wende die Regeln deiner Anwendung auf die Wiedergabe ausgehender Audiodaten an.

Verfolge zwei Entscheidungen getrennt: Sprichst du mit einem Menschen oder einem Anrufbeantworter? Ist die Gegenseite bereit, deine Nachricht aufzuzeichnen? Der Detektor kann eine Mailbox erkennen, während die Ansage noch läuft. Gib ausgehendes Audio erst frei, wenn die von deiner Anwendung verlangten Anhaltspunkte vorliegen. Eine Empfangsbestätigung für das Kontextupdate zeigt, dass es angenommen wurde. Über die Wiedergabe entscheidet weiterhin deine Anwendung. Nutze Schutzmaßnahmen anpassen und die Wiedergabesteuerung, um diese Entscheidung in dem von deiner Anwendung gesteuerten Audiopfad durchzusetzen.

Teste ein kurzes „Hallo“, das sich als Beginn einer Mailboxansage erweist, Ansagen zur Anrufprüfung und den Fall, dass während eines Mailboxanrufs jemand abhebt. Möchtest du den Detektor vor Gesprächsende stoppen, teste, was passiert, wenn danach jemand abhebt. Entscheide anhand der Ergebnisse und der zusätzlichen Kosten, wie lange der Detektor laufen soll. Berücksichtige Fälle, in denen sich die erste Einstufung als „Mensch“ ändert, sobald weitere Audiodaten eintreffen.

Von einem Textagenten oder einer mehrstufigen Pipeline migrieren

Vorher: Ein Textagent empfängt schriftliche Anfragen und nutzt seine Tools und seinen gespeicherten Zustand. Eine mehrstufige oder kaskadierte Sprachpipeline wandelt gesprochene Eingaben vor der Verarbeitung durch den Agenten in Text um und gibt seine Antworten anschließend per Sprachsynthese aus.

Nachher: GPT-Live stellt die Sprachschnittstelle bereit und delegiert Aufgaben an deinen vorhandenen Agenten. In einer mehrstufigen Pipeline ersetzt es die getrennten Stufen für Spracherkennung und Sprachsynthese. Behalte Modelle, Anweisungen, Tools, Abläufe und dauerhaft gespeicherte Zustandsdaten im Backend bei, soweit sie weiterhin zur Aufgabe passen.

Vorhandenen Agenten anbinden

Setze delegation auf {"type":"client"}, wenn du die Sitzung einrichtest. Deine Anwendung erhält eine Benachrichtigung wie diese:

{
  "type": "session.delegation.created",
  "offset_ms": 1000,
  "delegation": {
    "id": "item_appointment_1",
    "type": "delegation",
    "target": "client"
  }
}

Starte mit dieser Benachrichtigung den Delegationshandler deiner Anwendung. Speichere delegation.id, damit du das Ergebnis derselben Anfrage zuordnen kannst. Dein Handler bereitet die Eingabe für den Agenten aus den Transkripten beider Gesprächsseiten und den in der Anwendung gespeicherten Aufgabendaten vor. Die Benachrichtigung selbst enthält weder den Text der Anfrage noch Tool-Argumente.

Der Terminagent könnte beispielsweise Folgendes erhalten:

Anrufende Person: „Doch lieber Freitag.“

Aktuelle Anfrage: Einen Termin am Freitag in der Zeitzone der anrufenden Person finden.

Vorheriges Ergebnis: Donnerstag um 14 Uhr wurde angeboten.

Bestätigung: Für Freitag wurde noch kein Termin bestätigt.

Aufgabenrevision: 2.

Die Benachrichtigung kann eintreffen, bevor der ganze Satz transkribiert ist. Bewahre sie auf, bis genügend Kontext vorliegt, oder frage nach, bevor du eine Aktion ausführst.

In einer Textanwendung kannst du die neueste Nachricht der Person gegebenenfalls direkt an deinen Agenten weitergeben. Ergänze bei GPT-Live einen Adapter, der den nötigen Kontext liefert und ein knappes, geprüftes Ergebnis zurückgibt.

Speichere die Delegations-ID, bevor du den Adapter aufrufst, damit nur ein Handler die Bearbeitung dieser Delegation startet. Ist die Anfrage noch unklar, rufe den Adapter erneut auf, sobald der nötige Kontext vorliegt.

Dein Backend bleibt für Berechtigungen, Bestätigungen, Vorgangs-IDs und Wiederholungsversuche zuständig. Prüfe die aktuelle Revision der Aufgabe, bevor du eine Buchung änderst. Die spätere Revisionsprüfung im Adapter verhindert lediglich, dass der Assistent ein veraltetes Ergebnis mitteilt. Eine bereits erfolgte Buchung kann sie nicht rückgängig machen.

Client-Delegation mit deinem Agenten verbinden
import type {
  ServerEvent,
  CommentaryAppendEvent,
  DelegationCreatedEvent,
} from "openai/resources/live/live";

type AgentContext = {
  revision: number;
  recentConversation: string;
  task: string;
};
type DelegationApp = {
  readContext(): AgentContext | null;
  runAgent(context: AgentContext): Promise<string>;
  currentRevision(): number;
  send(event: CommentaryAppendEvent): void;
};

async function handleDelegation(event: ServerEvent, app: DelegationApp) {
  if (
    event.type !== "session.delegation.created" ||
    event.delegation?.target !== "client"
  )
    return;

  const context = app.readContext();
  if (!context) return; // Retain the notice; resolve the request before acting.

  const summary = await app.runAgent({
    revision: context.revision,
    recentConversation: context.recentConversation,
    task: context.task,
  });

  if (app.currentRevision() !== context.revision) return;

  app.send({
    type: "session.commentary.append",
    event_id: crypto.randomUUID(),
    delegation_id: event.delegation.id,
    content: summary,
  });
}

Implementiere die Callbacks für den Kontext und den Agenten in deiner Anwendung. Der Kontext-Callback gibt die jüngsten Gesprächsbeiträge und die aktuelle Aufgabe zurück. Solange die Anfrage unklar ist, gibt er keinen Wert zurück. Der Agenten-Callback führt dein vorhandenes Backend aus und gibt eine geprüfte Zusammenfassung mit höchstens 500 Token zurück. In JavaScript sendet der von der Anwendung bereitgestellte Callback send das JSON-Ereignis über deine Live-Verbindung. In Python sendet der Adapter das Update direkt über das SDK-Verbindungsobjekt connection.

Beim Terminassistenten sollte aus dem Kontext hervorgehen, welches Datum und welche Zeitzone gewünscht sind, welche Termine bereits angeboten wurden, welcher Termin gegebenenfalls bestätigt wurde und was zuletzt korrigiert wurde. Das Ergebnis einer Verfügbarkeitsprüfung sollte angeben, dass ein Termin frei ist und noch keine Buchung erfolgt ist. Gib eine Buchungsbestätigung erst nach erfolgreicher Buchung zurück. Das vollständige Setup und den Ablauf der Ergebnisübermittlung findest du unter Client-Delegation.

Updates und Korrekturen weiterleiten

Belasse strukturierte Tool-Ausgaben und Details zum Ablauf im Backend. Sende kurze, sachliche Updates an GPT-Live:

  • Nutze session.thinking.append für Fortschrittsmeldungen zu Hintergrundaufgaben, etwa zu einer noch laufenden Abfrage.
  • Nutze session.commentary.append für ein geprüftes Ergebnis, das die anrufende Person hören soll.
  • Nutze session.instructions.append für Verhaltensanweisungen, die deine Anwendung vorgibt.

Alle drei erwarten für content eine einfache Zeichenkette mit höchstens 500 Token und erfordern delegation_id. Verwende für zugehörige Aufgaben die ursprüngliche ID der Client-Delegation oder null für allgemeinen Sitzungskontext. Ordne jede Empfangsbestätigung anhand von client_event_id dem gesendeten Befehl zu. Die Bestätigung zeigt, dass das Update angenommen wurde. Verfolge die generierte Sprachausgabe anhand der Transkriptereignisse des Assistenten und die Wiedergabe anhand des Playerzustands. Siehe Das passende Update senden.

Sagt die anrufende Person „Doch lieber Freitag“, speichere Freitag als aktuellen Wunsch, erhöhe die Versionsnummer der Anfrage und verwerfe jede Bestätigung für Donnerstag. Sende die Korrektur an deinen vorhandenen Agenten. Entscheide, ob du den Abbruch der Abfrage für Donnerstag anforderst, die Abfrage änderst oder sie zu Ende laufen lässt und ihr Ergebnis verwirfst.

Verfolge den Status der Abfrage, bevor du sie als abgebrochen meldest. Setze die Entscheidung im Backend auch dann um, wenn die Unterbrechung durch die anrufende Person die Sprachausgabe des Assistenten bereits gestoppt hat.

Backend-Aufgaben können über das Ende der Sprachsitzung hinaus weiterlaufen. Speichere ihren Status dauerhaft in deiner Anwendung. Starte für ein späteres Gespräch eine neue Sitzung mit dem relevanten gespeicherten Kontext. Siehe Sitzungen verwalten.

Texteingaben weiterhin an den Agenten leiten

Leite Texteingaben weiterhin an dein vorhandenes Backend. Behandle eine eingetippte Korrektur als Aktualisierung derselben Aufgabe und sende den relevanten, geprüften Kontext an die Sprachsitzung. Siehe Texteingaben annehmen und Updates korrekt und hilfreich formulieren.

Schutzmaßnahmen für Text und Sprache anpassen

Ein Textagent oder eine mehrstufige Pipeline kann eine vollständige Antwort prüfen, bevor sie angezeigt oder vorgelesen wird. Bei GPT-Live laufen Gespräch und Backend-Aufgaben gleichzeitig. Muss jede gesprochene Antwort geprüft werden, bevor die anrufende Person sie hört, integriere die Prüfung in den Wiedergabepfad, den deine Anwendung steuert. Allein das Zurückhalten eines Backend-Ergebnisses unterbricht nicht die gesamte Sprachausgabe.

Wie du deine Prüfungen beibehältst und dabei die kontinuierliche Sprachausgabe berücksichtigst, erfährst du unter Schutzmaßnahmen anpassen.

Schutzmaßnahmen anpassen

Behalte bei der Migration aus beiden Architekturen die Schutzmaßnahmen deiner bisherigen Anwendung für Ein- und Ausgaben bei. GPT-Live kann weitersprechen, während das Backend Aufgaben bearbeitet und die Einhaltung von Richtlinien geprüft wird. Prüfe daher sowohl das Gespräch als auch die Aktionen des Backends.

Muss dein Server eine WebRTC-Sitzung im Browser überwachen oder steuern, binde einen Sideband-WebSocket an. Darüber kann der Server Transkripte empfangen und korrigierende Anweisungen senden. Audio wird weiterhin über WebRTC übertragen. Streamt dein Server Audio bereits über den primären WebSocket, nutze dessen Ereignisstream für diese Prüfungen. Allein die Wahl der Responses-Delegation erfordert keine Sideband-Verbindung.

  1. Verfolge die Transkriptereignisse der anrufenden Person und des Assistenten und führe deine Prüfungen parallel zum Gespräch aus.
  2. Sperre betroffene Tools und externe Aktionen im Anwendungscode. Brich zugehörige Aufgaben unter der Kontrolle deiner Anwendung ab, sofern sie einen Abbruch unterstützen. Verhindere, dass verspätete Ergebnisse die Bearbeitung einer gesperrten Anfrage fortsetzen.
  3. Sende session.instructions.append, um das Verhalten des Assistenten zu korrigieren, und halte die Entscheidung in deiner Anwendung fest.

Bittet jemand den Terminassistenten ohne Berechtigung, die Buchung einer anderen Person zu ändern, sperre den Buchungsvorgang, bevor er ausgeführt wird. Weise den Assistenten anschließend an, zu erklären, dass er die Änderung nicht vornehmen kann. Prüfe sowohl, ob der Buchungsdatensatz unverändert ist, als auch, was der Assistent gesagt hat. Die gesprochene Ablehnung allein setzt die Berechtigungsregel nicht durch.

Eine korrigierende Anweisung kann bereits gehörte Aussagen nicht zurücknehmen. Muss deine Anwendung die Sprachausgabe des Assistenten vor der Wiedergabe prüfen, findest du unter Sprachausgabe vor der Wiedergabe prüfen Hinweise zu Pufferung, Freigabe, Unterbrechung und Wiederaufnahme. Wie du Aktionen steuerst und eine korrigierende Anweisung formulierst, zeigt Schutzmaßnahmen im Gespräch anwenden. Ist für den Gesprächsbeginn ein bestimmter Wortlaut vorgeschrieben, siehe Einen vorgeschriebenen Hinweis aussprechen.

Migration überprüfen

Vergleiche den migrierten Assistenten anhand typischer Gespräche mit deiner bisherigen Anwendung. Verwende dieselben Szenarien, Backend-Tools und Erfolgskriterien. Wiederhole jedes Szenario und dokumentiere neben Regressionen auch beabsichtigte Verhaltensänderungen:

  • Aktionen und gesprochene Bestätigungen: Prüfe die Verfügbarkeit, bitte um Bestätigung und buche nur den bestätigten Termin. Überprüfe das Backend-Ergebnis, die gesprochene Antwort und die Wiedergabe im Client getrennt.
  • Korrekturen und Schutz vor Doppelbuchungen: Ändere den gewünschten Tag von Donnerstag auf Freitag, während die Anfrage noch läuft. Verwirf veraltete Ergebnisse und stelle sicher, dass Wiederholungsversuche keine zweite Buchung auslösen können.
  • Berechtigungen: Versuche, eine unzulässige Aktion auszuführen und eine Buchung ohne Bestätigung vorzunehmen. Prüfe, ob die Regeln der Anwendung die Ausführung verhindern.
  • Eingreifen der Schutzmaßnahmen: Löse Prüfungen während der Sprachausgabe und der Tool-Ausführung aus. Prüfe, ob der Assistent die Korrektur erhält, betroffene Aktionen auch bei verspäteten Tool-Ergebnissen gesperrt bleiben und die Wiedergabe wie vorgesehen fortgesetzt wird. Prüfe, ob ein laufender Vorgang tatsächlich gestoppt wurde. Berücksichtige langsame Prüfungen und Fehlalarme.
  • Unterbrechungen: Sprich, während der Assistent spricht oder eine Aufgabe bearbeitet. Prüfe das Gespräch, die Audiowiedergabe und den Zustand der Backend-Aufgabe unabhängig voneinander.
  • Fehler und erneuter Verbindungsaufbau: Teste Tool-Fehler, verlorene Ergebnisse und Verbindungsabbrüche. Geht die Antwort auf eine Buchungsanfrage verloren, prüfe vor einem erneuten Versuch, ob die Buchung erfolgreich war. Starte die nächste Sprachsitzung mit dem gespeicherten Aufgabenkontext und prüfe, ob sie an das festgestellte Ergebnis anknüpft.

Nutze Backend-Latenz reduzieren, um das migrierte Backend zu optimieren. Vergleiche anhand des Cookbooks zur Evaluation von Sprachagenten, wie lange es bis zu einer hilfreichen gesprochenen Antwort dauert und wie erfolgreich der Assistent Aufgaben erledigt. Nutze Kostenoptimierung, um Nutzung und Kosten zu vergleichen.