Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Pārtraukumi un sarunu maiņas vadība

Nodarbība 5 no 18 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Pārtraukumi un sarunu maiņas vadība
  2. Balss aktivitātes noteikšana (VAD)
  3. Pārtraukumu apstrāde
  4. Manuālās kontroles režīms
  5. Stāvokļa pārvaldības arhitektūra
  6. Galvenās atziņas

Atjaunināts 2026. gada 2. novembrī — Audio modeļi. Vairāki šī kursa modeļi ir novecojuši: tts-1, tts-1-hd un gpt-4o-mini-tts pārtrauks darboties 2027. gada 6. janvārī (aizstājējs: gpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata norāda kā ** neatbalstītu ar /v1/audio/speech**: runas sintēzes migrācija pāriet uz Realtime API); gpt-realtime, gpt-4o-realtime un vecie audio modeļi — 2027. gada 20. janvārī (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe un /v1/audio/translations — 2027. gada 26. februārī (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pilnīgai divpusējai balss saziņai GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra.

Labots 2026. gada 3. novembrī. Iepriekš session.update notikumi novietoja turn_detection sesijas saknē, kas ir vecā beta formāts: ar pašreizējo Realtime API iestatījums atrodas session.audio.input.turn_detection, un sesijai ir "type": "realtime". Iepriekš pārtraukumu apstrāde sūtīja response.cancel, taču ar VAD serveris pats atceļ atbildi, un kodā tika izmantots nedefinēts mainīgais. Šī nodarbība tagad aptver semantic_vad, create_response un interrupt_response, kā arī nošķir WebSocket un WebRTC. Notikumu formas verificētas pret openai SDK tipiem 3.42.1. Avoti: Balss aktivitātes noteikšana · Reāllaika sarunas.

Pārtraukumi un sarunu maiņas vadība

Dabiskā sarunā cilvēki viens otru pārtrauc, runā vienlaicīgi un pārtrauc viens otra teikumu. Balss aģents, kas nespēj tikt galā ar šādām situācijām, šķitīs robotisks un kaitinošs. Realtime API piedāvā divus mehānismus sarunu maiņas vadībai: automātisku balss aktivitātes noteikšanu (VAD) un manuālu kontroli.

Balss aktivitātes noteikšana (VAD)

VAD pēc noklusējuma ir iespējota balss sarunu sesijā, darbojoties server_vad režīmā: serveris nepārtraukti analizē ienākošo audio, segmentē to, balstoties uz klusumu, un signalizē lietotāja runas sākumu un beigas. Tu to konfigurē 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,      # atbildēt uzreiz, kad maiņa beidzas
                    "interrupt_response": True,   # pārtraukt aģentu, ja lietotājs runā
                }
            }
        },
    },
}))

VAD parametri

Parametrs Apraksts Ietekme
threshold Noteikšanas slieksnis (0,0 līdz 1,0) Augsts = mazāk jutīgs, Zems = jutīgāks
prefix_padding_ms Audio, kas saglabāts pirms noteikšanas Novērš vārdu sākuma nogriešanu
silence_duration_ms Klusuma ilgums, kas nepieciešams maiņas beigām Īss = reaģējošs, Garš = pacietīgs

Pārāk īgs silence_duration_ms izraisīs atbildi dabisku paužu laikā lietotāja runā; pārāk garš — aģents šķitīs nereaģējošs. OpenAI nepublicē valodai specifiskus noklusējumus: sāc ar dokumentācijas piemēru (500 ms) un pielāgo, balstoties uz savu lietotāju ierakstiem. Augstāks threshold prasa skaļāku skaņu aktivizēšanai, kas palīdz trokšņainā vidē.

Semantiskā VAD

Otrais režīms, semantic_vad, nepaļaujas uz klusumu, bet gan uz vārdiem: klasifikators novērtē, vai lietotājs ir pabeidzis teikumu. Nepabeigts teikums dod vairāk laika nekā skaidrs apgalvojums, un modelis pārtrauc retāk. Tā eagerness iestatījums var būt low (ļauj lietotājam ņemt laiku), medium, high (atbildēt cik ātri vien iespējams) vai auto — noklusētā vērtība, kas ir ekvivalenta medium:

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

Pārtraukumu apstrāde

Kad lietotājs runā, kamēr aģents sniedz atbildi, serveris ģenerē input_audio_buffer.speech_started. Ar iespējotu VAD un interrupt_response serveris atceļ pašreizējo atbildi: tas tad nosūta response.done ar statusu cancelled. Tev joprojām jāveic divas darbības savā pusē, ja izmanto WebSocket savienojumu, kurā atskaņo audio:

  1. Nekavējoties apturi atskaņošanu un izmet visu rindā esošo audio, atzīmējot, cik milisekundes lietotājs faktiski dzirdēja.
  2. Saīsini aģenta vienumu līdz šim ilgumam, izmantojot conversation.item.truncate.

