Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Voice function calling

Lektion 13 af 16 Opdateret 30. juli 2026 Udvikler
På denne side
  1. Kør funktioner fra en talesamtale
  2. Deklarér en funktion
  3. Modtag og håndtér et funktionskald
  4. Parallelle funktionskald
  5. Bedste praksis
  6. Vigtige pointer

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.

1

Agenten identificerer behovet

Brugeren siger noget, der kræver et funktionskald. Agenten genererer argumenterne.

2

Din app kører funktionen

Du modtager argumenterne via hændelsen function_call_arguments.done og kører din forretningslogik.

3

Du sender resultatet tilbage

Send conversation.item.create med typen function_call_output og call_id.

4

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:

  1. Løs alle funktioner før du svarer
  2. Indsend alle resultater med ét conversation.item.create pr. resultat
  3. Send én enkelt response.create til 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.update med et JSON-skema for deres parametre
  • Resultatet skal sendes tilbage via conversation.item.create med type: "function_call_output"
  • Send altid response.create efter at have indsendt resultaterne
  • Ved parallelle kald skal du vente på alle resultater, før du sender én enkelt response.create