Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Katkestused ja kõnevoogude haldamine

Õppetund 5 / 18 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Katkestused ja kõnevoogude haldamine
  2. Hääleaktiivsuse tuvastamine (VAD)
  3. Katkestuste käsitlemine
  4. Manuaalne juhtimisrežiim
  5. Oleku haldamise arhitektuur
  6. Peamised punktid

Uuendatud 2. novembril 2026 — Audiomudelid. Selles kursuses on mitu mudelit aegunud: tts-1, tts-1-hd ja gpt-4o-mini-tts lõpetavad töö 6. jaanuaril 2027 (asendaja: gpt-realtime-2.1-mini, mille OpenAI TTS juhend märgib, et ei toeta /v1/audio/speech: kõnesünteesi migratsioon liigub Realtime API-le); gpt-realtime, gpt-4o-realtime ja vanad audiomudelid 20. jaanuaril 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ja /v1/audio/translations 26. veebruaril 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Täisdupleksse kõne jaoks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026.

Parandatud 3. novembril 2026. session.update sündmused paigutasid turn_detection varem seansi juurele, mis oli vana beetaversiooni formaat: praeguse Realtime API korral asub see säte aadressil session.audio.input.turn_detection ja seansil on väärtus "type": "realtime". Katkestuste käsitlemine saatis varem response.cancel, kuid VAD-i korral tühistab server vastuse ise ja kood kasutas määratlemata muutujat. See tund käsitleb nüüd semantic_vad, create_response ja interrupt_response ning teeb vahet WebSocketi ja WebRTC vahel. Sündmuste struktuure on kontrollitud openai SDK tüüpide 3.42.1 põhjal. Allikad: Hääleaktiivsuse tuvastamine · Reaalajas vestlused.

Katkestused ja kõnevoogude haldamine

Loomulikus vestluses katkestavad inimesed üksteist, räägivad samaaegselt ja lõpetavad teiste lauseid. Häälagent, mis ei suuda selliseid olukordi käsitleda, mõjub robotlikult ja tekitab pettumust. Realtime API pakub kõnevoogude haldamiseks kahte mehhanismi: automaatset hääleaktiivsuse tuvastamist (VAD) ja manuaalset juhtimist.

Hääleaktiivsuse tuvastamine (VAD)

VAD on häälevestluse seansis vaikimisi lubatud ja töötab režiimis server_vad: server analüüsib pidevalt sisenevat heli, segmenteerib selle vaikusperioodide põhjal ning annab märku kasutaja kõne algusest ja lõpust. Saad seda konfigureerida väljal 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,      # vasta kohe, kui kõnevoor lõpeb
                    "interrupt_response": True,   # katkesta agent, kui kasutaja räägib
                }
            }
        },
    },
}))

VAD-i parameetrid

Parameeter Kirjeldus Mõju
threshold Tuvastamise lävi (0,0 kuni 1,0) Kõrge = vähem tundlik, Madal = tundlikum
prefix_padding_ms Enne tuvastamist säilitatud heli Hoiab ära sõnade alguse äralõikamise
silence_duration_ms Kõnevooru lõpetamiseks vajalik vaikus Lühike = reageeriv, Pikk = kannatlik

Liiga lühike silence_duration_ms käivitab vastuse kasutaja kõne loomulike pauside ajal; liiga pikk aga jätab agendi reageerimatu mulje. OpenAI ei avalda keelepõhiseid vaikeväärtusi: alusta dokumentatsiooni näitest (500 ms) ja kohanda seda oma kasutajate salvestiste põhjal. Kõrgem threshold nõuab käivitamiseks valjemat heli, mis aitab mürases keskkonnas.

Semantiline VAD

Teine režiim, semantic_vad, ei tugine vaikusele, vaid sõnadele: klassifikaator hindab, kas kasutaja on oma lause lõpetanud. Poolikuks jäänud lause annab rohkem aega kui selge väide ja mudel katkestab harvem. Selle eagerness (innukus) säte võib olla low (lase kasutajal rahulikult võtta), medium, high (vasta nii kiiresti kui võimalik) või auto, mis on vaikeväärtus ja võrdub medium-ga:

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

Katkestuste käsitlemine

Kui kasutaja räägib ajal, mil agent vastab, edastab server sündmuse input_audio_buffer.speech_started. Kui VAD ja interrupt_response on lubatud, tühistab server jooksva vastuse: see saadab seejärel response.done olekuga cancelled. Sinu poolt on WebSocketi ühendusel, kus heli esitad, vaja teha veel kaks asja:

  1. Peata esitus koheselt ja tühjenda järjekorras olev heli, märkides üles, mitu millisekundit kasutaja tegelikult kuulis.
  2. Lühenda agendi kirjet selle kestuseni, kasutades conversation.item.truncate.

