Wywoływanie funkcji w czasie rzeczywistym
Na tej stronie
Aktualizacja z 2 listopada 2026 r. — Modele audio. Kilka modeli w tym kursie zostało wycofanych:
tts-1,tts-1-hdorazgpt-4o-mini-ttsprzestaną działać 6 stycznia 2027 r. (zalecanym zamiennikiem jestgpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez/v1/audio/speech: migracja syntezy mowy przechodzi do Realtime API);gpt-realtime,gpt-4o-realtimeoraz starsze modele audio przestaną działać 20 stycznia 2027 r. (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoraz/v1/audio/translationsprzestaną działać 26 lutego 2027 r. (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). W przypadku komunikacji pełnodupleksowej (full-duplex), GPT-Live 1 jest dostępny w API od 10 września 2026 r.
Wywoływanie funkcji w czasie rzeczywistym
Wywoływanie funkcji w Realtime API pozwala Twojemu agentowi głosowemu wykonywać konkretne działania podczas rozmowy: odpytywać bazę danych, składać zamówienie lub sprawdzać status. Mechanika jest podobna do tej w Responses API, ale dostosowana do strumienia zdarzeń WebSocket.
Deklarowanie narzędzi w sesji
Narzędzia deklarujesz w session.update, dokładnie tak samo jak instrukcje i głos. Każde narzędzie to schemat JSON opisujący jego parametry:
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"
}
}))
Przebieg wywołania funkcji
Gdy model zdecyduje się wywołać narzędzie, sekwencja zdarzeń wygląda następująco:
response.function_call_arguments.delta
Argumenty funkcji docierają w strumieniu, fragment po fragmencie.
response.function_call_arguments.done
Argumenty są kompletne. Możesz teraz wykonać funkcję.
conversation.item.create (ty)
Wysyłasz wynik funkcji z powrotem do modelu.
response.create (ty)
Prosisz model o kontynuację odpowiedzi z uwzględnieniem wyniku.
Implementacja obsługi funkcji
Oto kompletny przykład obsługi wywołań funkcji:
import json
# Rejestr dostępnych funkcji
async def get_weather(city: str, unit: str = "celsius") -> dict:
# Wywołanie rzeczywistego API pogodowego
return {"city": city, "temperature": 22, "unit": unit, "condition": "sunny"}
async def book_appointment(date: str, time: str, service: str) -> dict:
# Logika rezerwacji
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):
"""Przetwarza wywołanie funkcji i zwraca wynik."""
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})")
# Wykonanie funkcji
func = FUNCTION_REGISTRY.get(func_name)
if func:
result = await func(**arguments)
else:
result = {"error": f"Unknown function: {func_name}"}
# Wysłanie wyniku z powrotem do modelu
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps(result)
}
}))
# Poproś model o kontynuację z wynikiem
await ws.send(json.dumps({
"type": "response.create"
}))
Integracja z pętlą zdarzeń
Obsługa funkcji integruje się z Twoją główną pętlą:
async def event_loop(ws):
"""Główna pętla przetwarzania zdarzeń."""
async for raw_message in ws:
event = json.loads(raw_message)
event_type = event["type"]
if event_type == "response.done":
response = event["response"]
# Sprawdź, czy model wywołał jakieś funkcje
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":
# Odtwórz audio odpowiedzi
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event_type == "error":
print(f"Error: {event['error']['message']}")
Wielokrotne wywołania funkcji
Model może zdecydować się na wywołanie wielu funkcji w ramach jednej odpowiedzi. Pole output w zdarzeniu response.done może zawierać wiele wpisów typu function_call. Przetwarzaj je wszystkie przed wywołaniem response.create.
Kluczowe wnioski
- Narzędzia deklarujesz w
session.update, używając standardowego schematu JSON - Argumenty docierają w strumieniu poprzez
response.function_call_arguments.delta - Po wykonaniu wyślij wynik z powrotem przez
conversation.item.createz polemcall_id - Wywołaj
response.create, aby model mógł sformułować odpowiedź głosową z wynikiem - Obsługuj wielokrotne wywołania: model może wywołać kilka funkcji jednocześnie