Voice-Funktionsaufrufe
Auf dieser Seite
Funktionsaufrufe aus einer Sprachkonversation ausführen
Voice-Funktionsaufrufe ermöglichen es Ihrem Agenten, während einer Konversation echte Aktionen auszulösen: Abfragen einer Datenbank, Auftragserteilung, Absenden einer E-Mail oder Aufruf einer externen API. Der Agent entscheidet basierend darauf, was der Nutzer sagt, wann er eine Funktion aufrufen soll.
Der Agent erkennt den Bedarf
Der Nutzer sagt etwas, das einen Funktionsaufruf erfordert. Der Agent generiert die Argumente.
Ihre Anwendung führt die Funktion aus
Sie erhalten die Argumente über das `function_call_arguments.done`-Ereignis und führen Ihre Geschäftslogik aus.
Sie senden das Ergebnis zurück
Senden Sie `conversation.item.create` mit dem Typ `function_call_output` und der `call_id`.
Der Agent setzt die Konversation fort
Senden Sie `response.create`, damit der Agent das Ergebnis in seine gesprochene Antwort einarbeitet.
Funktion deklarieren
Sie deklarieren Funktionen im tools-Array von 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"]
}
}
]
}
}
Funktionsaufruf empfangen und verarbeiten
Wenn der Agent beschließt, eine Funktion aufzurufen, erhalten Sie die Argumente als Stream und dann alles auf einmal:
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;
// Run the function
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 back the result
ws.send(JSON.stringify({
type: "conversation.item.create",
item: {
type: "function_call_output",
call_id: callId,
output: JSON.stringify(result)
}
}));
// Ask the agent to continue
ws.send(JSON.stringify({
type: "response.create"
}));
}
Parallele Funktionsaufrufe
Der Agent kann beschließen, mehrere Funktionen gleichzeitig aufzurufen. Sie erhalten dann mehrere function_call_arguments.done-Ereignisse. Die Regel lautet:
- Jede Funktion auflösen, bevor Sie antworten
- Jedes Ergebnis einreichen, mit einem
conversation.item.createpro Ergebnis - Eine einzige
response.createam Ende senden
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) {
// Every function is resolved
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)
}
}));
}
// A single response.create for all the outputs
ws.send(JSON.stringify({ type: "response.create" }));
pendingCalls.clear();
}
break;
Best Practices
- Klare Beschreibungen: Die Qualität Ihrer Funktionsbeschreibungen bestimmt, wann der Agent sie verwendet.
- Schnelle Ausführung: Eine Funktion, die länger als 2 oder 3 Sekunden dauert, erzeugt eine unangenehme Stille.
- Fehlerbehandlung: Geben Sie eine lesbare Fehlermeldung zurück, anstatt eine technische Ausnahme.
- Gesprochene Bestätigung: Bei sensiblen Aktionen (Zahlungen, Löschungen) lassen Sie den Nutzer bestätigen, bevor Sie diese ausführen.
Kernaussagen
- Voice-Funktionsaufrufe folgen einem vierstufigen Zyklus: Erkennung, Ausführung, Rückgabe des Ergebnisses, Fortsetzung.
- Sie deklarieren Funktionen in
session.updatemit einem JSON-Schema für ihre Parameter. - Das Ergebnis muss über
conversation.item.createmittype: "function_call_output"zurückgesendet werden. - Senden Sie immer
response.createnach dem Einreichen der Ergebnisse. - Bei parallelen Aufrufen warten Sie auf jedes Ergebnis, bevor Sie eine einzige
response.createsenden.