Anrop av funktioner via röst
På denna sida
Kör funktioner från ett röstsamtal
Med anrop av funktioner via röst kan din agent utföra verkliga åtgärder under ett samtal: fråga en databas, lägga en order, skicka ett e-postmeddelande eller anropa ett externt API. Agenten avgör själv när en funktion ska anropas baserat på vad användaren säger.
Agenten identifierar behovet
Användaren säger något som kräver ett funktionsanrop. Agenten genererar argumenten.
Din app kör funktionen
Du tar emot argumenten via händelsen function_call_arguments.done och kör din affärslogik.
Du skickar tillbaka resultatet
Skicka conversation.item.create med typen function_call_output och call_id.
Agenten fortsätter samtalet
Skicka response.create så att agenten kan väva in resultatet i sitt talade svar.
Deklarera en funktion
Du deklarerar funktioner i arrayen tools 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"]
}
}
]
}
}
Ta emot och hantera ett funktionsanrop
När agenten bestämmer sig för att anropa en funktion får du argumenten som en ström, och sedan allt på en gång:
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" };
}
// Skicka tillbaka resultatet
ws.send(JSON.stringify({
type: "conversation.item.create",
item: {
type: "function_call_output",
call_id: callId,
output: JSON.stringify(result)
}
}));
// Be agenten att fortsätta
ws.send(JSON.stringify({
type: "response.create"
}));
}
Parallella funktionsanrop
Agenten kan besluta att anropa flera funktioner samtidigt. Då får du flera händelser av typen function_call_arguments.done. Regeln är:
- Lös varje funktion innan du svarar
- Skicka varje resultat, med en
conversation.item.createper resultat - Skicka en enda
response.createpå slutet
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) {
// Varje funktion är 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 enda response.create för alla utdata
ws.send(JSON.stringify({ type: "response.create" }));
pendingCalls.clear();
}
break;
Bästa praxis
- Tydliga beskrivningar: kvaliteten på dina funktionsbeskrivningar avgör när agenten använder dem
- Snabb exekvering: en funktion som tar mer än 2 eller 3 sekunder skapar en obekväm tystnad
- Felhantering: returnera ett läsbart felmeddelande snarare än ett tekniskt undantag
- Muntlig bekräftelse: för känsliga åtgärder (betalningar, raderingar) bör du låta användaren bekräfta innan du kör dem
Viktiga punkter
- Anrop av funktioner via röst följer en fyrastegscykel: identifiering, exekvering, returnering av resultat, fortsättning
- Du deklarerar funktioner i
session.updatemed ett JSON-schema för deras parametrar - Resultatet måste skickas tillbaka via
conversation.item.createmedtype: "function_call_output" - Skicka alltid
response.createefter att du har skickat resultaten - Vid parallella anrop, vänta på alla resultat innan du skickar en enda
response.create