Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Funktsioonide reaalajas kutsumine

Õppetund 4 / 18 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Funktsioonide reaalajas kutsumine
  2. Tööriistade deklareerimine sessioonis
  3. Funktsiooni kutsumise voog
  4. Funktsiooni käsitleja rakendamine
  5. Integreerimine sündmuste tsüklisse
  6. Peamised punktid

Uuendus 2. novembril 2026 – Helimudelid. Selles kursuses on mitu mudelit aegunud: tts-1, tts-1-hd ja gpt-4o-mini-tts lõpetavad töö 6. jaanuaril 2027 (asendajaks on gpt-realtime-2.1-mini, mida OpenAI TTS juhend kirjeldab kui mittetoetatud teenuse /v1/audio/speech poolt: kõnesünteesi migratsioon viiakse üle Realtime API-le); gpt-realtime, gpt-4o-realtime ja vanad helimudelid lõpetavad töö 20. jaanuaril 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ja /v1/audio/translations lõpetavad töö 26. veebruaril 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Täisdupleksse heli jaoks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026.

Funktsioonide reaalajas kutsumine

Funktsioonide kutsumine Realtime API võimaldab su hääleagendil vestluse käigus konkreetseid tegevusi sooritada: pärida andmebaasi, esitada tellimus või kontrollida staatust. Mehhanism sarnaneb Responses API-ga, kuid on kohandatud WebSocketi sündmuste voogu.

Tööriistade deklareerimine sessioonis

Deklareerid tööriistad session.update päringus, täpselt nagu juhiseid ja häält. Iga tööriist on JSON skeem, mis kirjeldab selle parameetreid:

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"
    }
}))

Funktsiooni kutsumise voog

Kui mudel otsustab tööriista kutsuda, järgneb sündmuste jada:

1

response.function_call_arguments.delta

Funktsiooni argumendid saabuvad voogedastusena, tükkhaaval.

2

response.function_call_arguments.done

Argumendid on täielikud. Nüüd saad funktsiooni käivitada.

3

conversation.item.create (sina)

Saadad funktsiooni tulemuse mudelile tagasi.

4

response.create (sina)

Palud mudelil jätkata vastuse koostamist, kasutades saadud tulemust.

Funktsiooni käsitleja rakendamine

Siin on täielik näide funktsioonikutsude käsitlemisest:

import json

# Saadaval olevate funktsioonide register
async def get_weather(city: str, unit: str = "celsius") -> dict:
    # Kutsu tegelikku ilmateenuse API-t
    return {"city": city, "temperature": 22, "unit": unit, "condition": "sunny"}

async def book_appointment(date: str, time: str, service: str) -> dict:
    # Broneerimise loogika
    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):
    """Töötleb funktsioonikutse ja tagastab tulemuse."""
    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})")

        # Käivita funktsioon
        func = FUNCTION_REGISTRY.get(func_name)
        if func:
            result = await func(**arguments)
        else:
            result = {"error": f"Unknown function: {func_name}"}

        # Saada tulemus mudelile tagasi
        await ws.send(json.dumps({
            "type": "conversation.item.create",
            "item": {
                "type": "function_call_output",
                "call_id": call_id,
                "output": json.dumps(result)
            }
        }))

    # Palu mudelil tulemusega jätkata
    await ws.send(json.dumps({
        "type": "response.create"
    }))

Integreerimine sündmuste tsüklisse

Funktsiooni käsitleja integreeritakse sinu peatsüklisse:

async def event_loop(ws):
    """Peamine sündmuste töötlemise tsükkel."""
    async for raw_message in ws:
        event = json.loads(raw_message)
        event_type = event["type"]

        if event_type == "response.done":
            response = event["response"]
            # Kontrolli, kas mudel kutsus mõnda funktsiooni
            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":
            # Esita vastuse heli
            audio_bytes = base64.b64decode(event["delta"])
            player.write(audio_bytes)

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

Mitu funktsioonikutset korraga

Mudel võib otsustada ühe vastuse raames kutsuda mitut funktsiooni. response.done väli output võib sisaldada mitut kirjet tüübiga function_call. Töötle need kõik enne, kui kutsumad response.create.

Peamised punktid

  • Tööriistad deklareeritakse session.update kasutades standardset JSON skeemi
  • Argumendid saabuvad voogedastusena läbi response.function_call_arguments.delta
  • Pärast käivitamist saada tulemus tagasi kasutades conversation.item.create koos call_id-ga
  • Kutsu response.create, et mudel saaks tulemuse põhjal vormistada oma häälvastuse
  • Käitle mitut kutset korraga: mudel võib korraga kutsuda mitut funktsiooni