Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Megszakítások és fordulókezelés

5. lecke 18 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Megszakítások és fordulókezelés
  2. Hangtevékenység-észlelés (VAD)
  3. Megszakítások kezelése
  4. Manuális vezérlési mód
  5. Állapotkezelési architektúra
  6. Főbb megállapítások

Frissítve: 2026. november 2. — Hangmodellek. A tanfolyam több modellje elavult: a tts-1, tts-1-hd és a gpt-4o-mini-tts 2027. 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/speech nem támogat: a beszédszintézis migrációja a Realtime API-ra helyeződik át); a gpt-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); a whisper-1, gpt-4o-transcribe és a /v1/audio/translations 2027. 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.update események korábban a turn_detection mező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 a session.audio.input.turn_detection alatt található, és a munkamenet típusa "type": "realtime". A megszakításkezelés korábban response.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 a semantic_vad, create_response és interrupt_response kezelését tárgyalja, valamint különbséget tesz a WebSocket és a WebRTC között. Az eseménystruktúrákat az openai SDK 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:

  1. Á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ó.
  2. Csonkítsd az ügynök elemét erre az időtartamra a conversation.item.truncate haszná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) a session.audio.input.turn_detection alatt konfigurálható
  • A semantic_vad jelentés alapján szegmentál; az eagerness szabá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.truncate segítségével (WebRTC-n és SIP-en ez automatikus)
  • A manuális mód (turn_detection beállítva None-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