Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Functieaanroepen in realtime

Les 4 van 18 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Functieaanroepen in realtime
  2. Tools declareren in de sessie
  3. De flow van een functieaanroep
  4. De functiehandler implementeren
  5. Integratie in de eventloop
  6. Belangrijkste punten

Update 2 november 2026 — Audiomodellen. Verschillende modellen in deze cursus zijn verouderd: tts-1, tts-1-hd en gpt-4o-mini-tts stoppen op 6 januari 2027 (de aangegeven vervanger is gpt-realtime-2.1-mini, waarvan de OpenAI TTS-gids stelt dat deze niet wordt ondersteund door /v1/audio/speech: migratie van spraaksynthese gaat naar de Realtime API); gpt-realtime, gpt-4o-realtime en legacy audiomodellen op 20 januari 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe en /v1/audio/translations op 26 februari 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Voor full-duplex spraak is GPT-Live 1 beschikbaar in de API sinds 10 september 2026.

Functieaanroepen in realtime

Functieaanroepen in de Realtime API stellen uw stemagent in staat concrete acties uit te voeren tijdens een gesprek: een database bevragen, een bestelling plaatsen of een status controleren. De werking lijkt op die van de Responses API, maar is aangepast voor de WebSocket-eventstream.

Tools declareren in de sessie

U declareert tools in session.update, precies zoals instructies en stem. Elke tool is een JSON-schema dat de parameters beschrijft:

tools = [
    {
        "type": "function",
        "name": "get_weather",
        "description": "Get the current weather for a given city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Name of the city"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperature unit"
                }
            },
            "required": ["city"]
        }
    },
    {
        "type": "function",
        "name": "book_appointment",
        "description": "Book an appointment",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {"type": "string", "description": "Date in YYYY-MM-DD format"},
                "time": {"type": "string", "description": "Time in HH:MM format"},
                "service": {"type": "string", "description": "Type of service"}
            },
            "required": ["date", "time", "service"]
        }
    }
]

await ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "type": "realtime",
        "output_modalities": ["audio"],
        "instructions": "You are a voice assistant. Use the available tools.",
        "audio": {"output": {"voice": "marin"}},
        "tools": tools,
        "tool_choice": "auto"
    }
}))

De flow van een functieaanroep

Wanneer het model besluit een tool aan te roepen, verloopt de eventsequentie als volgt:

1

response.function_call_arguments.delta

Functieargumenten komen binnen via streaming, chunk voor chunk.

2

response.function_call_arguments.done

De argumenten zijn compleet. U kunt de functie nu uitvoeren.

3

conversation.item.create (u)

U stuurt het functieresultaat terug naar het model.

4

response.create (u)

U vraagt het model om zijn antwoord met het resultaat voort te zetten.

De functiehandler implementeren

Hier volgt een compleet voorbeeld van het afhandelen van functieaanroepen:

import json

# Register van beschikbare functies
async def get_weather(city: str, unit: str = "celsius") -> dict:
    # Roep een echte weer-API aan
    return {"city": city, "temperature": 22, "unit": unit, "condition": "sunny"}

async def book_appointment(date: str, time: str, service: str) -> dict:
    # Boekingslogica
    return {"confirmed": True, "date": date, "time": time, "reference": "RDV-2026-0042"}

FUNCTION_REGISTRY = {
    "get_weather": get_weather,
    "book_appointment": book_appointment,
}

async def handle_function_call(ws, event):
    """Verwerkt een functieaanroep en retourneert het resultaat."""
    response = event["response"]

    for output in response.get("output", []):
        if output["type"] != "function_call":
            continue

        func_name = output["name"]
        call_id = output["call_id"]
        arguments = json.loads(output["arguments"])

        print(f"Calling function: {func_name}({arguments})")

        # Voer de functie uit
        func = FUNCTION_REGISTRY.get(func_name)
        if func:
            result = await func(**arguments)
        else:
            result = {"error": f"Unknown function: {func_name}"}

        # Stuur het resultaat terug naar het model
        await ws.send(json.dumps({
            "type": "conversation.item.create",
            "item": {
                "type": "function_call_output",
                "call_id": call_id,
                "output": json.dumps(result)
            }
        }))

    # Vraag het model om verder te gaan met het resultaat
    await ws.send(json.dumps({
        "type": "response.create"
    }))

Integratie in de eventloop

De functiehandler integreert u in uw hoofdloop:

async def event_loop(ws):
    """Hoofdloop voor eventverwerking."""
    async for raw_message in ws:
        event = json.loads(raw_message)
        event_type = event["type"]

        if event_type == "response.done":
            response = event["response"]
            # Controleer of het model functies heeft aangeroepen
            has_function_calls = any(
                o["type"] == "function_call"
                for o in response.get("output", [])
            )
            if has_function_calls:
                await handle_function_call(ws, event)

        elif event_type == "response.output_audio.delta":
            # Speel responsaudio af
            audio_bytes = base64.b64decode(event["delta"])
            player.write(audio_bytes)

        elif event_type == "error":
            print(f"Error: {event['error']['message']}")

Meerdere functieaanroepen

Het model kan beslissen meerdere functies in één antwoord aan te roepen. Het veld output van response.done kan meerdere items van het type function_call bevatten. Verwerk ze allemaal voordat u response.create aanroept.

Belangrijkste punten

  • Tools declareert u in session.update met een standaard JSON-schema
  • Argumenten komen binnen via streaming door middel van response.function_call_arguments.delta
  • Na uitvoering stuurt u het resultaat terug via conversation.item.create met de call_id
  • Roep response.create aan zodat het model zijn spraakantwoord met het resultaat kan formuleren
  • Handel meerdere aanroepen af: het model kan meerdere functies tegelijk aanroepen