Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Avbrott och turhantering

Lektion 5 av 18 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Avbrott och turhantering
  2. Röstaktivitetsdetektering (VAD)
  3. Hantering av avbrott
  4. Manuellt kontrolläge
  5. Arkitektur för tillståndshantering
  6. Viktiga punkter

Uppdaterad 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade: tts-1, tts-1-hd och gpt-4o-mini-tts slutar 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-realtime och äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe och /v1/audio/translations den 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 tidigare turn_detection vid sessionsroten, ett format från den gamla betaversionen: med det nuvarande Realtime API:t finns inställningen i session.audio.input.turn_detection, och sessionen bär "type": "realtime". Hantering av avbrott skickade tidigare response.cancel, men med VAD avbryter servern svaret själv, och koden använde en odefinierad variabel. Denna lektion täcker nu semantic_vad, create_response och interrupt_response, och skiljer mellan WebSocket och WebRTC. Händelsestrukturer verifierade mot openai SDK-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:

  1. Stoppa uppspelningen omedelbart och kassera allt köat ljud, och notera hur många millisekunder användaren faktiskt hörde
  2. 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_vad som standard) konfigureras i session.audio.input.turn_detection
  • semantic_vad segmenterar baserat på betydelse; eagerness styr 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_detection satt till None) passar tryck-och-prata, IVR-menyer och diktering
  • En explicit tillståndsmaskin förhindrar inkonsekvent beteende i kantfall