Apelarea de funcții în timp real
Pe această pagină
Actualizare 2 noiembrie 2026 — Modele audio. Mai multe modele din acest curs sunt depreciate:
tts-1,tts-1-hdșigpt-4o-mini-ttsvor înceta să funcționeze pe 6 ianuarie 2027 (înlocuitorul indicat estegpt-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/translationspe 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:
response.function_call_arguments.delta
Argumentele funcției sosesc prin streaming, bucată cu bucată.
response.function_call_arguments.done
Argumentele sunt complete. Puteți executa acum funcția.
conversation.item.create (dumneavoastră)
Trimiteți rezultatul funcției înapoi la model.
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.updatefolosind o schemă JSON standard - Argumentele sosesc prin streaming prin
response.function_call_arguments.delta - După execuție, trimiteți rezultatul înapoi prin
conversation.item.createcucall_id - Apelați
response.createpentru ca modelul să își formuleze răspunsul vocal cu rezultatul - Gestionați apelurile multiple: modelul poate apela mai multe funcții simultan