Zu GPT-Live migrieren

Von der Realtime API

Beginne mit der Anleitung zum Formulieren von Prompts für GPT-Live. Teile deinen bestehenden Prompt zwischen dem Modell für Sprachinteraktionen und dem Backend auf, statt ihn vollständig in session.instructions zu kopieren. Behalte Gesprächsstil und Delegationshinweise im Prompt für die Sprachinteraktion bei. Verschiebe detaillierte Arbeitsabläufe und Anweisungen zur Werkzeugnutzung ins Backend.

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

Nachher: GPT-Live übernimmt die Sprachinteraktion und delegiert die Aufgabenbearbeitung. Das Backend wählt dieselben Funktionen aus; deine Anwendung prüft sie weiterhin und führt sie aus. Die hier beschriebenen Schritte verwenden Responses-Delegation. Wenn du einen externen Agenten beibehältst, verwende stattdessen den Client-Adapter.

So funktioniert Responses-Delegation

Konfiguriere das Backend-Modell, die Anweisungen und die Werkzeuge in delegation.responses. Wenn GPT-Live entscheidet, dass eine Anfrage im Backend bearbeitet werden muss, ruft der Live-Dienst dieses Responses-Modell auf und stellt relevanten Gesprächskontext bereit. Das Backend durchdenkt die Aufgabe und wählt Werkzeuge aus. Deine Anwendung führt weiterhin benutzerdefinierte Funktionen aus, setzt Berechtigungen durch und gibt die Ergebnisse zurück.

Beim Terminassistenten läuft das so ab:

1. Die nutzende Person fragt, welche Termine am Freitag verfügbar sind, und GPT-Live delegiert die Anfrage.
2. Das Responses-Backend fordert check_availability an.
3. Deine Anwendung führt die Funktion aus, gibt ihr Ergebnis zurück und setzt die Backend-Antwort fort.
4. GPT-Live nutzt die Antwort des Backends, um verfügbare Zeitfenster mit der nutzenden Person zu besprechen.

GPT-Live kann das Gespräch fortsetzen, während das Backend arbeitet. Der Abschluss dieser Arbeit bedeutet nicht, dass der Assistent fertig gesprochen hat. Informationen zur Konfiguration und zum vollständigen Ereignisablauf findest du unter Delegation und Werkzeuge.

Entscheidungen auf Basis von Audio beibehalten

Prüfe, ob bestehende Entscheidungen zur Werkzeugnutzung von akustischen Hinweisen abhängen, etwa vom Signalton einer Mailbox oder vom Sprechrhythmus einer aufgezeichneten Begrüßung. GPT-Live hört die eingehenden Audiodaten, aber sein Sprachfrontend delegiert Aufgaben, statt gewöhnliche strukturierte Funktionsaufrufe auszugeben. Im Client-Modus übermittelt session.delegation.created Metadaten und Zeitangaben, jedoch keine Audio-Rohdaten, keinen Aufgabentext und keine geparsten Werkzeugargumente. Ein Backend, an das Aufgaben delegiert werden, erhält die Wellenform nicht automatisch.

Leite eingehende Audiodaten zur Erkennung von Anrufbeantwortern ausdrücklich an einen Detektor weiter, der Audio verarbeiten kann. Eine mögliche, von der Anwendung verwaltete Architektur zum Testen betreibt während eines Teils des Anrufs eine separate Realtime-Sitzung parallel zu GPT-Live:

1. Sende eine Kopie der eingehenden Anrufaudiodaten an beide Sitzungen.
2. Lass den Detektor seine Klassifizierung über einen strukturierten Funktionsaufruf melden. Prüfe jedes Ergebnis anhand deines Schemas, verwerfe veraltete Ergebnisse und behalte bei unzureichenden Hinweisen den Zustand „unbekannt“ bei. Ermögliche es, die Entscheidung anhand späterer Hinweise zu revidieren.
3. Sende relevanten, vertrauenswürdigen Kontext an GPT-Live und wende die Richtlinie deiner Anwendung auf die Wiedergabe ausgehender Audiodaten an.

