Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Přerušení a správa předávání řeči

Lekce 5 z 18 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Přerušení a správa předávání řeči
  2. Detekce hlasové aktivity (VAD)
  3. Zpracování přerušení
  4. Režim ručního ovládání
  5. Architektura správy stavu
  6. Klíčové poznatky

Aktualizováno 2. listopadu 2026 — Zvukové modely. Několik modelů v tomto kurzu je zastaralých: tts-1, tts-1-hd a gpt-4o-mini-tts přestanou fungovat 6. ledna 2027 (náhrada: gpt-realtime-2.1-mini, který podle průvodce OpenAI TTS není podporován endpointem /v1/audio/speech: migrace syntézy řeči přechází na Realtime API); gpt-realtime, gpt-4o-realtime a starší zvukové modely skončí 20. ledna 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe a /v1/audio/translations skončí 26. února 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pro plně duplexní hlas je GPT-Live 1 dostupné v API od 10. září 2026.

Opraveno 3. listopadu 2026. Události session.update dříve umisťovaly turn_detection do kořene relace, což byl formát ze staré betaverze: u aktuálního Realtime API se toto nastavení nachází v session.audio.input.turn_detection a relace nese "type": "realtime". Zpracování přerušení dříve odesílalo response.cancel, ale s VAD server zruší odpověď sám a kód používal nedefinovanou proměnnou. Tato lekce nyní pokrývá semantic_vad, create_response a interrupt_response a rozlišuje mezi WebSocket a WebRTC. Tvar událostí ověřen proti typům SDK openai verze 3.42.1. Zdroje: Detekce hlasové aktivity · Konverzace v reálném čase.

Přerušení a správa předávání řeči

V přirozené konverzaci si lidé navzájem skáčou do řeči, mluví přes sebe a přerušují se. Hlasový agent, který tyto situace nezvládá, působí roboticky a frustrujícím dojmem. Realtime API nabízí dva mechanismy pro správu předávání řeči: automatickou detekci hlasové aktivity (VAD) a ruční ovládání.

Detekce hlasové aktivity (VAD)

VAD je v relaci hlasové konverzace ve výchozím nastavení povoleno a běží v režimu server_vad: server neustále analyzuje příchozí zvuk, segmentuje jej na základě ticha a signalizuje začátek a konec řeči uživatele. Konfigurujete jej 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,      # okamžitě odpovědět po skončení projevu
                    "interrupt_response": True,   # přerušit agenta, pokud uživatel promluví
                }
            }
        },
    },
}))

Parametry VAD

Parametr Popis Dopad
threshold Práh detekce (0,0 až 1,0) Vysoký = méně citlivý, Nízký = více citlivý
prefix_padding_ms Zvuk zachovaný před detekcí Zabraňuje uříznutí začátku slov
silence_duration_ms Délka ticha potřebná k ukončení projevu Krátká = reagující, Dlouhá = trpělivá

Příliš krátká hodnota silence_duration_ms spustí odpověď během přirozených pauz v řeči uživatele; příliš dlouhá způsobí, že agent bude působit nereagujícím dojmem. OpenAI nezveřejňuje výchozí hodnoty specifické pro jednotlivé jazyky: začněte s příkladem z dokumentace (500 ms) a upravujte jej na základě nahrávek vašich uživatelů. Vyšší hodnota threshold vyžaduje k aktivaci hlasitější zvuk, což pomáhá v hlučném prostředí.

Sémantické VAD

Druhý režim, semantic_vad, nespoléhá na ticho, ale na slova: klasifikátor odhaduje, zda uživatel dokončil svou větu. Věta ponechaná „viset“ získá více času než jasné prohlášení a model přerušuje méně často. Jeho nastavení eagerness může být low (nechat uživatele, ať si dá čas), medium, high (odpovědět co nejdříve) nebo auto, což je výchozí hodnota ekvivalentní medium:

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

Zpracování přerušení

Když uživatel promluví, zatímco agent odpovídá, server vyšle událost input_audio_buffer.speech_started. Pokud je povoleno VAD a interrupt_response, server zruší aktuální odpověď: následně odešle response.done se stavem cancelled. Na vaší straně musíte stále provést dvě věci na WebSocket připojení, kde přehráváte zvuk:

  1. Okamžitě zastavit přehrávání a zahodit veškerý zvuk ve frontě, přičemž zaznamenáte, kolik milisekund uživatel skutečně slyšel.
  2. Zkrátit položku agenta na tuto délku pomocí conversation.item.truncate.

