Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Voice-Funktionsaufrufe

Lektion 13 von 16 Aktualisiert am 30. Juli 2026 Entwickler
Auf dieser Seite
  1. Funktionsaufrufe aus einer Sprachkonversation ausführen
  2. Funktion deklarieren
  3. Funktionsaufruf empfangen und verarbeiten
  4. Parallele Funktionsaufrufe
  5. Best Practices
  6. Kernaussagen

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.

1

Der Agent erkennt den Bedarf

Der Nutzer sagt etwas, das einen Funktionsaufruf erfordert. Der Agent generiert die Argumente.

2

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.

3

Sie senden das Ergebnis zurück

Senden Sie `conversation.item.create` mit dem Typ `function_call_output` und der `call_id`.

4

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:

  1. Jede Funktion auflösen, bevor Sie antworten
  2. Jedes Ergebnis einreichen, mit einem conversation.item.create pro Ergebnis
  3. Eine einzige response.create am 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.update mit einem JSON-Schema für ihre Parameter.
  • Das Ergebnis muss über conversation.item.create mit type: "function_call_output" zurückgesendet werden.
  • Senden Sie immer response.create nach dem Einreichen der Ergebnisse.
  • Bei parallelen Aufrufen warten Sie auf jedes Ergebnis, bevor Sie eine einzige response.create senden.