Trenne die Klassifizierung als Mensch oder Maschine von der Aufnahmebereitschaft. Eine erkannte Mailbox bedeutet nicht, dass Begrüßung und Signalton beendet sind oder die Aufnahme beginnen kann. Auch ein Klassifizierungsergebnis oder eine Kontextbestätigung erteilt keine Berechtigung zur Audiowiedergabe. Nutze Schutzmechanismen anpassen und die Wiedergabesteuerung, um diese Entscheidung in dem Audiopfad durchzusetzen, den deine Anwendung kontrolliert.

Teste ein kurzes „Hallo“, das in eine Mailboxansage übergeht, Aufforderungen zur Anrufprüfung und den Fall, dass eine Person während der Mailboxansage abnimmt. Wenn du den Detektor vor Ende des Anrufs stoppst, teste auch, was passiert, wenn danach noch eine Person abnimmt. Entscheide anhand dieser Tests und der zusätzlichen Kosten, wann du den Detektor stoppst. Die erste Klassifizierung als Mensch allein belegt nicht, dass eine weitere Erkennung unnötig ist.

Verbindungs- und Audiolebenszyklus anpassen

Ersetze das Realtime-Sitzungs-Setup durch das Verbindungsverfahren für GPT-Live. Prüfe den Verbindungsaufbau und das Audioformat deines Transportprotokolls erneut. 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 den Anruf zu überwachen oder Schutzmechanismen durchzusetzen, passe sie an die GPT-Live-Sideband-Verbindung an. Folge Schutzmechanismen anpassen, um Gesprächsprüfungen und Wiedergabe entsprechend zu ändern.

Generierung und Wiedergabe: In Realtime markiert response.output_audio.done das Ende der Audiogenerierung, während response.done das Ende des Antwortstreams markiert. Diese Ereignisse können auch auftreten, wenn eine Antwort unterbrochen wird oder nicht erfolgreich ist. Prüfe response.status in response.done. Keines der beiden Ereignisse bestätigt, dass gepufferte Audiodaten vollständig wiedergegeben wurden. Beispielsweise kann der Server die Generierung bereits abgeschlossen haben, während der Client noch eine Sekunde Audio wiedergeben muss. Steuere eine Anzeige wie „Spricht“ anhand des Wiedergabestatus.

Untertitel: Die Eingabetranskription gibt die Äußerungen der nutzenden Person wieder; die Ausgabetranskription gibt die generierte Sprache des Assistenten wieder. Wenn die Eingabetranskription aktiviert ist, sendet Realtime Aktualisierungen über conversation.item.input_audio_transcription.delta und ein abschließendes Transkript über conversation.item.input_audio_transcription.completed. Ein delta ist ein neues Textfragment. Hänge in GPT-Live jedes Fragment unabhängig an die Untertitel der jeweiligen sprechenden Person oder des Assistenten an, da Zuhören und Sprechen sich überschneiden können. Ein Fragment ist weder ein vollständiger Gesprächsbeitrag noch eine Bestätigung der Wiedergabe. Eine Anleitung zur Anzeige findest du unter Untertitel anzeigen.

In GPT-Live startet response.create delegierte Responses-Aufgaben oder setzt sie fort. Es erteilt dem Audiomodell keine Erlaubnis zu sprechen. Hinweise zum Starten, Begrüßen, Unterbrechen und Beenden einer Sitzung findest du unter Sitzungen verwalten.

Anweisungen für Gespräch und Backend trennen

Verschiebe Vorgaben zum Gesprächsstil und zur Delegation nach session.instructions. Verschiebe Geschäftsregeln und Anweisungen zur Werkzeugnutzung nach delegation.responses.instructions. Bei einem selbst betriebenen Backend bleiben diese Regeln im bestehenden Prompt.

Vorher: ein einzelner Realtime-Prompt

Help callers book appointments. Speak briefly. Check availability with the tool,
ask the caller to confirm a slot, then book it. Never claim an unverified booking.

Nachher: Gesprächsanweisungen für GPT-Live

Help callers book appointments. Keep spoken replies brief. Delegate availability
checks and booking requests. Ask the caller to confirm the proposed slot.
Only announce a booking when the backend reports that it succeeded.

Nachher: Backend-Anweisungen

