Anrop av funktioner i realtid
På denna sida
Uppdatering 2 november 2026 — Ljudmodeller. Flera modeller i denna kurs är avvecklade:
tts-1,tts-1-hdochgpt-4o-mini-ttsslutar fungera den 6 januari 2027 (den angivna ersättaren ärgpt-realtime-2.1-mini, vilket OpenAI:s TTS-guide anger inte stöds av/v1/audio/speech: migreringen av talgenerering flyttas till Realtime API);gpt-realtime,gpt-4o-realtimeoch äldre ljudmodeller den 20 januari 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeoch/v1/audio/translationsden 26 februari 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). För full duplex-röst har GPT-Live 1 funnits tillgänglig i API:t sedan den 10 september 2026.
Anrop av funktioner i realtid
Anrop av funktioner i Realtime API låter din röstagent utföra konkreta åtgärder under en konversation: fråga en databas, lägga en order eller kontrollera en status. Mekanismerna liknar Responses API, men är anpassade för WebSocket-händelseströmmen.
Deklarera verktyg i sessionen
Du deklarerar verktyg i session.update, precis som instruktioner och röst. Varje verktyg är ett JSON-schema som beskriver dess parametrar:
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"
}
}))
Flödet för funktionsanrop
När modellen bestämmer sig för att anropa ett verktyg ser händelseföljden ut så här:
response.function_call_arguments.delta
Funktionsargumenten anländer via strömning, bit för bit.
response.function_call_arguments.done
Argumenten är kompletta. Nu kan du köra funktionen.
conversation.item.create (du)
Du skickar tillbaka funktionsresultatet till modellen.
response.create (du)
Du ber modellen att fortsätta sitt svar med resultatet.
Implementera funktionshanteraren
Här är ett komplett exempel på hur du hanterar funktionsanrop:
import json
# Register över tillgängliga funktioner
async def get_weather(city: str, unit: str = "celsius") -> dict:
# Anropa ett riktigt väder-API
return {"city": city, "temperature": 22, "unit": unit, "condition": "sunny"}
async def book_appointment(date: str, time: str, service: str) -> dict:
# Bokningslogik
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):
"""Bearbetar ett funktionsanrop och returnerar resultatet."""
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ör funktionen
func = FUNCTION_REGISTRY.get(func_name)
if func:
result = await func(**arguments)
else:
result = {"error": f"Unknown function: {func_name}"}
# Skicka tillbaka resultatet till modellen
await ws.send(json.dumps({
"type": "conversation.item.create",
"item": {
"type": "function_call_output",
"call_id": call_id,
"output": json.dumps(result)
}
}))
# Be modellen att fortsätta med resultatet
await ws.send(json.dumps({
"type": "response.create"
}))
Integrera i händelseloopen
Funktionshanteraren integreras i din huvudloop:
async def event_loop(ws):
"""Huvudloop för händelsebearbetning."""
async for raw_message in ws:
event = json.loads(raw_message)
event_type = event["type"]
if event_type == "response.done":
response = event["response"]
# Kontrollera om modellen anropade några funktioner
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":
# Spela upp svars ljud
audio_bytes = base64.b64decode(event["delta"])
player.write(audio_bytes)
elif event_type == "error":
print(f"Error: {event['error']['message']}")
Flera funktionsanrop
Modellen kan besluta att anropa flera funktioner i ett enda svar. Fältet output i response.done kan innehålla flera poster av typen function_call. Bearbeta alla dessa innan du anropar response.create.
Viktiga punkter
- Verktyg deklareras i
session.updatemed ett standard-JSON-schema - Argument anländer via strömning genom
response.function_call_arguments.delta - Efter körning skickar du tillbaka resultatet via
conversation.item.createmedcall_id - Anropa
response.createså att modellen kan formulera sitt röstsvar med resultatet - Hantera flera anrop: modellen kan anropa flera funktioner samtidigt