Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Prekinitve in upravljanje menjavanja govorcev

Lekcija 5 od 18 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Prekinitve in upravljanje menjavanja govorcev
  2. Detekcija glasovne aktivnosti (VAD)
  3. Obravnava prekinitev
  4. Način ročnega nadzora
  5. Arhitektura upravljanja stanja
  6. Ključne ugotovitve

Posodobljeno 2. novembra 2026 — Zvočni modeli. Več modelov v tem tečaju je zastarelih: tts-1, tts-1-hd in gpt-4o-mini-tts prenehajo delovati 6. januarja 2027 (nadomestilo: gpt-realtime-2.1-mini, ki ga vodnik za OpenAI TTS navaja kot nepodprtega z /v1/audio/speech: selitev sinteze govora prehaja na Realtime API); gpt-realtime, gpt-4o-realtime in stari zvočni modeli 20. januarja 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe in /v1/audio/translations 26. februarja 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za polnodupleksni glas je GPT-Live 1 na voljo v API-ju od 10. septembra 2026.

Popravljeno 3. novembra 2026. Dogodki session.update so prej postavljali turn_detection v koren seje, kar je bila oblika iz stare beta različice: pri trenutnem Realtime API-ju nastavitve živijo v session.audio.input.turn_detection, seja pa nosi "type": "realtime". Obravnava prekinitev je prej pošiljala response.cancel, toda z VAD strežnik sam prekliče odgovor, koda pa je uporabljala nedefinirano spremenljivko. Ta lekcija zdaj pokriva semantic_vad, create_response in interrupt_response ter razlikuje med WebSocket in WebRTC. Oblike dogodkov so preverjene glede na tipe SDK openai različice 3.42.1. Viri: Detekcija glasovne aktivnosti · Pogovori v realnem času.

Prekinitve in upravljanje menjavanja govorcev

V naravnem pogovoru se ljudje med seboj prekinjajo, govorijo drug čez drugega in si segajo v besedo. Glasovni agent, ki teh situacij ne zna obdelati, deluje robotsko in frustrirajoče. Realtime API ponuja dva mehanizma za upravljanje menjavanja govorcev: samodejno detekcijo glasovne aktivnosti (VAD) in ročni nadzor.

Detekcija glasovne aktivnosti (VAD)

VAD je v seji glasovnega pogovora privzeto omogočen in deluje v načinu server_vad: strežnik neprestano analizira dohodni zvok, ga segmentira na podlagi tišine ter signalizira začetek in konec uporabnikovega govora. Nastaviš ga 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,      # odgovori takoj, ko se menjava konča
                    "interrupt_response": True,   # prekini agenta, če uporabnik spregovori
                }
            }
        },
    },
}))

Parametri VAD

Parameter Opis Vpliv
threshold Prag detekcije (0,0 do 1,0) Visok = manj občutljiv, Nizek = bolj občutljiv
prefix_padding_ms Zvok, ohranjen pred detekcijo Preprečuje odrezovanje začetka besed
silence_duration_ms Trajanje tišine, potrebno za konec menjave Kratko = odzivno, Dolgo = potrpežljivo

Če je silence_duration_ms prekratek, se odgovor sproži med naravnimi premori v uporabnikovem govoru; če je predolg, bo agent deloval neodzivno. OpenAI ne objavlja privzetih vrednosti, specifičnih za jezik: začni s primerom iz dokumentacije (500 ms) in prilagodi na podlagi posnetkov svojih uporabnikov. Višji threshold zahteva glasnejši zvok za sprožitev, kar pomaga v hrupnih okoljih.

Semantični VAD

Drugi način, semantic_vad, ne temelji na tišini, temveč na besedah: klasifikator oceni, ali je uporabnik končal svoj stavek. Nedokončan stavek kupi več časa kot jasna izjava, model pa redkeje prekine. Njegova nastavitev eagerness je lahko low (dovoli uporabniku, da si vzame čas), medium, high (odgovori čim prej) ali auto, kar je privzeta vrednost in enakovredna medium:

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

Obravnava prekinitev

Ko uporabnik spregovori, medtem ko agent odgovarja, strežnik odda dogodek input_audio_buffer.speech_started. Če sta omogočena VAD in interrupt_response, strežnik prekliče trenutni odgovor: nato pošlje response.done s statusom cancelled. Na svoji strani moraš storiti še dve stvari, in sicer pri povezavi WebSocket, kjer predvajaš zvok:

  1. Takoj ustavi predvajanje in zavrzi ves zvok v čakalni vrsti, pri čemer zabeležiš, koliko milisekund je uporabnik dejansko slišal.
  2. Okrajšaj element agenta na to trajanje z uporabo conversation.item.truncate.

