Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Funkciju izsaukšana reāllaikā

Nodarbība 4 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. Funkciju izsaukšana reāllaikā
  2. Rīku deklarēšana sesijā
  3. Funkciju izsaukšanas plūsma
  4. Funkciju apstrādātāja implementēšana
  5. Integrēšana notikumu ciklā
  6. Galvenās atziņas

Atjauninājums: 2026. gada 2. novembris — Audio modeļi. Vairāki šī kursa modeļi tiek atzīti par novecojušiem: tts-1, tts-1-hd un gpt-4o-mini-tts pārtrauks darboties 2027. gada 6. janvārī (norādītais aizstājējs ir gpt-realtime-2.1-mini, ko OpenAI TTS rokasgrāmata definē kā ** neatbalstītu ar /v1/audio/speech**: runas sintēzes migrācija pāriet uz Realtime API); gpt-realtime, gpt-4o-realtime un vecie audio modeļi — 2027. gada 20. janvārī (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe un /v1/audio/translations — 2027. gada 26. februārī (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pilndupleksa balss komunikācijai GPT-Live 1 ir pieejams API kopš 2026. gada 10. septembra.

Funkciju izsaukšana reāllaikā

Funkciju izsaukšana Realtime API ļauj tavam balss aģentam sarunas laikā veikt konkrētas darbības: vaicāt datubāzi, veikt pasūtījumu vai pārbaudīt statusu. Mehānisms ir līdzīgs Responses API, taču pielāgots WebSocket notikumu plūsmai.

Rīku deklarēšana sesijā

Rīkus tu deklarē session.update ziņojumā, tieši tāpat kā instrukcijas un balsi. Katrs rīks ir JSON shēma, kas apraksta tā parametrus:

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

Funkciju izsaukšanas plūsma

Kad modelis nolemj izsaukt rīku, notikumu secība ir šāda:

1

response.function_call_arguments.delta

Funkcijas argumenti pienāk straumējoties, pa daļām.

2

response.function_call_arguments.done

Argumenti ir pilnībā saņemti. Tagad vari izpildīt funkciju.

3

conversation.item.create (tu)

Tu nosūti funkcijas rezultātu atpakaļ modelim.

4

response.create (tu)

Tu lūdz modelim turpināt atbildi, iekļaujot iegūto rezultātu.

Funkciju apstrādātāja implementēšana

Lūk, pilns piemērs, kā apstrādāt funkciju izsaukumus:

import json

# Pieejamo funkciju reģistrs
async def get_weather(city: str, unit: str = "celsius") -> dict:
    # Izsauc patiesu laika apstākļu API
    return {"city": city, "temperature": 22, "unit": unit, "condition": "sunny"}

async def book_appointment(date: str, time: str, service: str) -> dict:
    # Pieraksta loģika
    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):
    """Apstrādā funkcijas izsaukumu un atgriež rezultātu."""
    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})")

        # Izpilda funkciju
        func = FUNCTION_REGISTRY.get(func_name)
        if func:
            result = await func(**arguments)
        else:
            result = {"error": f"Unknown function: {func_name}"}

        # Nosūta rezultātu atpakaļ modelim
        await ws.send(json.dumps({
            "type": "conversation.item.create",
            "item": {
                "type": "function_call_output",
                "call_id": call_id,
                "output": json.dumps(result)
            }
        }))

    # Lūdz modelim turpināt ar rezultātu
    await ws.send(json.dumps({
        "type": "response.create"
    }))

Integrēšana notikumu ciklā

Funkciju apstrādātājs tiek integrēts tavā galvenajā ciklā:

async def event_loop(ws):
    """Galvenais notikumu apstrādes cikls."""
    async for raw_message in ws:
        event = json.loads(raw_message)
        event_type = event["type"]

        if event_type == "response.done":
            response = event["response"]
            # Pārbauda, vai modelis ir izsaujis kādas funkcijas
            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":
            # Atskaņo atbildes audio
            audio_bytes = base64.b64decode(event["delta"])
            player.write(audio_bytes)

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

Vairāki funkciju izsaukumi

Modelis vienā atbildē var nolemt izsaukt vairākas funkcijas. Lauks output ziņojumā response.done var saturēt vairākus ierakstus ar tipu function_call. Apstrādā tos visus, pirms izsauc response.create.

Galvenās atziņas

  • Rīki tiek deklarēti session.update, izmantojot standarta JSON shēmu
  • Argumenti pienāk straumējoties caur response.function_call_arguments.delta
  • Pēc izpildes nosūti rezultātu atpakaļ, izmantojot conversation.item.create kopā ar call_id
  • Izsauc response.create, lai modelis varētu formulēt savu balss atbildi, iekļaujot rezultātu
  • Apstrādā vairākus izsaukumus: modelis var izsaukt vairākas funkcijas vienlaicīgi