Use the appointment tools to check current availability. Before booking, verify
that the caller confirmed the exact slot and still has permission to book it.
Apply the latest correction. Return verified availability, booking, or failure
status with the date, time, and time zone.

Erzwinge in deiner Anwendung die Prüfung von Bestätigungen und Berechtigungen, bevor ein Werkzeug ausgeführt wird. Prompt-Anweisungen leiten die Modelle an, erzwingen diese Prüfungen aber nicht. Hinweise zur Prompt-Gestaltung findest du unter Prompts für Audiomodelle formulieren.

Funktions-Handler anpassen

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

Die Funktion gibt weiterhin ein Ergebnis für ihre ursprüngliche call_id zurück. Geändert wird, wo dein Handler den Aufruf empfängt und das Ergebnis sendet:

Wenn beispielsweise check_availability einen verifizierten freien Termin zurückgibt, ändert sich dein Ergebnis wie folgt. Diese Nachrichten werden über eine bereits verbundene Sitzung gesendet; call_availability steht für die tatsächliche Aufruf-ID, die du erhalten hast.

Vorher: Realtime-Ergebnis

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

Nachher: GPT-Live-Ergebnis

1
2
3
4
5
6
7
8
9
10
11export function sendUpdate(connection) {
  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}',
    },
  });
}

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


async def send_update(
    connection: AsyncLiveConnection | AsyncSidebandConnection,
) -> None:
    item: ResponseInputItemParam = {
        "type": "function_call_output",
        "call_id": "call_availability",
        "output": '{"available":true,"slot_id":"slot_friday_14","booked":false}',
    }
    await connection.response.item.create(
        event_id="availability_result_1",
        item=item,
    )

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

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

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


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

Für die erste Migration vereinfacht es die Ergebnisverarbeitung, parallel_tool_calls auf false zu setzen. Sammle Aufrufe aus Ereignissen, die abgeschlossene Ausgabeelemente melden, auch wenn ein abschließender Snapshot des Lebenszyklus output: [] enthält. Ein Ereignis, das den Abschluss der Argumente meldet, liefert allein weder den Funktionsnamen noch die call_id. Befolge das vollständige Verfahren für Funktionsergebnisse, um Aufrufe zu sammeln, Ausgaben zu übermitteln und Fehler zu behandeln.

Kontext bewahren und Korrekturen übernehmen

Die Responses-Delegation stellt dem Backend relevanten Kontext aus dem Sprachgespräch bereit. Halte den maßgeblichen Stand der Terminbuchung in deiner Anwendung fest: ausgewählter Termin, bestätigter Termin, Berechtigungen, aktive Operation und Ergebnis. Der Gesprächsverlauf in Live kann verdichtet werden; er ist kein Buchungsprotokoll.

Wenn die nutzende Person „Doch lieber Freitag“ sagt, während eine Abfrage für Donnerstag noch läuft, aktualisiere die Revision der Aufgabe und mache die bisherige Terminbestätigung ungültig. Prüfe vor einer Buchung, ob ihre Argumente noch zur aktuellen Aufgabe und Bestätigung passen. Gib für jeden ausstehenden Funktionsaufruf, den deine Anwendung ablehnt, ein zutreffendes Ergebnis zurück, das ihn als überholt oder abgebrochen kennzeichnet. Vervollständige dann den erforderlichen Ausgabestapel, bevor du fortfährst. Falls eine Buchung bereits erfolgreich war, gleiche dieses Ergebnis mit der gewünschten Änderung ab, bevor du eine weitere Aktion ausführst.

Transkriptfragmente können verspätet eintreffen oder sich mit der Sprachausgabe des Assistenten überschneiden. Hänge jedes delta exakt so an, wie du es empfangen hast, und verwende start_ms und end_ms, um die Anzeige zu gruppieren. Diese Zeitstempel markieren weder verbindliche Grenzen von Gesprächsbeiträgen noch Wiedergabezeitpunkte einzelner Wörter. Kläre wichtige Datumsangaben, Namen und Zahlen, wenn die Absicht unklar ist. Hinweise zum Umgang mit Transkripten und Kontext findest du unter Sitzungen verwalten.

