Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Prerušenia a správa ťahov

Lekcia 5 z 18 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Prerušenia a správa ťahov
  2. Detekcia hlasovej aktivity (VAD)
  3. Spracovanie prerušení
  4. Režim manuálneho ovládania
  5. Architektúra správy stavu
  6. Kľúčové poznatky

Aktualizované 2. novembra 2026 — Zvukové modely. Niekoľko modelov v tomto kurze je zastaraných: tts-1, tts-1-hd a gpt-4o-mini-tts prestanú fungovať 6. januára 2027 (náhrada: gpt-realtime-2.1-mini, ktorý podľa sprievodcu OpenAI TTS nie je podporovaný cez /v1/audio/speech: migrácia syntézy reči prechádza na Realtime API); gpt-realtime, gpt-4o-realtime a staršie zvukové modely 20. januára 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe a /v1/audio/translations 26. februára 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pre plno duplexný hlas je GPT-Live 1 dostupné v API od 10. septembra 2026.

Opravené 3. novembra 2026. Události session.update predtým umiestňovali turn_detection do koreňa relácie, čo bol formát zo starej betaverzie: v aktuálnom Realtime API sa toto nastavenie nachádza v session.audio.input.turn_detection a relácia obsahuje "type": "realtime". Spracovanie prerušení predtým odosielalo response.cancel, ale pri VAD server zruší odpoveď sám a kód používal nedefinovanú premennú. Táto lekcia teraz pokrýva semantic_vad, create_response a interrupt_response a rozlišuje medzi WebSocket a WebRTC. Tvary udalostí overené podľa typov SDK openai verzie 3.42.1. Zdroje: Detekcia hlasovej aktivity · Konverzácie v reálnom čase.

Prerušenia a správa ťahov

V prirodzenej konverzácii si ľudia navzájom skáčú do reči, hovoria súčasne a prerušujú sa. Hlasový agent, ktorý nedokáže tieto situácie zvládnuť, pôsobí roboticky a frustrujúco. Realtime API poskytuje dva mechanizmy na správu striedania sa v reči: automatickú detekciu hlasovej aktivity (VAD) a manuálne ovládanie.

Detekcia hlasovej aktivity (VAD)

VAD je v relácii hlasovej konverzácie predvolene zapnuté a funguje v režime server_vad: server neustále analyzuje prichádzajúci zvuk, segmentuje ho na základe ticha a signalizuje začiatok a koniec reči používateľa. Konfiguruješ ho v session.audio.input.turn_detection:

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,      # odpovedať okamžite po skončení ťahu
                    "interrupt_response": True,   # prerušiť agenta, ak používateľ hovorí
                }
            }
        },
    },
}))

Parametre VAD

Parameter Popis Dopad
threshold Prah detekcie (0,0 až 1,0) Vysoký = menej citlivý, Nízky = viac citlivý
prefix_padding_ms Zvuk zachovaný pred detekciou Zabraňuje orezaniu začiatku slov
silence_duration_ms Dĺžka ticha potrebná na ukončenie ťahu Krátky = reakčný, Dlhý = trpezlivý

Príliš krátke silence_duration_ms spustí odpoveď počas prirodzených pauz v reči používateľa; príliš dlhé spôsobí, že agent bude pôsobiť nereaktívne. OpenAI nezverejňuje predvolené hodnoty špecifické pre jazyk: začni s príkladom z dokumentácie (500 ms) a upravuj ho na základe nahrávok svojich používateľov. Vyšší threshold vyžaduje hlasnejší zvuk na spustenie, čo pomáha v hlučnom prostredí.

Sémantické VAD

Druhý režim, semantic_vad, nespolieha na ticho, ale na slová: klasifikátor odhaduje, či používateľ dokončil vetu. Veta ponechaná „visieť“ získa viac času než jasná výpoveď a model prerušuje menej často. Jeho nastavenie eagerness môže byť low (nechaj používateľa, nech si dá čas), medium, high (odpovedz čo najskôr) alebo auto, čo je predvolená hodnota ekvivalentná medium:

await ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "type": "realtime",
        "audio": {"input": {"turn_detection": {"type": "semantic_vad", "eagerness": "low"}}},
    },
}))

Spracovanie prerušení

Keď používateľ hovorí počas odpovede agenta, server vydá udalosť input_audio_buffer.speech_started. Pri zapnutom VAD a interrupt_response server zruší aktuálnu odpoveď: následne odošle response.done so stavom cancelled. Na tvojej strane musíš urobiť ešte dve veci pri WebSocket pripojení, kde prehrávaš zvuk:

  1. Okamžite zastav prehrávanie a zahodź akýkoľvek zvuk v rade, pričom si zaznamenaj, koľko milisekúnd používateľ skutočne počul.
  2. Orež položku agenta na túto dĺžku pomocou conversation.item.truncate.

