Întreruperi și gestionarea tururilor de vorbire
Pe această pagină
Actualizat pe 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate:
tts-1,tts-1-hdșigpt-4o-mini-ttsvor înceta să funcționeze la 6 ianuarie 2027 (înlocuitor:gpt-realtime-2.1-mini, pe care ghidul OpenAI TTS precizează că nu este suportat de/v1/audio/speech: migrarea sintezei vocale se mută în Realtime API);gpt-realtime,gpt-4o-realtimeși modelele audio legacy la 20 ianuarie 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeși/v1/audio/translationsla 26 februarie 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Pentru voce full-duplex, GPT-Live 1 este disponibil în API din 10 septembrie 2026.
Corectat pe 3 noiembrie 2026. Evenimentele
session.updateplasau anteriorturn_detectionla rădăcina sesiunii, un format din vechea versiune beta: cu actualul Realtime API, setarea se află însession.audio.input.turn_detection, iar sesiunea conține"type": "realtime". Gestionarea întreruperilor trimitea anteriorresponse.cancel, dar cu VAD serverul anulează singur răspunsul, iar codul folosea o variabilă nedefinită. Această lecție acoperă acumsemantic_vad,create_responseșiinterrupt_response, și face distincția între WebSocket și WebRTC. Formele evenimentelor verificate față de tipurile SDKopenai3.42.1. Surse: Detectarea activității vocale · Conversații în timp real.
Întreruperi și gestionarea tururilor de vorbire
În conversațiile naturale, oamenii se întrerup reciproc, vorbesc simultan și se opresc brusc. Un agent vocal care nu poate gestiona aceste situații va părea robotic și frustrant. Realtime API oferă două mecanisme pentru gestionarea preluării cuvântului: Detectarea Automată a Activității Vocale (VAD) și controlul manual.
Detectarea Activității Vocale (VAD)
VAD este activat implicit într-o sesiune de conversație vocală, operând în modul server_vad: serverul analizează continuu audio-ul primit, segmentează pe baza tăcerii și semnalează începutul și sfârșitul vorbirii utilizatorului. Îl configurați în 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, # răspunde imediat când se termină turul
"interrupt_response": True, # întrerupe agentul dacă utilizatorul vorbește
}
}
},
},
}))
Parametrii VAD
| Parametru | Descriere | Impact |
|---|---|---|
| threshold | Prag de detectare (0.0 până la 1.0) | Ridicat = mai puțin sensibil, Scăzut = mai sensibil |
| prefix_padding_ms | Audio păstrat înainte de detectare | Previne tăierea începutului cuvintelor |
| silence_duration_ms | Durata de tăcere necesară pentru a încheia turul | Scurt = reactiv, Lung = pacient |
Un silence_duration_ms prea scurt va declanșa un răspuns în timpul pauzelor naturale din vorbirea utilizatorului; prea lung, iar agentul va părea lipsit de reacție. OpenAI nu publică valori implicite specifice limbii: începeți cu exemplul din documentație (500 ms) și ajustați pe baza înregistrărilor utilizatorilor dumneavoastră. Un threshold mai ridicat necesită un sunet mai puternic pentru a se declanșa, ceea ce ajută în medii zgomotoase.
Semantic VAD
Al doilea mod, semantic_vad, nu se bazează pe tăcere, ci pe cuvinte: un clasificator estimează dacă utilizatorul și-a terminat propoziția. O propoziție lăsată în suspans câștigă mai mult timp decât o afirmație clară, iar modelul întrerupe mai rar. Setarea sa eagerness poate fi low (lăsați utilizatorul să ia timpul necesar), medium, high (răspundeți cât mai repede posibil) sau auto, valoarea implicită, care este echivalentă cu medium:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"audio": {"input": {"turn_detection": {"type": "semantic_vad", "eagerness": "low"}}},
},
}))
Gestionarea întreruperilor
Când utilizatorul vorbește în timp ce agentul răspunde, serverul emite input_audio_buffer.speech_started. Cu VAD și interrupt_response activate, serverul anulează răspunsul curent: apoi trimite response.done cu statusul cancelled. Totuși, trebuie să faceți două lucruri din partea dumneavoastră, pe o conexiune WebSocket unde redați audio-ul:
- Opriți redarea imediat și eliminați orice audio aflat în coadă, notând câte milisecunde a auzit efectiv utilizatorul.
- Trunchiați elementul agentului la acea durată folosind
conversation.item.truncate.
Nu așteptați response.done pentru a face niciunul dintre aceste lucruri.
async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
"""Gestionează vorbirea utilizatorului în timp ce agentul vorbește (WebSocket)."""
if event["type"] != "input_audio_buffer.speech_started":
return
# 1. Oprește redarea și golește buffer-ul de audio din coadă
player.stop_stream()
# 2. Elimină din istoric partea pe care utilizatorul nu a auzit-o
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. Deschide din nou redarea pentru următorul răspuns
player.start_stream()
Calculați ms_played pe baza a ceea ce ați trimis efectiv difuzorului: în PCM mono pe 16 biți la 24 kHz, 48.000 de octeți egalau o secundă. În WebRTC sau SIP, serverul gestionează singur buffer-ul de ieșire, știe ce s-a redat și trunchiază automat: nu trebuie să trimiteți nimic.
De ce să trunchiați răspunsul?
Fără trunchiere, istoricul conversației ar conține răspunsul complet al modelului, chiar dacă utilizatorul a auzit doar o parte din el. Dacă utilizatorul întreabă „Ce ai spus ultima dată?“, modelul ar crede că le-a spus pe toate. Trunchierea aliniază istoricul cu ceea ce a auzit efectiv utilizatorul. Documentația notează o limitare: trunchierea taie audio-ul și elimină transcripția porțiunii neredate, dar nu oferă o transcripție trunchiată cuvânt cu cuvânt.
Modul de control manual
Pentru anumite cazuri de utilizare (meniuri IVR, dictare, quiz-uri), VAD automat nu este potrivit. Modul manual vă oferă control total:
# Dezactivează VAD
await ws.send(json.dumps({
"type": "session.update",
"session": {"type": "realtime", "audio": {"input": {"turn_detection": None}}},
}))
# Buton apăsat: dacă agentul vorbește încă, anulează-i răspunsul și trunchiază audio-ul neredat
await ws.send(json.dumps({"type": "response.cancel"}))
# Buton eliberat: audio-ul a fost trimis prin input_audio_buffer.append, confirmă turul...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
# ...apoi declanșează răspunsul
await ws.send(json.dumps({"type": "response.create"}))
Fără VAD, nimic nu este automat: aici intervine response.cancel, când un răspuns este în curs de desfășurare în timp ce utilizatorul preia controlul. Între tururi, input_audio_buffer.clear golește buffer-ul de intrare.
Există o soluție de compromis: mențineți VAD activat astfel încât să continue să segmenteze tururile și să emită evenimente, dar setați create_response și interrupt_response pe False. Niciun răspuns nu este trimis fără response.create explicit din partea dumneavoastră, oferindu-vă timp să verificați sau să îmbogățiți intrarea (moderare, recuperare de documente), cu costul unei anumite latențe.
Cazuri de utilizare pentru modul manual
- Meniu IVR: Așteptați un ton DTMF sau un cuvânt cheie specific înainte de a răspunde.
- Dictare: Acumulați segmente lungi de audio fără întrerupere.
- Confirmare: Așteptați un „da“ sau „nu“ explicit.
- Apasă-pentru-a-vorbi: Utilizatorul apasă un buton pentru a vorbi.
Arhitectura gestionării stării
Pentru o gestionare robustă a tururilor de vorbire, mențineți o mașină de stări:
from enum import Enum
class ConversationState(Enum):
IDLE = "idle" # În așteptare
USER_SPEAKING = "user_speaking" # Utilizatorul vorbește
PROCESSING = "processing" # Modelul procesează
AGENT_SPEAKING = "agent_speaking" # Agentul răspunde
INTERRUPTED = "interrupted" # Întrerupere în curs
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
Puncte cheie
- VAD (
server_vadimplicit) este configurat însession.audio.input.turn_detection semantic_vadsegmentează pe baza sensului;eagernesscontrolează răbdarea sa- Cu VAD, serverul anulează răspunsul întrerupt; pe WebSocket, opriți redarea și trunchiați cu
conversation.item.truncate(automat în WebRTC și SIP) - Modul manual (
turn_detectionsetat peNone) se potrivește pentru push-to-talk, meniuri IVR și dictare - O mașină de stări explicită previne comportamentele inconsistente în cazurile limită