Avbrott och turhantering
På denna sida
Uppdaterad 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade:
tts-1,tts-1-hdochgpt-4o-mini-ttsslutar fungera den 6 januari 2027 (ersättning:gpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av/v1/audio/speech: migreringen av talgenerering flyttas till Realtime API);gpt-realtime,gpt-4o-realtimeoch äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoch/v1/audio/translationsden 26 februari 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). För full-duplex-röst har GPT-Live 1 funnits tillgänglig i API:t sedan den 10 september 2026.
Korrigerad 3 november 2026.
session.update-händelser placerade tidigareturn_detectionvid sessionsroten, ett format från den gamla betaversionen: med det nuvarande Realtime API:t finns inställningen isession.audio.input.turn_detection, och sessionen bär"type": "realtime". Hantering av avbrott skickade tidigareresponse.cancel, men med VAD avbryter servern svaret själv, och koden använde en odefinierad variabel. Denna lektion täcker nusemantic_vad,create_responseochinterrupt_response, och skiljer mellan WebSocket och WebRTC. Händelsestrukturer verifierade motopenaiSDK-typer 3.42.1. Källor: Voice activity detection · Realtime conversations.
Avbrott och turhantering
I naturliga samtal avbryter människor varandra, pratar i munnen på varandra och klipper av varandra. En röstagent som inte kan hantera dessa situationer kommer att kännas robotaktig och frustrerande. Realtime API:t tillhandahåller två mekanismer för att hantera turtagning: automatisk röstaktivitetsdetektering (VAD) och manuell kontroll.
Röstaktivitetsdetektering (VAD)
VAD är aktiverat som standard i en röstsamtalssession och arbetar i läget server_vad: servern analyserar kontinuerligt inkommande ljud, segmenterar baserat på tystnad och signalerar start och slut på användarens tal. Du konfigurerar det i 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, # svara direkt när turen slutar
"interrupt_response": True, # klipp av agenten om användaren pratar
}
}
},
},
}))
VAD-parametrar
| Parameter | Beskrivning | Påverkan |
|---|---|---|
| threshold | Detekteringströskel (0,0 till 1,0) | Hög = mindre känslig, Låg = mer känslig |
| prefix_padding_ms | Ljud som behålls före detektering | Förhindrar att början av ord klipps bort |
| silence_duration_ms | Tystnadsduration som krävs för att avsluta tur | Kort = responsivt, Långt = tålmodigt |
En silence_duration_ms som är för kort kommer att utlösa ett svar under naturliga pauser i användarens tal; är den för lång kommer agenten att verka oresponsiv. OpenAI publicerar inga språkspecifika standardvärden: börja med dokumentationsexemplet (500 ms) och justera baserat på inspelningar av dina användare. En högre threshold kräver högre ljudvolym för att utlösas, vilket hjälper i bullriga miljöer.
Semantisk VAD
Det andra läget, semantic_vad, förlitar sig inte på tystnad utan på ord: en klassificator uppskattar om användaren har avslutat sin mening. En mening som lämnas svävande köper mer tid än ett tydligt uttalande, och modellen avbryter mindre ofta. Dess inställning eagerness kan vara low (låt användaren ta sin tid), medium, high (svara så snart som möjligt) eller auto, standardvärdet, vilket motsvarar medium:
await ws.send(json.dumps({
"type": "session.update",
"session": {
"type": "realtime",
"audio": {"input": {"turn_detection": {"type": "semantic_vad", "eagerness": "low"}}},
},
}))
Hantering av avbrott
När användaren pratar medan agenten svarar emitterar servern input_audio_buffer.speech_started. Med VAD och interrupt_response aktiverat avbryter servern det aktuella svaret: den skickar sedan response.done med statusen cancelled. Du behöver fortfarande göra två saker på din sida, på en WebSocket-anslutning där du spelar upp ljudet:
- Stoppa uppspelningen omedelbart och kassera allt köat ljud, och notera hur många millisekunder användaren faktiskt hörde
- Avkorta agentens objekt till den durationen med hjälp av
conversation.item.truncate
Vänta inte på response.done för att göra något av detta.
async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
"""Hanterar användartal medan agenten talar (WebSocket)."""
if event["type"] != "input_audio_buffer.speech_started":
return
# 1. Stoppa uppspelning och töm den köade ljudbufferten
player.stop_stream()
# 2. Ta bort den del användaren inte hörde från historiken
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. Öppna uppspelning igen för nästa svar
player.start_stream()
Beräkna ms_played baserat på vad du faktiskt skickade till högtalaren: i 16-bitars mono PCM vid 24 kHz motsvarar 48 000 byte en sekund. I WebRTC eller SIP hanterar servern utmatningsbufferten själv, vet vad som har spelats upp och avkortar automatiskt: du behöver inte skicka något.
Varför avkorta svaret?
Utan avkortning skulle samtalshistoriken innehålla modellens fullständiga svar, även om användaren bara hörde en del av det. Om användaren frågar: “Vad var det senaste du sa?”, skulle modellen tro att den hade sagt allt. Avkortning synkroniserar historiken med vad användaren faktiskt hörde. Dokumentationen noterar en begränsning: avkortning klipper ljudet och tar bort transkriberingen av den del som inte spelades upp, men den tillhandahåller inte en ord-för-ord avkortad transkribering.
Manuellt kontrolläge
För vissa användningsfall (IVR-menyer, diktering, quiz) är automatisk VAD inte lämplig. Manuellt läge ger dig full kontroll:
# Inaktivera VAD
await ws.send(json.dumps({
"type": "session.update",
"session": {"type": "realtime", "audio": {"input": {"turn_detection": None}}},
}))
# Knapp tryckt: om agenten fortfarande talar, avbryt dess svar och avkorta ospelat ljud
await ws.send(json.dumps({"type": "response.cancel"}))
# Knapp släppt: ljud skickades via input_audio_buffer.append, commit:a turen...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
# ...utlös sedan svaret
await ws.send(json.dumps({"type": "response.create"}))
Utan VAD är inget automatiskt: här kommer response.cancel in i bilden, när ett svar pågår när användaren tar tillbaka kontrollen. Mellan turerna tömmer input_audio_buffer.clear inmatningsbufferten.
En medelväg finns: håll VAD aktiverat så att det fortsätter att segmentera turer och emittera händelser, men sätt create_response och interrupt_response till False. Inget svar skickas utan din explicita response.create, vilket ger dig tid att verifiera eller berika inmatningen (moderering, hämtning av dokument), till priset av viss latens.
Användningsfall för manuellt läge
- IVR-meny: Vänta på en DTMF-ton eller ett specifikt nyckelord innan du svarar
- Diktering: Samla långa ljudsegment utan avbrott
- Bekräftelse: Vänta på ett explicit “ja” eller “nej”
- Tryck-och-prata: Användaren trycker på en knapp för att tala
Arkitektur för tillståndshantering
För robust turhantering, behåll en tillståndsmaskin:
from enum import Enum
class ConversationState(Enum):
IDLE = "idle" # Väntar
USER_SPEAKING = "user_speaking" # Användaren talar
PROCESSING = "processing" # Modellen bearbetar
AGENT_SPEAKING = "agent_speaking" # Agenten svarar
INTERRUPTED = "interrupted" # Avbrott pågår
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
Viktiga punkter
- VAD (
server_vadsom standard) konfigureras isession.audio.input.turn_detection semantic_vadsegmenterar baserat på betydelse;eagernessstyr dess tålmodighet- Med VAD avbryter servern det avbrutna svaret; på WebSocket, stoppa uppspelning och avkorta med
conversation.item.truncate(automatiskt i WebRTC och SIP) - Manuellt läge (
turn_detectionsatt tillNone) passar tryck-och-prata, IVR-menyer och diktering - En explicit tillståndsmaskin förhindrar inkonsekvent beteende i kantfall