Megszakítások és fordulókezelés
Ezen az oldalon
Frissítve: 2026. november 2. — Hangmodellek. A tanfolyam több modellje elavult: a
tts-1,tts-1-hdés agpt-4o-mini-tts2027. január 6-án megszűnik működni (helyettesítőjük:gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint a/v1/audio/speechnem támogat: a beszédszintézis migrációja a Realtime API-ra helyeződik át); agpt-realtime,gpt-4o-realtimeés a régi hangmodellek 2027. január 20-án (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5); awhisper-1,gpt-4o-transcribeés a/v1/audio/translations2027. február 26-án (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). A teljes duplex hanghívásokhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.
Helyesbítve: 2026. november 3. A
session.updateesemények korábban aturn_detectionmezőt a munkamenet gyökerébe helyezték, ami a régi béta verzió formátuma volt: a jelenlegi Realtime API-val a beállítás asession.audio.input.turn_detectionalatt található, és a munkamenet típusa"type": "realtime". A megszakításkezelés korábbanresponse.cancelüzenetet küldött, de VAD esetén a szerver maga szakítja meg a választ, és a kód egy nem definiált változót használt. Ez a lecke most asemantic_vad,create_responseésinterrupt_responsekezelését tárgyalja, valamint különbséget tesz a WebSocket és a WebRTC között. Az eseménystruktúrákat azopenaiSDK 3.42.1-es típusai alapján ellenőriztük. Források: Hangtevékenység-észlelés · Valós idejű beszélgetések.
Megszakítások és fordulókezelés
A természetes beszélgetésekben az emberek gyakran megszakítják egymást, egyszerre beszélnek, vagy félbeszakítják a másikat. Egy hangalapú ügynök, amely nem képes kezelni ezeket a helyzeteket, robotikusnak és idegesítőnek hat majd. A Realtime API két mechanizmust biztosít a beszélgetési fordulók kezelésére: az automatikus Hangtevékenység-észlelést (VAD) és a manuális vezérlést.
Hangtevékenység-észlelés (VAD)
A VAD alapértelmezés szerint engedélyezve van egy hangalapú beszélgetési munkamenetben, server_vad módban működve: a szerver folyamatosan elemzi a bejövő hangot, csend alapján szegmentálja azt, és jelzi a felhasználói beszéd kezdetét és végét. Ezt a session.audio.input.turn_detection alatt konfigurálod:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"audio": {
"input": {
"turn_detection": {
"type": "server_vad",
"threshold": 0.5,
"prefix_padding_ms": 300,
"silence_duration_ms": 500,
"create_response": True, # válasz azonnal a forduló végén
"interrupt_response": True, # ügynök félbeszakítása, ha a felhasználó beszél
}
}
},
},
}))
VAD paraméterek
| Paraméter | Leírás | Hatás |
|---|---|---|
| threshold | Észlelési küszöb (0.0 és 1.0 között) | Magas = kevésbé érzékeny, Alacsony = érzékenyebb |
| prefix_padding_ms | Az észlelés előtt megtartott hang | Megakadályozza a szavak elejének levágását |
| silence_duration_ms | A forduló lezárásához szükséges csend időtartama | Rövid = reagálókész, Hosszú = türelmes |
Ha a silence_duration_ms túl rövid, a válasz a felhasználó beszédének természetes szüneteiben is elindul; ha túl hosszú, az ügynök reagálatlannak tűnik. Az OpenAI nem tesz közzé nyelvspecifikus alapértelmezéseket: kezdd a dokumentáció példájával (500 ms), és a felhasználóid felvételei alapján állítsd be. A magasabb threshold hangosabb hangot igényel az aktiváláshoz, ami zajos környezetben segít.
Szemantikai VAD
A második mód, a semantic_vad, nem a csendre, hanem a szavakra támaszkodik: egy osztályozó becslést ad arra, hogy a felhasználó befejezte-e a mondatát. Egy félbehagyott mondat több időt engedélyez, mint egy egyértelmű kijelentés, és a modell ritkábban szakít félbe. Az eagerness (sietség) beállítása lehet low (hagyd, hogy a felhasználó ráérjen), medium, high (válaszolj, amint csak lehet), vagy auto, ami az alapértelmezett érték, és egyenértékű a medium-mal:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"audio": {"input": {"turn_detection": {"type": "semantic_vad", "eagerness": "low"}}},
},
}))
Megszakítások kezelése
Amikor a felhasználó beszél, miközben az ügynök válaszol, a szerver kibocsátja az input_audio_buffer.speech_started eseményt. Ha a VAD és az interrupt_response engedélyezve van, a szerver megszakítja az aktuális választ: ezután elküldi a response.done üzenetet cancelled állapottal. Neked még két dolgot kell tenned a saját oldaladon egy WebSocket kapcsolaton, ahol te lejátszod a hangot:
- Állítsd le azonnal a lejátszást, és dobd el a sorban lévő összes hangot, jegyezve fel, hogy hány milliszekundumot hallott valójában a felhasználó.
- Csonkítsd az ügynök elemét erre az időtartamra a
conversation.item.truncatehasználatával.
Ne várj a response.done eseményre sem egyik lépéshez sem.
async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
"""Kezeli a felhasználói beszédet, miközben az ügynök beszél (WebSocket)."""
if event["type"] != "input_audio_buffer.speech_started":
return
# 1. Lejátszás leállítása és a sorban lévő hangpuffer törlése
player.stop_stream()
# 2. A felhasználó által nem hallott rész eltávolítása az előzményekből
if item_id:
await ws.send(json.dumps({
"type": "conversation.item.truncate",
"item_id": item_id,
"content_index": 0,
"audio_end_ms": ms_played,
}))
# 3. Lejátszás újraindítása a következő válaszhoz
player.start_stream()
A ms_played értékét aszerint számold ki, amit ténylegesen elküldtél a hangszórónak: 16 bites mono PCM formátumban, 24 kHz-en 48 000 bájt egy másodpercnek felel meg. WebRTC vagy SIP esetén a szerver kezeli maga a kimeneti puffert, tudja, mi szólalt meg, és automatikusan csonkít: neked nem kell semmit küldened.
Miért kell csonkítani a választ?
Csonkítás nélkül a beszélgetés előzményei tartalmaznák a modell teljes válaszát, annak ellenére, hogy a felhasználó csak egy részét hallotta. Ha a felhasználó megkérdezi: „Mi volt az utolsó dolog, amit mondtál?“, a modell azt hinné, hogy mindent elmondott. A csonkítás összehangolja az előzményeket azzal, amit a felhasználó valójában hallott. A dokumentáció megjegyzi a korlátozást: a csonkítás levágja a hangot és eltávolítja a le nem játszott rész átiratát, de nem biztosít szóról szóra csonkított átiratot.
Manuális vezérlési mód
Bizonyos használati eseteknél (IVR menük, diktálás, kvízek) az automatikus VAD nem megfelelő. A manuális mód teljes kontrollt ad a kezedbe:
# VAD letiltása
await ws.send(json.dumps({
"type": "session.update",
"session": {"type": "realtime", "audio": {"input": {"turn_detection": None}}},
}))
# Gomb megnyomva: ha az ügynök még beszél, szakítsd meg a választ és csonkítsd a le nem játszott hangot
await ws.send(json.dumps({"type": "response.cancel"}))
# Gomb elengedve: a hangot az input_audio_buffer.append küldte, commitold a fordulót...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
# ...majd indítsd el a választ
await ws.send(json.dumps({"type": "response.create"}))
VAD nélkül semmi sem automatikus: itt jön képbe a response.cancel, amikor egy válasz folyamatban van, és a felhasználó visszaveszi az irányítást. A fordulók között az input_audio_buffer.clear kiüríti a bemeneti puffert.
Létezik egy köztes megoldás is: hagyd engedélyezve a VAD-ot, hogy továbbra is szegmentálja a fordulókat és kibocsássa az eseményeket, de állítsd a create_response és interrupt_response értékeket False-ra. Így nincs válasz küldve a te explicit response.create parancsod nélkül, ami időt ad az input ellenőrzésére vagy gazdagítására (moderálás, dokumentumlekérés), némi késleltetés árán.
Manuális mód használati esetei
- IVR menü: Várakozás DTMF hangra vagy specifikus kulcsszóra válaszadás előtt
- Diktálás: Hosszú hangszakaszok gyűjtése megszakítás nélkül
- Megerősítés: Várakozás egy explicit „igen“ vagy „nem“ válaszra
- Nyomd-a-beszéléshez (Push-to-talk): A felhasználó gombot nyom a beszéléshez
Állapotkezelési architektúra
A robusztus fordulókezeléshez tarts fenn egy állapotgépet:
from enum import Enum
class ConversationState(Enum):
IDLE = "idle" # Várakozás
USER_SPEAKING = "user_speaking" # Felhasználó beszél
PROCESSING = "processing" # Modell feldolgozás alatt
AGENT_SPEAKING = "agent_speaking" # Ügynök válaszol
INTERRUPTED = "interrupted" # Megszakítás folyamatban
class TurnManager:
def __init__(self):
self.state = ConversationState.IDLE
self.current_response_item_id = None
self.played_audio_ms = 0
def on_event(self, event_type: str):
if event_type == "input_audio_buffer.speech_started":
if self.state == ConversationState.AGENT_SPEAKING:
self.state = ConversationState.INTERRUPTED
else:
self.state = ConversationState.USER_SPEAKING
elif event_type == "input_audio_buffer.speech_stopped":
self.state = ConversationState.PROCESSING
elif event_type == "response.output_audio.delta":
self.state = ConversationState.AGENT_SPEAKING
elif event_type == "response.done":
self.state = ConversationState.IDLE
Főbb megállapítások
- A VAD (alapértelmezés szerint
server_vad) asession.audio.input.turn_detectionalatt konfigurálható - A
semantic_vadjelentés alapján szegmentál; azeagernessszabályozza a türelmét - VAD esetén a szerver megszakítja a félbeszakított választ; WebSocketen állítsd le a lejátszást és csonkíts a
conversation.item.truncatesegítségével (WebRTC-n és SIP-en ez automatikus) - A manuális mód (
turn_detectionbeállítvaNone-ra) alkalmas nyomd-a-beszéléshez, IVR menükhöz és diktáláshoz - Egy explicit állapotgép megakadályozza a következetlen viselkedést a szélsőséges esetekben