Ära oota kummagi tegemisega sündmust response.done.

async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
    """Käsitleb kasutaja kõnet ajal, mil agent räägib (WebSocket)."""
    if event["type"] != "input_audio_buffer.speech_started":
        return

    # 1. Peata esitus ja tühjenda järjekorras olev helipuhver
    player.stop_stream()

    # 2. Eemalda ajaloost osa, mida kasutaja ei kuulnud
    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. Ava esitus uuesti järgmise vastuse jaoks
    player.start_stream()

Arvuta ms_played põhjal, mida tegelikult kõlarisse saatsid: 16-bitises mono PCM-formaadis sagedusega 24 kHz võrdub 48 000 baiti ühe sekundiga. WebRTC või SIP puhul haldab server väljundpuhvrit ise, teab, mida on esitatud, ja lühendab automaatselt: sinul pole vaja midagi saata.

Miks vastust lühendada?

Ilma lühendamiseta sisaldaks vestluse ajalugu mudeli täielikku vastust, kuigi kasutaja kuulis ainult osa sellest. Kui kasutaja küsib: „Mis oli viimane asi, mida sa ütlesid?“, arvaks mudel, et ütles kõik. Lühendamine viib ajaloo kooskõlla sellega, mida kasutaja tegelikult kuulis. Dokumentatsioon toob välja piirangu: lühendamine lõikab heli ja eemaldab esitamata osa transkriptsiooni, kuid ei paku sõna-sõnalt lühendatud transkriptsiooni.

Manuaalne juhtimisrežiim

Teatud kasutusjuhtudel (IVR-menüüd, dikteerimine, viktoriinid) ei sobi automaatne VAD. Manuaalne režiim annab sulle täieliku kontrolli:

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

# Nupp vajutatud: kui agent veel räägib, tühista tema vastus ja lühenda esitamata heli
await ws.send(json.dumps({"type": "response.cancel"}))

# Nupp vabastatud: heli saadeti input_audio_buffer.append kaudu, kinnita kõnevoor...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))

# ...ja käivita seejärel vastus
await ws.send(json.dumps({"type": "response.create"}))

Ilma VAD-ita pole midagi automaatset: siin tulebki mängu response.cancel, kui vastus on pooleli ajal, kui kasutaja kontrolli tagasi võtab. Kõnevoorude vahel tühjendab input_audio_buffer.clear sisendpuhvri.

Olemas on ka kompromisslahendus: hoia VAD lubatuna, et see jätkaks kõnevoorude segmenteerimist ja sündmuste edastamist, kuid sea create_response ja interrupt_response väärtuseks False. Ühtegi vastust ei saadeta ilma sinu selge response.create käsuta, mis annab sulle aega sisendi kontrollimiseks või rikastamiseks (moderatsioon, dokumentide otsing), kuid suurendab latentsust.

Manuaalse režiimi kasutusjuhud

  • IVR-menüü: Oota DTMF-tooni või kindlat märksõna enne vastamist
  • Dikteerimine: Kogu pikki helilõike ilma katkestusteta
  • Kinnitamine: Oota selget „jah“ või „ei“
  • Vajuta-räägi: Kasutaja vajutab rääkimiseks nuppu

Oleku haldamise arhitektuur

Tugeva kõnevoogude haldamise jaoks loo olekumasina:

from enum import Enum

class ConversationState(Enum):
    IDLE = "idle"                    # Ootel
    USER_SPEAKING = "user_speaking"  # Kasutaja räägib
    PROCESSING = "processing"        # Mudel töötleb
    AGENT_SPEAKING = "agent_speaking" # Agent vastab
    INTERRUPTED = "interrupted"       # Katkestus käsil

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

Peamised punktid

  • VAD (vaikimisi server_vad) on konfigureeritud väljal session.audio.input.turn_detection
  • semantic_vad segmenteerib tähenduse põhjal; eagerness kontrollib selle kannatlikkust
  • VAD-i korral tühistab server katkestatud vastuse; WebSocketil peata esitus ja lühenda käsuga conversation.item.truncate (WebRTC ja SIP puhul automaatne)
  • Manuaalne režiim (turn_detection väärtusega None) sobib vajuta-räägi, IVR-menüüde ja dikteerimise jaoks
  • Selge olekumasin hoiab ära ebajärjekindla käitumise piirjuhtudel