Mit dem WebRTC Abridged Roundtrip Protocol (WARP) kannst du Sprachsitzungen mit GPT-Live oder der Realtime API schneller starten. WARP kombiniert drei Transportoptimierungen (DTLS 1.3, SPED und SNAP) mit einem vorab ausgehandelten Datenkanal. Dadurch sind beim Verbindungsaufbau weniger Roundtrips über das Netzwerk nötig.
Du kannst diese Optimierungen auch einzeln nutzen. Aktiviere die Funktionen, die dein Client unterstützt, um den Verbindungsaufbau zu beschleunigen, auch wenn WARP nur teilweise verfügbar ist. Mit allen Funktionen zusammen erhältst du den vollständigen WARP-Handshake.
WARP, SPED und SNAP sind Internet-Drafts der IETF. Ihre Spezifikationen und die Unterstützung durch Clients können sich daher ändern.
GPT-Live und die Realtime API nutzen dieselben WebRTC-Optimierungen. Du konfigurierst sie im Browser oder im nativen Client, unabhängig von der Programmiersprache deines Anwendungsservers. Die APIs unterscheiden sich darin, wie du beim Erstellen einer Sitzung die ausgehandelte Datenkanal-ID übermittelst.
WARP in einem nativen Client aktivieren
Um WARP vollständig zu nutzen, aktiviere die Transportoptimierungen über Field Trials und handle vorab einen Datenkanal aus. Du kannst die beiden Schritte auch unabhängig voneinander ausführen.
Field Trials aktivieren
Aktuelle Versionen von libwebrtc enthalten die WARP-Optimierungen. Wenn dein nativer Client einen kompatiblen Build von libwebrtc verwendet, aktiviere die folgenden Field Trials:
WebRTC-ForceDtls13/Enabled/
WebRTC-Sctp-Snap/Enabled/
WebRTC-IceHandshakeDtls/Enabled/
Der erste Field Trial aktiviert DTLS 1.3, der zweite SNAP und der dritte SPED. Gib nur die Field Trials für die Optimierungen an, die du aktivieren möchtest.
Bei manchen Integrationen musst du alle gewünschten Field Trials in einer einzigen Zeichenfolge angeben:
WebRTC-ForceDtls13/Enabled/WebRTC-Sctp-Snap/Enabled/WebRTC-IceHandshakeDtls/Enabled/
Initialisiere die Field Trials, bevor du die Peer Connection Factory erstellst. Manche Wrapper bieten nur Einstellungen für einzelne Optimierungen. In webrtc-sys 0.3.51 aktivierst du beispielsweise SPED an der Factory und SNAP über die Verbindungskonfiguration:
use webrtc_sys::peer_connection::ffi::{
ContinualGatheringPolicy, IceTransportsType, RtcConfiguration,
};
use webrtc_sys::peer_connection_factory::ffi::create_peer_connection_factory_with_options;
// The wrapper enables SPED on the factory; SNAP is an immutable connection option.
let factory = create_peer_connection_factory_with_options(false, true);
let configuration = RtcConfiguration {
ice_servers: vec![],
continual_gathering_policy: ContinualGatheringPolicy::GatherOnce,
ice_transport_type: IceTransportsType::All,
enable_sctp_snap: true,
};Wenn du ein SDK verwendest, das libwebrtc kapselt, etwa ein natives LiveKit-SDK, übergib dieselbe Zeichenfolge über die WebRTC-Konfiguration oder die Initialisierungsoptionen des SDK. Bietet das SDK keinen Zugriff auf die Field Trials, initialisiere die zugrunde liegende Instanz von libwebrtc, bevor das SDK seine Peer Connection Factory erstellt. Alternativ kannst du auf einen Wrapper aktualisieren, der diese Konfiguration unterstützt.
Einen Datenkanal vorab aushandeln
Verwende im Client und in der Signalisierungsanfrage dieselbe Kanal-ID. Die folgenden Schritte gelten für native Clients und Browser, auch wenn du nur einen Teil der drei Transportoptimierungen oder keine davon aktiviert hast:
- Erstelle den Datenkanal vor dem SDP-Angebot. Setze dabei
negotiatedauftrueundidauf eine freie Kanal-ID, etwa4. Als Kanalbezeichnung kannst du eine beliebige Zeichenfolge verwenden. - Sende das SDP-Angebot und die Kanal-ID an deinen Anwendungsserver. Folge dann der Anleitung für deine API weiter unten.
Verbindung zu GPT-Live herstellen
Beginne mit der WebRTC-Schnellstartanleitung für GPT-Live. Dein Server muss die Kanal-ID als transport.dcid im JSON-Body von POST /v1/live/sessions mitsenden. Behalte für transport.type den Wert webrtc und für transport.sdp das SDP-Angebot des Clients bei.
Für einen Kanal, den du mit id: 4 erstellt hast, sende den folgenden JSON-Body an POST /v1/live/sessions. Ersetze <SDP offer> durch das SDP-Angebot, das dein Client erzeugt hat:
{
"session": {
"model": "gpt-live-1"
},
"transport": {
"type": "webrtc",
"sdp": "<SDP offer>",
"dcid": 4
}
}
Das Feld transport.dcid aktiviert den vorab ausgehandelten Kanal. Lass es weg, wenn du einen Standarddatenkanal verwendest. Sende dcid nicht als URL-Abfrageparameter. Anders als die Realtime API im unten beschriebenen Ablauf lehnt GPT-Live Abfrageparameter ab.
Übernimm den zurückgegebenen Wert von transport.sdp als SDP-Antwort der Gegenstelle und warte auf session.started, bevor du Anwendungsbefehle sendest. Die HTTP-Anfrage startet die Sitzung. Sende deshalb kein session.start über den Datenkanal.
Wenn dein SDK keinen Zugriff auf transport.dcid bietet, verwende den Standarddatenkanal wie in der Schnellstartanleitung für GPT-Live beschrieben. Die einzelnen Transportoptimierungen, die dein Client unterstützt, kannst du trotzdem aktivieren.
Verbindung zur Realtime API herstellen
Nutze den WebRTC-Verbindungsaufbau über die einheitliche Schnittstelle. Dein Server muss die Kanal-ID im Abfrageparameter dcid übermitteln, wenn er /v1/realtime/calls aufruft. Für einen Kanal, den du mit id: 4 erstellt hast, verwende POST /v1/realtime/calls?dcid=4. Behalte im Multipart-Body der Anfrage dasselbe SDP-Angebot und dieselbe Sitzungskonfiguration bei.
Übernimm die zurückgegebenen SDP-Daten als Antwort der Gegenstelle. Lass dcid weg, wenn du einen Standarddatenkanal verwendest. Das vollständige Beispiel weiter unten zeigt beide Konfigurationen.
WARP im Browser aktivieren
Chrome, Edge und andere Chromium-basierte Browser liefern libwebrtc mit. Über eine Webseite lassen sich die Field Trials der Bibliothek jedoch nicht konfigurieren. Aktiviere die in deinem Browser verfügbaren Transportfunktionen und handle dann vorab einen Datenkanal aus. Verwende dafür dieselbe API-spezifische Signalisierung wie bei einem nativen Client.
Verfügbare Funktionen und Origin Trials aktivieren
Ein Origin Trial schaltet eine experimentelle Browserfunktion für eine registrierte Website frei. Prüfe, welche WARP-Funktionen verfügbar sind:
- DTLS 1.3: Chrome unterstützt DTLS 1.3 ohne Origin Trial.
- SNAP: Die Chrome-Versionen 151–156 unterstützen SNAP über einen Origin Trial. Prüfe für Edge, ob für deine Version ein SNAP-Origin-Trial verfügbar ist, und registriere dich für ein von Edge ausgestelltes Token.
- SPED: Für SPED gibt es derzeit keinen Origin Trial in Browsern. Prüfe später erneut, ob SPED unterstützt wird. Um WARP vollständig zu nutzen, muss dein Browser SPED standardmäßig aktivieren, oder du musst die Startparameter des Browsers festlegen können und die erforderlichen Field Trials selbst aktivieren.
Der SNAP-Origin-Trial aktiviert weder SPED noch den vollständigen WARP-Handshake. Auch wenn dein Browser keinen Zugriff auf SPED bietet, kannst du mit DTLS 1.3 und dem SNAP-Origin-Trial den Verbindungsaufbau beschleunigen.
Hier findest du die Origin Trials für deinen Browser:
So aktivierst du den SNAP-Origin-Trial:
-
Öffne die Seite mit den Origin Trials für deinen Browser und suche nach „WebRTC Data Channel: SCTP Negotiation Acceleration Protocol (SNAP)“.
-
Wähle „Register“ und gib den Origin deiner Anwendung an, etwa
https://example.com. -
Füge das ausgestellte Token im
<head>deiner Seite vor dem Skript ein, dasRTCPeerConnectionerstellt:<meta http-equiv="origin-trial" content="YOUR_ORIGIN_TRIAL_TOKEN" /> -
Lade die Seite neu. Öffne in Chrome die DevTools, wähle „Application“ und prüfe, ob
WebRtcSctpSnapunter „Origin Trials“ erscheint.
Du kannst das Token auch als HTTP-Antwortheader übermitteln:
Origin-Trial: YOUR_ORIGIN_TRIAL_TOKEN
Ein Origin-Trial-Token gilt nur für die darin angegebene Funktion, den Browser, der es ausgestellt hat, und den registrierten Origin. Ein SNAP-Token aktiviert SPED nicht. Mit einem Chrome-Token kannst du den Origin Trial in Edge nicht aktivieren. Firefox, Safari, Browser unter iOS und ältere Chromium-Builds können Standard-WebRTC unterstützen, auch wenn sie WARP nicht vollständig unterstützen.
Den Datenkanal im Browser vorab aushandeln
Folge der Anleitung zum Einrichten des Datenkanals. Übermittle anschließend dieselbe ID wie in der Anleitung für GPT-Live oder die Realtime API beschrieben. Für das Aushandeln des Kanals im Voraus brauchst du keinen Origin Trial. Dadurch kann dein Client Serverereignisse früher empfangen, auch wenn WARP nur teilweise verfügbar ist.
Verbindung über die einheitliche Schnittstelle herstellen
Nutze den WebRTC-Verbindungsaufbau über die einheitliche Schnittstelle, um schneller eine Verbindung zur Realtime API herzustellen. Der Browser sendet sein SDP-Angebot und die ausgehandelte Datenkanal-ID an deinen Anwendungsserver. Dein Server leitet dieselbe ID im Abfrageparameter dcid weiter, wenn er /v1/realtime/calls aufruft.
Deinen Anwendungsserver konfigurieren
Dieser Anwendungsserver unterstützt Standard-WebRTC und WARP. Der mit WARP only gekennzeichnete Kommentar zeigt, wo der Server dcid für WARP weiterleiten muss:
import express from "express";
const app = express();
// Parse raw SDP payloads posted from the browser
app.use(express.text({ type: ["application/sdp", "text/plain"] }));
const sessionConfig = JSON.stringify({
type: "realtime",
model: "gpt-realtime-2.1",
audio: { output: { voice: "marin" } },
});
// An endpoint which creates a Realtime API session.
app.post("/session", async (req, res) => {
const fd = new FormData();
fd.set("sdp", req.body);
fd.set("session", sessionConfig);
const endpoint = new URL("https://api.openai.com/v1/realtime/calls");
// WARP only: forward the negotiated data-channel ID to the Realtime API.
if (typeof req.query.dcid === "string") {
endpoint.searchParams.set("dcid", req.query.dcid);
}
try {
const r = await fetch(endpoint, {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
"OpenAI-Safety-Identifier": "hashed-user-id",
},
body: fd,
});
// Send back the SDP we received from the OpenAI REST API
const sdp = await r.text();
res.set(
"Content-Type",
r.ok ? "application/sdp" : (r.headers.get("Content-Type") ?? "text/plain")
);
const location = r.headers.get("Location");
if (location) res.set("Location", location);
res.status(r.status).send(sdp);
} catch (error) {
console.error("Session creation error:", error);
res.status(500).json({ error: "Failed to create session" });
}
});
app.listen(3000);Verbindung vom Browser aus herstellen
Aktiviere die in deinem Browser verfügbaren Optimierungen und setze anschließend useWarp auf true. Wähle eine freie Datenkanal-ID und übermittle dieselbe ID an den Server. Die mit WARP only gekennzeichneten Kommentare zeigen, welche Konfigurations- und Signalisierungsschritte du bei Standard-WebRTC weglassen kannst:
// WARP only: set to true after enabling the supported WARP optimizations.
const useWarp = false;
// WARP only: choose any available data-channel ID.
const dataChannelId = 4;
// Create a peer connection
const pc = new RTCPeerConnection();
// Set up to play remote audio from the model
audioElement.current = document.createElement("audio");
audioElement.current.autoplay = true;
pc.ontrack = (e) => (audioElement.current.srcObject = e.streams[0]);
// Add local audio track for microphone input in the browser
const ms = await navigator.mediaDevices.getUserMedia({
audio: true,
});
pc.addTrack(ms.getTracks()[0]);
// Set up the event channel using any channel label.
// WARP only: pre-negotiate the channel using the selected data-channel ID.
const dc = pc.createDataChannel(
"events",
useWarp ? { negotiated: true, id: dataChannelId } : undefined,
);
// Start the session using the Session Description Protocol (SDP)
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
const endpoint = new URL("/session", window.location.origin);
// WARP only: include the matching data-channel ID in the session request.
if (useWarp) {
endpoint.searchParams.set("dcid", String(dataChannelId));
}
const sdpResponse = await fetch(endpoint, {
method: "POST",
body: offer.sdp,
headers: {
"Content-Type": "application/sdp",
},
});
const answer = {
type: "answer",
sdp: await sdpResponse.text(),
};
await pc.setRemoteDescription(answer);Einen Client ohne WARP-Unterstützung verwenden
Wenn dein WebRTC-Client ohne libwebrtc arbeitet, ergänze deinen WebRTC-Stack um die WARP-kompatiblen Transportoptimierungen oder wähle einen anderen Ansatz, den dein Stack unterstützt. Die zugehörigen Spezifikationen beschreiben WARP, SPED, SNAP, DTLS 1.3 und den Aufbau von Datenkanälen.
Wenn diese Optimierungen nicht verfügbar sind, nutze den standardmäßigen WebRTC-Verbindungsaufbau für GPT-Live oder die einheitliche Schnittstelle der Realtime API.