Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Afbrydelser og turstyring

Lektion 5 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. Afbrydelser og turstyring
  2. Taleaktivitetsdetektion (VAD)
  3. Håndtering af afbrydelser
  4. Manuel kontroltilstand
  5. Arkitektur for tilstandsstyring
  6. Vigtige pointer

Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts ophører med at fungere den 6. januar 2027 (erstatning: gpt-realtime-2.1-mini, som OpenAI TTS-guiden angiver ikke understøttes af /v1/audio/speech: migrationen af talesyntese flyttes til Realtime API); gpt-realtime, gpt-4o-realtime og ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations den 26. februar 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.

Rettet 3. november 2026. session.update-begivenheder placerede tidligere turn_detection ved sessions-roden, hvilket er et format fra den gamle beta-version: Med den nuværende Realtime API lever indstillingen i session.audio.input.turn_detection, og sessionen bærer "type": "realtime". Håndtering af afbrydelser sendte tidligere response.cancel, men med VAD annullerer serveren selv svaret, og koden brugte en udefineret variabel. Denne lektion dækker nu semantic_vad, create_response og interrupt_response og skelner mellem WebSocket og WebRTC. Begivenhedsstrukturer er verificeret mod openai SDK-typer 3.42.1. Kilder: Voice activity detection · Realtime conversations.

Afbrydelser og turstyring

I naturlig samtale afbryder folk hinanden, taler i munden på hinanden og skærer hinanden over. En taleagent, der ikke kan håndtere disse situationer, vil føles robotagtig og frustrerende. Realtime API tilbyder to mekanismer til styring af turtagning: automatisk taleaktivitetsdetektion (VAD) og manuel kontrol.

Taleaktivitetsdetektion (VAD)

VAD er aktiveret som standard i en talesession og kører i server_vad-tilstand: Serveren analyserer løbende indkommende lyd, segmenterer baseret på stilhed og signalerer start og slut på brugerens tale. Du konfigurerer 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,      # svar straks, når turen slutter
                    "interrupt_response": True,   # afbryd agenten, hvis brugeren taler
                }
            }
        },
    },
}))

VAD-parametre

Parameter Beskrivelse Påvirkning
threshold Detektionstærskel (0,0 til 1,0) Høj = mindre følsom, Lav = mere følsom
prefix_padding_ms Lyd beholdt før detektion Forhindrer afskæring af starten på ord
silence_duration_ms Stilhedsvarighed krævet for at afslutte tur Kort = responsiv, Lang = tålmodig

En silence_duration_ms, der er for kort, vil udløse et svar under naturlige pauser i brugerens tale; er den for lang, vil agenten virke ureagerende. OpenAI offentliggør ikke sprogspecifikke standardværdier: start med dokumentationseksemplet (500 ms) og juster baseret på optagelser af dine brugere. En højere threshold kræver højere lyd for at udløse, hvilket hjælper i støjende omgivelser.

Semantisk VAD

Den anden tilstand, semantic_vad, stole ikke på stilhed, men på ord: En klassifikator estimerer, om brugeren har afsluttet sin sætning. En sætning, der hænger i luften, køber mere tid end en klar udtalelse, og modellen afbryder mindre ofte. Dens eagerness-indstilling kan være low (lad brugeren tage sig tid), medium, high (svar så hurtigt som muligt) eller auto, som er standardværdien og svarer til medium:

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

Håndtering af afbrydelser

Når brugeren taler, mens agenten svarer, udsender serveren input_audio_buffer.speech_started. Med VAD og interrupt_response aktiveret annullerer serveren det aktuelle svar: Den sender derefter response.done med statussen cancelled. Du skal stadig gøre to ting på din side på en WebSocket-forbindelse, hvor du afspiller lyden:

  1. Stop afspilningen øjeblikkeligt og kassér al lyd i køen, mens du noterer, hvor mange millisekunder brugeren faktisk hørte.
  2. Afkort agentens element til den varighed ved hjælp af conversation.item.truncate.