Nečekejte s provedením kterékoli z těchto akcí na událost response.done.

async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
    """Zpracovává řeč uživatele během mluvení agenta (WebSocket)."""
    if event["type"] != "input_audio_buffer.speech_started":
        return

    # 1. Zastavit přehrávání a vyprázdnit vyrovnávací paměť zvuku ve frontě
    player.stop_stream()

    # 2. Odstranit z historie část, kterou uživatel neslyšel
    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 otevřít přehrávání pro další odpověď
    player.start_stream()

Hodnotu ms_played vypočítejte na základě toho, co jste skutečně odeslali do reproduktoru: u 16bitového mono PCM při 24 kHz se 48 000 bajtů rovná jedné sekundě. U WebRTC nebo SIP server spravuje výstupní vyrovnávací paměť sám, ví, co bylo přehráno, a zkrácení provede automaticky: nemusíte nic odesílat.

Proč odpověď zkracovat?

Bez zkrácení by historie konverzace obsahovala celou odpověď modelu, přestože uživatel slyšel pouze její část. Pokud by se uživatel zeptal: „Co jsi řekl naposledy?“, model by si myslel, že řekl vše. Zkrácení sladuje historii s tím, co uživatel skutečně slyšel. Dokumentace uvádí omezení: zkrácení ořízne zvuk a odstraní přepis nepřehrané části, ale neposkytuje přepis zkrácený slovo od slova.

Režim ručního ovládání

Pro určité případy použití (nabídky IVR, diktování, kvízy) není automatické VAD vhodné. Ruční režim vám poskytuje plnou kontrolu:

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

# Stisknuto tlačítko: pokud agent stále mluví, zrušit jeho odpověď a zkrátit nepřehraný zvuk
await ws.send(json.dumps({"type": "response.cancel"}))

# Uvolněno tlačítko: zvuk byl odeslán přes input_audio_buffer.append, potvrdit projev...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))

# ...poté spustit odpověď
await ws.send(json.dumps({"type": "response.create"}))

Bez VAD není nic automatické: zde přichází na řadu response.cancel, když probíhá odpověď a uživatel převezme kontrolu zpět. Mezi projevy input_audio_buffer.clear vyprázdní vstupní vyrovnávací paměť.

Existuje střední cesta: ponechte VAD povolené, aby nadále segmentovalo projevy a vysílalo události, ale nastavte create_response a interrupt_response na False. Žádná odpověď není odeslána bez vašeho explicitního response.create, což vám dává čas na ověření nebo obohacení vstupu (moderování, vyhledávání dokumentů) za cenu určité latence.

Případy použití ručního režimu

  • Nabídka IVR: Čekat na tón DTMF nebo specifické klíčové slovo před odpovědí
  • Diktování: Shromažďovat dlouhé zvukové segmenty bez přerušení
  • Potvrzení: Čekat na explicitní „ano“ nebo „ne“
  • Stiskni-a-mluv (Push-to-talk): Uživatel stiskne tlačítko pro řeč

Architektura správy stavu

Pro robustní správu předávání řeči udržujte stavový automat:

from enum import Enum

class ConversationState(Enum):
    IDLE = "idle"                    # Čekání
    USER_SPEAKING = "user_speaking"  # Uživatel mluví
    PROCESSING = "processing"        # Model zpracovává
    AGENT_SPEAKING = "agent_speaking" # Agent odpovídá
    INTERRUPTED = "interrupted"       # Probíhá přerušení

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

Klíčové poznatky

  • VAD (ve výchozím nastavení server_vad) je konfigurováno v session.audio.input.turn_detection
  • semantic_vad segmentuje na základě významu; eagerness řídí jeho trpělivost
  • S VAD server zruší přerušenou odpověď; u WebSocket zastavte přehrávání a zkraťte pomocí conversation.item.truncate (automatické u WebRTC a SIP)
  • Ruční režim (turn_detection nastaveno na None) vyhovuje pro push-to-talk, nabídky IVR a diktování
  • Explicitní stavový automat zabraňuje nekonzistentnímu chování v hraničních případech