Salt la conținutul principal
Română— Alege o limbă
Meniu

Apelarea de funcții în timp real

Lecția 4 din 18 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Apelarea de funcții în timp real
  2. Declararea instrumentelor în sesiune
  3. Fluxul apelului de funcție
  4. Implementarea gestionarului de funcții
  5. Integrarea în bucla de evenimente
  6. Puncte cheie

Actualizare 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate: tts-1, tts-1-hd și gpt-4o-mini-tts vor înceta să funcționeze pe 6 ianuarie 2027 (înlocuitorul indicat este gpt-realtime-2.1-mini, pe care ghidul OpenAI TTS precizează că nu este suportat de /v1/audio/speech: migrarea sintezei vocale se mută în Realtime API); gpt-realtime, gpt-4o-realtime și modelele audio legacy pe 20 ianuarie 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe și /v1/audio/translations pe 26 februarie 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pentru voce full-duplex, GPT-Live 1 este disponibil în API din 10 septembrie 2026.

Apelarea de funcții în timp real

Apelarea de funcții în Realtime API permite agentului vocal să execute acțiuni concrete în timpul unei conversații: interogarea unei baze de date, plasarea unei comenzi sau verificarea unui statut. Mecanismele sunt similare cu cele din Responses API, dar adaptate pentru fluxul de evenimente WebSocket.

Declararea instrumentelor în sesiune

Declarați instrumentele în session.update, exact ca instrucțiunile și vocea. Fiecare instrument este o schemă JSON care descrie parametrii săi:

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

Fluxul apelului de funcție

Când modelul decide să apeleze un instrument, secvența de evenimente este următoarea:

1

response.function_call_arguments.delta

Argumentele funcției sosesc prin streaming, bucată cu bucată.

2

response.function_call_arguments.done

Argumentele sunt complete. Puteți executa acum funcția.

3

conversation.item.create (dumneavoastră)

Trimiteți rezultatul funcției înapoi la model.

4

response.create (dumneavoastră)

Solicitați modelului să își continue răspunsul cu rezultatul obținut.

Implementarea gestionarului de funcții

Iată un exemplu complet de gestionare a apelurilor de funcții:

import json

# Registry of available functions
async def get_weather(city: str, unit: str = "celsius") -> dict:
    # Call a real weather API
    return {"city": city, "temperature": 22, "unit": unit, "condition": "sunny"}

async def book_appointment(date: str, time: str, service: str) -> dict:
    # Booking logic
    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):
    """Processes a function call and returns the result."""
    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})")

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

        # Send the result back to the model
        await ws.send(json.dumps({
            "type": "conversation.item.create",
            "item": {
                "type": "function_call_output",
                "call_id": call_id,
                "output": json.dumps(result)
            }
        }))

    # Ask the model to continue with the result
    await ws.send(json.dumps({
        "type": "response.create"
    }))

Integrarea în bucla de evenimente

Gestionarul de funcții se integrează în bucla principală:

async def event_loop(ws):
    """Main event processing loop."""
    async for raw_message in ws:
        event = json.loads(raw_message)
        event_type = event["type"]

        if event_type == "response.done":
            response = event["response"]
            # Check if the model called any functions
            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":
            # Play response audio
            audio_bytes = base64.b64decode(event["delta"])
            player.write(audio_bytes)

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

Apeluri multiple de funcții

Modelul poate decide să apeleze mai multe funcții într-un singur răspuns. Câmpul output din response.done poate conține mai multe intrări de tip function_call. Procesați-le pe toate înainte de a apela response.create.

Puncte cheie

  • Instrumentele sunt declarate în session.update folosind o schemă JSON standard
  • Argumentele sosesc prin streaming prin response.function_call_arguments.delta
  • După execuție, trimiteți rezultatul înapoi prin conversation.item.create cu call_id
  • Apelați response.create pentru ca modelul să își formuleze răspunsul vocal cu rezultatul
  • Gestionați apelurile multiple: modelul poate apela mai multe funcții simultan