Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Anrop av funktioner via röst

Lektion 13 av 16 Uppdaterad 30 juli 2026 Utvecklare
På denna sida
  1. Kör funktioner från ett röstsamtal
  2. Deklarera en funktion
  3. Ta emot och hantera ett funktionsanrop
  4. Parallella funktionsanrop
  5. Bästa praxis
  6. Viktiga punkter

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.

1

Agenten identifierar behovet

Användaren säger något som kräver ett funktionsanrop. Agenten genererar argumenten.

2

Din app kör funktionen

Du tar emot argumenten via händelsen function_call_arguments.done och kör din affärslogik.

3

Du skickar tillbaka resultatet

Skicka conversation.item.create med typen function_call_output och call_id.

4

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:

  1. Lös varje funktion innan du svarar
  2. Skicka varje resultat, med en conversation.item.create per resultat
  3. Skicka en enda response.create på 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.update med ett JSON-schema för deras parametrar
  • Resultatet måste skickas tillbaka via conversation.item.create med type: "function_call_output"
  • Skicka alltid response.create efter att du har skickat resultaten
  • Vid parallella anrop, vänta på alla resultat innan du skickar en enda response.create