Ne čakaj na response.done, da bi storil karkoli od tega.

async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
    """Obdelava uporabnikovega govora med govorjenjem agenta (WebSocket)."""
    if event["type"] != "input_audio_buffer.speech_started":
        return

    # 1. Ustavi predvajanje in počisti medpomnilnik čakajočega zvoka
    player.stop_stream()

    # 2. Odstrani del, ki ga uporabnik ni slišal, iz zgodovine
    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. Ponovno odpri predvajanje za naslednji odgovor
    player.start_stream()

Izračunaj ms_played na podlagi tega, kar si dejansko poslal zvočniku: pri 16-bitnem mono PCM pri 24 kHz 48.000 bajtov predstavlja eno sekundo. Pri WebRTC ali SIP strežnik sam upravlja izhodni medpomnilnik, ve, kaj je bilo predvajano, in samodejno okrajša zapis: ti ne potrebuješ ničesar poslati.

Zakaj okrajšati odgovor?

Brez okrajšave bi zgodovina pogovora vsebovala celoten odgovor modela, čeprav je uporabnik slišal le njegov del. Če uporabnik vpraša: „Kaj si nazadnje rekel?”, bi model mislil, da je povedal vse. Okrajšava uskladi zgodovino s tem, kar je uporabnik dejansko slišal. Dokumentacija opozarja na omejitev: okrajšava odreže zvok in odstrani prepis nepredvajanega dela, vendar ne zagotavlja beseda-za-besedo okrajšanega prepisa.

Način ročnega nadzora

Za določene primere uporabe (meniji IVR, narekovanje, kvizi) samodejni VAD ni primeren. Ročni način ti daje popoln nadzor:

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

# Pritisnjen gumb: če agent še govori, prekliči njegov odgovor in okrajšaj nepredvajani zvok
await ws.send(json.dumps({"type": "response.cancel"}))

# Spuščen gumb: zvok je bil poslan prek input_audio_buffer.append, potrdi menjavo...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))

# ...nato sproži odgovor
await ws.send(json.dumps({"type": "response.create"}))

Brez VAD nič ni samodejno: tu pride prav response.cancel, ko je odgovor v teku in uporabnik ponovno prevzame nadzor. Med menjavami input_audio_buffer.clear izprazni vhodni medpomnilnik.

Obstaja tudi srednja pot: ohrani VAD omogočen, da še naprej segmentira menjave in oddaja dogodke, vendar nastavi create_response in interrupt_response na False. Brez tvoje izrecne zahteve response.create se ne pošlje noben odgovor, kar ti da čas za preverjanje ali obogatitev vnosa (moderacija, pridobivanje dokumentov), vendar na račun nekaj zakasnitve.

Primeri uporabe ročnega načina

  • Meni IVR: Počakaj na ton DTMF ali določeno ključno besedo, preden odgovoriš
  • Narekovanje: Zberi dolge zvočne segmente brez prekinitev
  • Potrditev: Počakaj na izrecen „da” ali „ne”
  • Pritisni-in-govori: Uporabnik pritisne gumb za govor

Arhitektura upravljanja stanja

Za zanesljivo upravljanje menjavanja govorcev vzdržuj končni avtomat:

from enum import Enum

class ConversationState(Enum):
    IDLE = "idle"                    # Čakanje
    USER_SPEAKING = "user_speaking"  # Uporabnik govori
    PROCESSING = "processing"        # Model obdeluje
    AGENT_SPEAKING = "agent_speaking" # Agent odgovarja
    INTERRUPTED = "interrupted"       # Prekinitev v teku

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

Ključne ugotovitve

  • VAD (privzeto server_vad) je nastavljen v session.audio.input.turn_detection
  • semantic_vad segmentira na podlagi pomena; eagerness nadzira njegovo potrpežljivost
  • Pri VAD strežnik prekliče prekinjeni odgovor; pri WebSocket ustavi predvajanje in okrajšaj z conversation.item.truncate (samodejno pri WebRTC in SIP)
  • Ročni način (turn_detection nastavljen na None) ustreza pristopu pritisni-in-govori, menijem IVR in narekovanju
  • Izrecen končni avtomat preprečuje nedosledno obnašanje v robnih primerih