Voice function calling
På denne side
Kør funktioner fra en talesamtale
Voice function calling giver din agent mulighed for at udløse rigtige handlinger under en samtale: forespørge en database, placere en ordre, sende en e-mail eller kalde en ekstern API. Agenten beslutter selv, hvornår den skal kalde en funktion, baseret på hvad brugeren siger.
Agenten identificerer behovet
Brugeren siger noget, der kræver et funktionskald. Agenten genererer argumenterne.
Din app kører funktionen
Du modtager argumenterne via hændelsen function_call_arguments.done og kører din forretningslogik.
Du sender resultatet tilbage
Send conversation.item.create med typen function_call_output og call_id.
Agenten fortsætter samtalen
Send response.create, så agenten kan indarbejde resultatet i sit talte svar.
Deklarér en funktion
Du deklarerer funktioner i tools-arrayet i session.update:
{
"type": "session.update",
"session": {
"tools": [
{
"type": "function",
"name": "get_balance",
"description": "Gets the balance of a customer's bank account",
"parameters": {
"type": "object",
"properties": {
"client_id": {
"type": "string",
"description": "Customer ID"
}
},
"required": ["client_id"]
}
}
]
}
}
Modtag og håndtér et funktionskald
Når agenten beslutter at kalde en funktion, modtager du argumenterne som en stream, og derefter samlet på én gang:
let functionArgs = "";
ws.on("message", (data) => {
const event = JSON.parse(data);
switch (event.type) {
case "response.function_call_arguments.delta":
functionArgs += event.delta;
break;
case "response.function_call_arguments.done":
const args = JSON.parse(event.arguments);
const callId = event.call_id;
const functionName = event.name;
// Kør funktionen
handleFunctionCall(functionName, args, callId);
break;
}
});
async function handleFunctionCall(name, args, callId) {
let result;
switch (name) {
case "get_balance":
result = await getBalance(args.client_id);
break;
default:
result = { error: "Unknown function" };
}
// Send resultatet tilbage
ws.send(JSON.stringify({
type: "conversation.item.create",
item: {
type: "function_call_output",
call_id: callId,
output: JSON.stringify(result)
}
}));
// Bed agenten om at fortsætte
ws.send(JSON.stringify({
type: "response.create"
}));
}
Parallelle funktionskald
Agenten kan beslutte at kalde flere funktioner på én gang. I så fald modtager du flere function_call_arguments.done-hændelser. Reglen er:
- Løs alle funktioner før du svarer
- Indsend alle resultater med ét
conversation.item.createpr. resultat - Send én enkelt
response.createtil sidst
const pendingCalls = new Map();
let expectedCalls = 0;
case "response.function_call_arguments.done":
const result = await executeFunction(event.name, event.arguments);
pendingCalls.set(event.call_id, result);
if (pendingCalls.size === expectedCalls) {
// Alle funktioner er løst
for (const [callId, output] of pendingCalls) {
ws.send(JSON.stringify({
type: "conversation.item.create",
item: {
type: "function_call_output",
call_id: callId,
output: JSON.stringify(output)
}
}));
}
// En enkelt response.create for alle outputs
ws.send(JSON.stringify({ type: "response.create" }));
pendingCalls.clear();
}
break;
Bedste praksis
- Klare beskrivelser: kvaliteten af dine funktionsbeskrivelser afgør, hvornår agenten bruger dem
- Hurtig eksekvering: en funktion, der tager mere end 2-3 sekunder, skaber en akavet stilhed
- Fejlhåndtering: returnér en læsbar fejlmeddelelse i stedet for en teknisk undtagelse
- Talt bekræftelse: ved følsomme handlinger (betalinger, sletninger) skal brugeren bekræfte, før du kører dem
Vigtige pointer
- Voice function calling følger en firetrinscyklus: detektion, eksekvering, returnering af resultatet og fortsættelse
- Du deklarerer funktioner i
session.updatemed et JSON-skema for deres parametre - Resultatet skal sendes tilbage via
conversation.item.createmedtype: "function_call_output" - Send altid
response.createefter at have indsendt resultaterne - Ved parallelle kald skal du vente på alle resultater, før du sender én enkelt
response.create