Vent ikke på response.done for at gøre nogen af delene.

async def handle_interruption(ws, event: dict, player, item_id: str | None, ms_played: int) -> None:
    """Håndterer brugertale, mens agenten taler (WebSocket)."""
    if event["type"] != "input_audio_buffer.speech_started":
        return

    # 1. Stop afspilning og ryd bufferen for lyd i køen
    player.stop_stream()

    # 2. Fjern den del, brugeren ikke hørte, fra historikken
    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. Genåbn afspilning til næste svar
    player.start_stream()

Beregn ms_played baseret på det, du faktisk sendte til højttaleren: I 16-bit mono PCM ved 24 kHz svarer 48.000 bytes til ét sekund. I WebRTC eller SIP administrerer serveren selv output-bufferen, ved hvad der er blevet afspillet og afkorter automatisk: Du behøver ikke sende noget.

Hvorfor afkorte svaret?

Uden afkortning ville samtalehistorikken indeholde modellens fulde svar, selvom brugeren kun hørte en del af det. Hvis brugeren spørger: „Hvad var det sidste, du sagde?”, ville modellen tro, den havde sagt det hele. Afkortning bringer historikken i overensstemmelse med det, brugeren faktisk hørte. Dokumentationen nævner en begrænsning: Afkortning skærer lyden over og fjerner transskriptionen af den del, der ikke blev afspillet, men den giver ikke en ord-for-ord afkortet transskription.

Manuel kontroltilstand

I visse brugstilfælde (IVR-menuer, diktering, quizzer) er automatisk VAD ikke velegnet. Manuel tilstand giver dig fuld kontrol:

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

# Knap trykket: Hvis agenten stadig taler, annuller dens svar og afkort ikke-afspillet lyd
await ws.send(json.dumps({"type": "response.cancel"}))

# Knap sluppet: Lyd blev sendt via input_audio_buffer.append, commit turen...
await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))

# ...udløs derefter svaret
await ws.send(json.dumps({"type": "response.create"}))

Uden VAD sker intet automatisk: Her kommer response.cancel ind i billedet, når et svar er i gang, mens brugeren overtager kontrollen. Mellem ture tømmer input_audio_buffer.clear input-bufferen.

Der findes en mellemvej: Hold VAD aktiveret, så den fortsætter med at segmentere ture og udsende begivenheder, men sæt create_response og interrupt_response til False. Intet svar sendes uden din eksplicitte response.create, hvilket giver dig tid til at verificere eller berige inputtet (moderation, henting af dokumenter) på bekostning af noget latens.

Brugstilfælde for manuel tilstand

  • IVR-menu: Vent på en DTMF-tone eller et specifikt nøgleord før svar
  • Diktering: Akkumuler lange lydsegmenter uden afbrydelse
  • Bekræftelse: Vent på et eksplicit „ja” eller „nej”
  • Tryk-for-at-tale: Brugeren trykker på en knap for at tale

Arkitektur for tilstandsstyring

For robust turstyring skal du vedligeholde en tilstandsmaskine:

from enum import Enum

class ConversationState(Enum):
    IDLE = "idle"                    # Venter
    USER_SPEAKING = "user_speaking"  # Brugeren taler
    PROCESSING = "processing"        # Modellen behandler
    AGENT_SPEAKING = "agent_speaking" # Agenten svarer
    INTERRUPTED = "interrupted"       # Afbrydelse i gang

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

Vigtige pointer

  • VAD (server_vad som standard) konfigureres i session.audio.input.turn_detection
  • semantic_vad segmenterer baseret på betydning; eagerness styrer dens tålmodighed
  • Med VAD annullerer serveren det afbrudte svar; på WebSocket skal du stoppe afspilningen og afkorte med conversation.item.truncate (automatisk i WebRTC og SIP)
  • Manuel tilstand (turn_detection sat til None) passer til tryk-for-at-tale, IVR-menuer og diktering
  • En eksplicit tilstandsmaskine forhindrer inkonsistent adfærd i kanttilfælde