Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Pertraukimai ir pokalbio valdymas

Paskaita 5 iš 18 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Pertraukimai ir pokalbio valdymas
  2. Balso aktyvumo aptikimas (VAD)
  3. Pertraukimų valdymas
  4. Rankinio valdymo režimas
  5. Būsenos valdymo architektūra
  6. Svarbiausi punktai

Atnaujinta 2026 m. lapkričio 2 d. – Garso modeliai. Keli šio kurso modeliai yra pasenę: tts-1, tts-1-hd ir gpt-4o-mini-tts nustos veikti 2027 m. sausio 6 d. (pakaitalas: gpt-realtime-2.1-mini, kuris, kaip nurodo „OpenAI“ TTS gidas, nepalaikomas per /v1/audio/speech: kalbos sintezės migracija perkeliama į „Realtime API“); gpt-realtime, gpt-4o-realtime ir senieji garso modeliai nustos veikti 2027 m. sausio 20 d. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ir /v1/audio/translations nustos veikti 2027 m. vasario 26 d. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Visaduplexiam balsui „GPT-Live 1“ API yra prieinamas nuo 2026 m. rugsėjo 10 d.

Ištaisyta 2026 m. lapkričio 3 d. Anksčiau session.update įvykiuose turn_detection buvo dedamas sesijos šaknyje – tai senojo beta formato ypatybė: dabartinėje „Realtime API“ šis nustatymas yra session.audio.input.turn_detection, o sesija turi "type": "realtime". Anksčiau pertraukimų valdymui buvo siunčiamas response.cancel, tačiau naudojant VAD serveris atsakymą atšaukia pats, o kode buvo naudotas neapibrėžtas kintamasis. Šioje pamokoje dabar nagrinėjami semantic_vad, create_response ir interrupt_response, taip pat atskiriami „WebSocket“ ir „WebRTC“ skirtumai. Įvykių struktūros patikrintos pagal openai SDK tipus 3.42.1. Šaltiniai: Balso aktyvumo aptikimas · Realtime pokalbiai.

Pertraukimai ir pokalbio valdymas

Natūraliame pokalbyje žmonės vienas kitą pertraukia, kalba vienas per kitą ir nutraukia pašnekovą. Balsinis agentas, kuris nesugeba tvarkytis su tokiomis situacijomis, atrodys robotiškas ir erzins. „Realtime API“ suteikia du mechanizmus pokalbio eigai valdyti: automatinį balso aktyvumo aptikimą (VAD) ir rankinį valdymą.

Balso aktyvumo aptikimas (VAD)

VAD balsinio pokalbio sesijoje yra įjungtas pagal nutylėjimą ir veikia server_vad režimu: serveris nuolat analizuoja gaunamą garso srautą, segmentuoja jį pagal tylos momentus ir signalizuoja naudotojo kalbos pradžią bei pabaigą. Tai konfigūruojiama 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,      # atsakyti iškart pasibaigus replikai
                    "interrupt_response": True,   # nutraukti agentą, jei pradeda kalbėti naudotojas
                }
            }
        },
    },
}))

VAD parametrai

Parametras Aprašymas Poveikis
threshold Aptikimo slenkstis (nuo 0,0 iki 1,0) Aukštas = mažiau jautrus, Žemas = jautresnis
prefix_padding_ms Garso dalis, išsaugoma prieš aptikimą Neleidžia nukirpti žodžių pradžios
silence_duration_ms Tylos trukmė, reikalinga replikai baigti Trumpa = reaguoja greitai, Ilga = kantrus

Per trumpas silence_duration_ms sukels atsakymą natūralių naudotojo kalbos pauzių metu; per ilgas – agentas atrodys nereaguojantis. „OpenAI“ neskelbia kalboms specifinių numatytųjų verčių: pradėk nuo dokumentacijos pavyzdžio (500 ms) ir koreguok pagal savo naudotojų įrašus. Didesnis threshold reikalauja garsesnio garso suveikimui, kas padeda triukšmingoje aplinkoje.

Semantinis VAD

Antrasis režimas, semantic_vad, remiasi ne tyla, o žodžiais: klasifikatorius įvertina, ar naudotojas baigė savo sakinį. Nepabaigtas sakinys suteikia daugiau laiko nei aiškus teiginys, todėl modelis rečiau pertraukia. Jo eagerness nustatymas gali būti low (leisti naudotojui neskubėti), medium, high (atsakyti kuo greičiau) arba auto – numatytoji vertė, kuri yra lygiavertė medium:

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

Pertraukimų valdymas

