Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Häälkäskluste funktsioonide kutsumine

Õppetund 13 / 16 Värskendatud 30. juuli 2026 Arendajatele
Sellel lehel
  1. Funktsioonide käivitamine häälvestluse käigus
  2. Funktsiooni deklareerimine
  3. Funktsioonikutse vastuvõtmine ja töötlemine
  4. Paralleelsed funktsioonikutsed
  5. Parimad tavad
  6. Peamised punktid

Funktsioonide käivitamine häälvestluse käigus

Häälkäskluste funktsioonide kutsumine võimaldab sinu agendil vestluse käigus reaalseid toiminguid sooritada: pärida andmebaasi, esitada tellimus, saata meil või kutsuda välist API-t. Agent otsustab funktsiooni kutsumise aja kasutaja öeldu põhjal.

1

Agent tuvastab vajaduse

Kasutaja ütleb midagi, mis nõuab funktsiooni kutsumist. Agent genereerib argumendid.

2

Sinu rakendus käivitab funktsiooni

Saad argumendid sündmuse `function_call_arguments.done` kaudu ja käivitad oma äriloogika.

3

Saadad tulemuse tagasi

Saada `conversation.item.create` koos tüübiga `function_call_output` ja vastava `call_id`-ga.

4

Agent jätkab vestlust

Saada `response.create`, et agent saaks tulemuse oma kõnevastusesse lõimida.

Funktsiooni deklareerimine

Deklareeri funktsioonid session.update massiivis tools:

{
  "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"]
        }
      }
    ]
  }
}

Funktsioonikutse vastuvõtmine ja töötlemine

Kui agent otsustab funktsiooni kutsuda, saad argumendid esmalt voona ja seejärel korraga:

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äivita funktsioon
      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" };
  }

  // Saada tulemus tagasi
  ws.send(JSON.stringify({
    type: "conversation.item.create",
    item: {
      type: "function_call_output",
      call_id: callId,
      output: JSON.stringify(result)
    }
  }));

  // Palu agendil jätkata
  ws.send(JSON.stringify({
    type: "response.create"
  }));
}

Paralleelsed funktsioonikutsed

Agent võib otsustada kutsuda korraga mitut funktsiooni. Sel juhul saad mitu function_call_arguments.done sündmust. Reegel on järgmine:

  1. Lahenda iga funktsioon enne vastamist
  2. Esita iga tulemus, kasutades iga tulemuse kohta ühte conversation.item.create
  3. Saada lõpus üksainus response.create
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) {
    // Iga funktsioon on lahendatud
    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)
        }
      }));
    }
    // Üksainus response.create kõigi väljundite jaoks
    ws.send(JSON.stringify({ type: "response.create" }));
    pendingCalls.clear();
  }
  break;

Parimad tavad

  • Selged kirjeldused: sinu funktsioonide kirjelduste kvaliteet määrab, millal agent neid kasutab
  • Kiire täitmine: funktsioon, mis võtab aega üle 2–3 sekundi, tekitab ebamugava vaikuse
  • Veakäsitlus: tagasta loetav veateade tehnilise erindi asemel
  • Suuline kinnitus: tundlike toimingute (maksed, kustutamised) puhul lase kasutajal enne käivitamist kinnitada

Peamised punktid

  • Häälkäskluste funktsioonide kutsumine järgib neljaetapilist tsüklit: tuvastamine, täitmine, tulemuse tagastamine, jätkamine
  • Deklareeri funktsioonid session.update sees koos nende parameetrite JSON-skeemiga
  • Tulemus tuleb tagastada conversation.item.create kaudu, kasutades tüüpi function_call_output
  • Saada pärast tulemuste esitamist alati response.create
  • Paralleelsete kutsete puhul oota kõiki tulemusi enne ühe response.create saatmist