Nečakaj s týmito krokmi na udalosť response.done.

async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
    """Spracováva reč používateľa počas hovoru agenta (WebSocket)."""
    if event["type"] != "input_audio_buffer.speech_started":
        return

    # 1. Zastav prehrávanie a vyčisti buffer zvuku v rade
    player.stop_stream()

    # 2. Odstráň časť, ktorú používateľ nepočul, z histórie
    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. Znovu otvor prehrávanie pre ďalšiu odpoveď
    player.start_stream()

Hodnotu ms_played vypočítaj na základe toho, čo si skutočne odoslal do reproduktora: pri 16-bitovom mono PCM na 24 kHz sa 48 000 bajtov rovná jednej sekunde. Pri WebRTC alebo SIP server sám spravuje výstupný buffer, vie, čo bolo prehrané, a orezávanie vykoná automaticky: nemusíš nič odosielať.

Prečo orezávať odpoveď?

Bez orezania by história konverzácie obsahovala celú odpoveď modelu, hoci používateľ počul len jej časť. Ak by sa používateľ opýtal: „Čo si povedal naposledy?“, model by si myslel, že povedal všetko. Orezanie zosúladí históriu s tým, čo používateľ skutočne počul. Dokumentácia uvádza obmedzenie: orezanie vystrihne zvuk a odstráni prepis neprehranej časti, ale neposkytuje prepis slovo od slova pre orezanú časť.

Režim manuálneho ovládania

Pre určité prípady použitia (IVR menu, diktovanie, kvízy) nie je automatické VAD vhodné. Manuálny režim ti dáva plnú kontrolu:

# Zakázať VAD
await ws.send(json.dumps({
    "type": "session.update",
    "session": {"type": "realtime", "audio": {"input": {"turn_detection": None}}},
}))

# Stlačené tlačidlo: ak agent stále hovorí, zruš jeho odpoveď a orež neprehraný zvuk
await ws.send(json.dumps({"type": "response.cancel"}))

# Uvoľnené tlačidlo: zvuk bol odoslaný cez input_audio_buffer.append, potvrď ťah...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))

# ...potom spusti odpoveď
await ws.send(json.dumps({"type": "response.create"}))

Bez VAD nie je nič automatické: tu prichádza na rad response.cancel, keď prebieha odpoveď a používateľ preberá kontrolu späť. Medzi ťahmi input_audio_buffer.clear vyprázdni vstupný buffer.

Existuje aj stredná cesta: nechaj VAD zapnuté, aby naďalej segmentovalo ťahy a vydávalo udalosti, ale nastav create_response a interrupt_response na False. Žiadna odpoveď sa neodošle bez tvojej explicitnej výzvy response.create, čo ti dáva čas na overenie alebo obohatenie vstupu (moderácia, vyhľadávanie dokumentov) za cenu určitého oneskorenia.

Prípady použitia manuálneho režimu

  • IVR menu: Čakaj na tón DTMF alebo konkrétne kľúčové slovo pred odpoveďou
  • Diktovanie: Akumuluj dlhé zvukové segmenty bez prerušenia
  • Potvrdenie: Čakaj na explicitné „áno“ alebo „nie“
  • Stlač a hovort (Push-to-talk): Používateľ stlačí tlačidlo, aby hovoril

Architektúra správy stavu

Pre robustnú správu ťahov si udržuj stavový automat:

from enum import Enum

class ConversationState(Enum):
    IDLE = "idle"                    # Čakanie
    USER_SPEAKING = "user_speaking"  # Používateľ hovorí
    PROCESSING = "processing"        # Model spracováva
    AGENT_SPEAKING = "agent_speaking" # Agent odpovedá
    INTERRUPTED = "interrupted"       # Prebieha prerušenie

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

Kľúčové poznatky

  • VAD (predvolene server_vad) sa konfiguruje v session.audio.input.turn_detection
  • semantic_vad segmentuje na základe významu; eagerness riadi jeho trpezlivosť
  • Pri VAD server zruší prerušenú odpoveď; pri WebSocket zastav prehrávanie a orež pomocou conversation.item.truncate (automatické pri WebRTC a SIP)
  • Manuálny režim (turn_detection nastavené na None) vyhovuje push-to-talk, IVR menu a diktovaniu
  • Explicitný stavový automat zabraňuje nekonzistentnému správaniu v hraničných prípadoch