Kai naudotojas pradeda kalbėti agentui atsakant, serveris išsiunčia input_audio_buffer.speech_started. Įjungus VAD ir interrupt_response, serveris atšaukia dabartinį atsakymą: tuomet jis siunčia response.done su būsena cancelled. Tau vis tiek reikia atlikti du veiksmus savo pusėje, jei naudoji „WebSocket“ ryšį ir groji garso įrašą:

  1. Nedelsiant sustabdyti grojimą ir išvalyti bet kokią eilėje laukiančią garso dalį, užfiksavus, kiek milisekundžių naudotojas iš tikrųjų išgirdo.
  2. Sutrumpinti agento elementą iki tos trukmės naudojant conversation.item.truncate.

Nelauk response.done, kad atliktum šiuos veiksmus.

async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
    """Apdoroja naudotojo kalbą agentui kalbant (WebSocket)."""
    if event["type"] != "input_audio_buffer.speech_started":
        return

    # 1. Sustabdyti grojimą ir išvalyti eilėje laukiantį garso buferį
    player.stop_stream()

    # 2. Pašalinti iš istorijos dalį, kurios naudotojas neišgirdo
    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. Vėl atidaryti grojimą kitam atsakymui
    player.start_stream()

Apskaičiuok ms_played pagal tai, ką iš tikrųjų išsiuntei į garsiakalbį: 16 bitų mono PCM formatu esant 24 kHz dažniui, 48 000 baitų sudaro vieną sekundę. Naudojant WebRTC arba SIP, serveris pats valdo išvesties buferį, žino, kas buvo sugrota, ir automatiškai sutrumpina atsakymą: tau nieko siųsti nereikia.

Kodėl reikia sutrumpinti atsakymą?

Be sutrumpinimo pokalbio istorijoje liktų visas modelio atsakymas, nors naudotojas išgirdo tik jo dalį. Jei naudotojas paklaus: „Ką paskutinį pasakei?“, modelis manytų, kad pasakė viską. Sutrumpinimas suderina istoriją su tuo, ką naudotojas iš tikrųjų išgirdo. Dokumentacijoje nurodomas apribojimas: sutrumpinimas nukerpa garso įrašą ir pašalina nesugrotos dalies transkripciją, tačiau nepateikia žodis žodin sutrumpintos transkripcijos.

Rankinio valdymo režimas

Tam tikrais atvejais (IVR meniu, diktavimas, viktorinos) automatinis VAD netinka. Rankinis režimas suteikia pilną kontrolę:

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

# Paspaustas mygtukas: jei agentas vis dar kalba, atšaukti jo atsakymą ir sutrumpinti nesugrotą garso dalį
await ws.send(json.dumps({"type": "response.cancel"}))

# Mygtukas atleistas: garso duomenys buvo išsiųsti per input_audio_buffer.append, užfiksuoti repliką...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))

# ...tada inicijuoti atsakymą
await ws.send(json.dumps({"type": "response.create"}))

Be VAD niekas nevyksta automatiškai: čia ir praverčia response.cancel, kai atsakymas vyksta, o naudotojas perima kontrolę. Tarp replikų input_audio_buffer.clear išvalo įvesties buferį.

Yra ir tarpinis variantas: palikti VAD įjungtą, kad jis toliau segmentuotų replikas ir siųstų įvykius, tačiau nustatyti create_response ir interrupt_response į False. Atsakymas nebus siunčiamas be tavo aiškaus response.create, kas suteikia laiko patikrinti arba papildyti įvestį (moderavimas, dokumentų paieška), tačiau tai šiek tiek padidina delsą.

Rankinio režimo naudojimo atvejai

  • IVR meniu: Laukti DTMF tono arba specifinio raktažodžio prieš atsakant.
  • Diktavimas: Kaupti ilgas garso atkarpas be pertraukimų.
  • Patvirtinimas: Laukti aiškaus „taip“ arba „ne“.
  • Spausk ir kalbėk: Naudotojas paspaudžia mygtuką norėdamas kalbėti.

Būsenos valdymo architektūra

Patikimam pokalbio valdymui palaikyk būsenos mašiną:

from enum import Enum

class ConversationState(Enum):
    IDLE = "idle"                    # Laukiama
    USER_SPEAKING = "user_speaking"  # Kalba naudotojas
    PROCESSING = "processing"        # Modelis apdoroja
    AGENT_SPEAKING = "agent_speaking" # Agentas atsako
    INTERRUPTED = "interrupted"       # Vyksta pertraukimas

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

Svarbiausi punktai

  • VAD (pagal nutylėjimą server_vad) konfigūruojamas session.audio.input.turn_detection
  • semantic_vad segmentuoja pagal prasmę; eagerness valdo jo kantrumą
  • Naudojant VAD, serveris atšaukia pertrauktą atsakymą; „WebSocket“ atveju sustabdyk grojimą ir sutrumpink naudodamas conversation.item.truncate („WebRTC“ ir „SIP“ tai vyksta automatiškai)
  • Rankinis režimas (turn_detection nustatytas į None) tinka „spausk ir kalbėk“, IVR meniu ir diktavimui
  • Aiški būsenos mašina apsaugo nuo nenuoselaus elgesio kraštutiniais atvejais