Bilder und Bildschirmkontext: Wenn deine Realtime-Anwendung Bilder entgegennimmt, leite sie an ein Backend mit Bildverarbeitung weiter und gib relevanten Text an GPT-Live zurück. Sowohl die Client- als auch die Responses-Delegation unterstützen dieses Muster. Siehe Bilder und visuellen Kontext hinzufügen.

Von einem Textagenten oder einer verketteten Pipeline migrieren

Vorher: Ein Textagent erhält schriftliche Anfragen und nutzt seine Werkzeuge und seinen gespeicherten Zustand. Eine verkettete oder kaskadierte Sprachpipeline schaltet dem Agenten eine Spracherkennung vor und eine Sprachsynthese nach.

Nachher: GPT-Live stellt die Sprachschnittstelle bereit und delegiert die Aufgabenbearbeitung an deinen bestehenden Agenten. Bei einer verketteten Pipeline ersetzt es die separaten Stufen für Spracherkennung und Sprachsynthese. Behalte Modelle, Anweisungen, Werkzeuge, Ablauf und dauerhaft gespeicherten Zustand in deinem Backend bei, soweit sie weiterhin zur Aufgabe passen.

Deinen bestehenden Agenten anbinden

Konfiguriere delegation beim Setup der Sitzung als {"type":"client"}. Deine Anwendung erhält eine Benachrichtigung wie diese:

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

Die Benachrichtigung enthält Metadaten, aber weder den Anfragetext noch Werkzeugargumente oder ein vollständiges Transkript. Behalte die tatsächliche delegation.id unverändert bei. Stelle die Eingabe für den Agenten aus aktuellen, mit Rollen gekennzeichneten Transkriptfragmenten und dem verifizierten Anwendungszustand zusammen, einschließlich der aktiven Aufgabe und der letzten Korrektur. Eine Delegation kann eintreffen, bevor ein vollständiger Satz im Transkript erscheint. Wenn der verfügbare Kontext die Anfrage nicht eindeutig erkennen lässt, sammle weiteren Kontext oder frage nach, bevor du handelst.