Negaidi response.done, lai veiktu kādu no šīm darbībām.

async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
    """Apstrādā lietotāja runu, kamēr aģents runā (WebSocket)."""
    if event["type"] != "input_audio_buffer.speech_started":
        return

    # 1. Apturi atskaņošanu un notīri rindā esošo audio buferi
    player.stop_stream()

    # 2. No vēstures noņem daļu, ko lietotājs nedzirdēja
    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. Atkārtoti atver atskaņošanu nākamajai atbildei
    player.start_stream()

Aprēķini ms_played, balstoties uz to, ko faktiski nosūtīji skaļrunim: 16 bitu mono PCM ar 24 kHz, 48 000 baiti ir vienāds ar vienu sekundi. WebRTC vai SIP gadījumā serveris pats pārvalda izejas buferi, zina, kas ir atskaņots, un automātiski saīsina: tev nekas nav jāsūta.

Kāpēc saīsināt atbildi?

Bez saīsināšanas sarunu vēsturē paliktu modeļa pilnā atbilde, lai gan lietotājs dzirdēja tikai tās daļu. Ja lietotājs jautā: „Ko tu teici pēdējo?”, modelis domātu, ka ir teicis visu. Saīsināšana saskaņo vēsturi ar to, ko lietotājs faktiski dzirdēja. Dokumentācija norāda ierobežojumu: saīsināšana nogriež audio un noņem neat skaņoto daļu transkripciju, taču tā nenodrošina vārds vārdā saīsinātu transkripciju.

Manuālās kontroles režīms

Noteiktiem lietojumiem (IVR izvēlnes, diktēšana, viktorīnas) automātiskais VAD nav piemērots. Manuālais režīms dod tev pilnu kontroli:

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

# Nospiesta poga: ja aģents joprojām runā, atcelt tā atbildi un saīsināt neatskaņoto audio
await ws.send(json.dumps({"type": "response.cancel"}))

# Atlaista poga: audio tika nosūtīts caur input_audio_buffer.append, fiksēt maiņu...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))

# ...tad izraisīt atbildi
await ws.send(json.dumps({"type": "response.create"}))

Bez VAD nekas nav automātisks: tieši šeit nāk talkā response.cancel, kad notiek atbilde, bet lietotājs pārņem kontroli. Starp maiņām input_audio_buffer.clear iztukšo ievades buferi.

Pastāv arī vidusceļš: atstāj VAD iespējotu, lai tas turpinātu segmentēt maiņas un ģenerēt notikumus, bet iestati create_response un interrupt_response uz False. Bez tavas tiešas response.create komandas netiek sūtīta nekāda atbilde, dodot laiku ievades pārbaudei vai bagātināšanai (moderācija, dokumentu izgūšana), par cenu nelielas latentces.

Manuālā režīma lietojumi

  • IVR izvēlne: Gaidīt DTMF signālu vai konkrētu atslēgvārdu pirms atbildes
  • Diktēšana: Uzkrāt garus audio segmentus bez pārtraukumiem
  • Apstiprinājums: Gaidīt tiešu „jā” vai „nē”
  • Nospied-un-runā: Lietotājs nospiež pogu, lai runātu

Stāvokļa pārvaldības arhitektūra

Lai nodrošinātu stabilu maiņu vadību, uzturi stāvokļa mašīnu:

from enum import Enum

class ConversationState(Enum):
    IDLE = "idle"                    # Gaida
    USER_SPEAKING = "user_speaking"  # Lietotājs runā
    PROCESSING = "processing"        # Modelis apstrādā
    AGENT_SPEAKING = "agent_speaking" # Aģents atbild
    INTERRUPTED = "interrupted"       # Notiek pārtraukums

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

Galvenās atziņas

  • VAD (server_vad pēc noklusējuma) tiek konfigurēts session.audio.input.turn_detection
  • semantic_vad segmentē, balstoties uz nozīmi; eagerness kontrolē tā pacietību
  • Ar VAD serveris atceļ pārtraukto atbildi; WebSocket gadījumā apturi atskaņošanu un saīsini ar conversation.item.truncate (automātiski WebRTC un SIP)
  • Manuālais režīms (turn_detection iestatīts uz None) ir piemērots „nospied-un-runā”, IVR izvēlnēm un diktēšanai
  • Tieša stāvokļa mašīna novērš neatbilstīgu uzvedību robežgadījumos