In einer Textanwendung übergibst du die letzte Nachricht der nutzenden Person möglicherweise direkt an deinen Agenten. Ergänze für GPT-Live einen Adapter, der diesen Kontext bereitstellt und ein knappes, verifiziertes Ergebnis zurückgibt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25async function handleDelegation(event, app) {
  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,
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40from collections.abc import Awaitable, Callable
from dataclasses import dataclass
from uuid import uuid4

from openai.resources.live.live import AsyncLiveConnection
from openai.resources.live.sideband import AsyncSidebandConnection
from openai.types.live.server_event import ServerEvent


@dataclass(frozen=True)
class Context:
    revision: int
    recent_conversation: str
    task: str


async def handle_delegation(
    event: ServerEvent,
    connection: AsyncLiveConnection | AsyncSidebandConnection,
    *,
    read_context: Callable[[], Context | None],
    run_agent: Callable[[Context], Awaitable[str]],
    current_revision: Callable[[], int],
) -> None:
    if (
        event.type != "session.delegation.created"
        or event.delegation.target != "client"
    ):
        return
    context = read_context()
    if context is None:
        return  # Retain the notice; resolve the request before acting.
    summary = await run_agent(context)
    if current_revision() != context.revision:
        return
    await connection.session.commentary.append(
        event_id=str(uuid4()),
        delegation_id=event.delegation.id,
        content=summary,
    )

Der Adapter nutzt Callbacks deiner Anwendung, um Kontext auszulesen, deinen Agenten auszuführen und die aktuelle Revision der Aufgabe zu prüfen. Das sind keine SDK-Methoden. Der Kontext-Callback gibt einen verfügbaren Snapshot mit dem jüngsten Gesprächsverlauf und der aktuellen Aufgabe zurück. Ist die Anfrage noch unklar, gibt er keinen Snapshot zurück. Der Agenten-Callback ruft deinen bestehenden Agenten auf und gibt eine verifizierte Zusammenfassung mit höchstens 500 Tokens zurück. In JavaScript sendet der von der Anwendung bereitgestellte Callback send das JSON-Ereignis über deine Live-Verbindung. In Python sendet der Adapter die Aktualisierung direkt über connection des SDK.

Wenn der Kontext noch nicht bereitsteht, bewahre die Benachrichtigung auf und rufe den Adapter erneut auf, sobald die Anfrage geklärt ist. Markiere die Delegation vor dem Aufruf dieses Adapters in deiner Anwendung als zur Bearbeitung übernommen, damit eine doppelte Zustellung dieselbe Operation nicht zweimal starten kann. Verwalte Autorisierung, Bestätigung, Operations-IDs und Entscheidungen über Wiederholungsversuche in deinem Backend. Die Revisionsprüfung verhindert, dass dieser Adapter ein veraltetes Ergebnis mitteilt. Auch das Backend muss die aktuelle Revision prüfen, bevor es eine Aktion mit Seiteneffekt ausführt, etwa eine Buchung.

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ügbarkeitsabfrage sollte angeben, dass ein Termin verfügbar ist und noch keine Buchung vorgenommen wurde. Gib eine Buchungsbestätigung erst zurück, nachdem die Buchung erfolgreich war. Das vollständige Setup und den Ablauf der Ergebnisübermittlung findest du unter Client-Delegation.

Aktualisierungen und Korrekturen weiterleiten

Belasse strukturierte Werkzeugausgaben und Details zum Ablauf in deinem Backend. Gib kurze, sachliche Aktualisierungen an GPT-Live zurück:

• Verwende session.thinking.append für Fortschrittsmeldungen aus dem Hintergrund, etwa zu einer noch laufenden Abfrage.
• Verwende session.commentary.append für ein verifiziertes Ergebnis, das die nutzende Person hören soll.
• Verwende session.instructions.append für Verhaltensanweisungen, die von der Anwendung stammen.

Alle drei akzeptieren content als einfache Zeichenfolge mit höchstens 500 Tokens und erfordern delegation_id. Verwende für zugehörige Aufgaben die ursprüngliche ID der Client-Delegation oder null für allgemeinen Sitzungskontext. Ordne Bestätigungen für das Anhängen mithilfe von client_event_id zu. Die Annahme bestätigt weder eine Sprachausgabe noch deren Wiedergabe. Siehe Die passende Art von Aktualisierung senden.

Wenn die nutzende Person „Doch lieber Freitag“ sagt, aktualisiere die aktive Aufgabe und ihre Revision, mache jede Bestätigung für Donnerstag ungültig und weise den bestehenden Agenten an, die korrigierte Anfrage zu bearbeiten. Entscheide, ob du die laufende Abfrage abbrichst, änderst oder zu Ende führen lässt. Verwirf ein veraltetes Ergebnis, bevor du es an GPT-Live zurückgibst. Eine Unterbrechung der Sprachausgabe bricht keine Backend-Operation ab, und eine Abbruchanforderung belegt nicht, dass eine Aktion abgebrochen wurde.

Die Verarbeitung im Backend kann über die Sprachsitzung hinaus andauern. Speichere ihren Status dauerhaft in deiner Anwendung. Starte bei einer späteren Sprachinteraktion eine neue Sitzung mit dem relevanten gespeicherten Kontext. Siehe Sitzungen verwalten.

Schutzmaßnahmen für Text und Sprache anpassen

Ein Textagent kann eine Antwort fertigstellen und validieren, bevor er sie anzeigt. Eine verkettete Pipeline kann die vollständige Antwort validieren, bevor sie diese an die Sprachsynthese weitergibt. GPT-Live kann sprechen, während die Verarbeitung im Backend noch läuft. Ein Werkzeugergebnis zurückzuhalten oder die Fortsetzung der Backend-Verarbeitung aufzuschieben hält daher nicht die gesamte Sprachausgabe zurück.

Befolge die Anleitung unter Schutzmechanismen anpassen, um deine Prüfungen beizubehalten und kontinuierliche Sprachausgabe zu berücksichtigen.

Leite getippte Eingaben weiterhin an dein bestehendes Backend weiter. Behandle eine getippte Korrektur als Aktualisierung derselben Aufgabe und sende relevanten, verifizierten Kontext an die Sprachsitzung. Siehe Getippte Eingaben entgegennehmen und Aktualisierungen korrekt und nützlich halten.