Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Volanie funkcií hlasom

Lekcia 13 z 16 Aktualizované 30. júla 2026 Vývojár
Na tejto strane
  1. Spúšťanie funkcií počas hlasovej konverzácie
  2. Deklarácia funkcie
  3. Prijatie a spracovanie volania funkcie
  4. Paralelné volania funkcií
  5. Osvedčené postupy
  6. Kľúčové poznatky

Spúšťanie funkcií počas hlasovej konverzácie

Volanie funkcií hlasom umožňuje tvojmu agentovi spúšťať reálne akcie priamo počas konverzácie: dotazovať sa do databázy, zadávať objednávky, odosielať e-maily alebo volať externé API. Agent sa sám rozhodne, kedy funkciu zavolať, na základe toho, čo používateľ povie.

1

Agent identifikuje potrebu

Používateľ povie niečo, čo si vyžaduje zavolanie funkcie. Agent vygeneruje potrebné argumenty.

2

Tvoja aplikácia spustí funkciu

Argumenty prijmeš prostredníctvom udalosti function_call_arguments.done a spustíš svoju business logiku.

3

Odošleš späť výsledok

Odošli conversation.item.create s typom function_call_output a príslušným call_id.

4

Agent pokračuje v konverzácii

Odošli response.create, aby agent mohol výsledok zapracovať do svojej hlasovej odpovede.

Deklarácia funkcie

Funkcie deklaruješ v poli tools pri správe 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"]
        }
      }
    ]
  }
}

Prijatie a spracovanie volania funkcie

Keď sa agent rozhodne zavolať funkciu, najprv prijmeš argumenty ako stream a následne všetky naraz:

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;

      // Spusti funkciu
      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" };
  }

  // Odošli späť výsledok
  ws.send(JSON.stringify({
    type: "conversation.item.create",
    item: {
      type: "function_call_output",
      call_id: callId,
      output: JSON.stringify(result)
    }
  }));

  // Požiadaj agenta o pokračovanie
  ws.send(JSON.stringify({
    type: "response.create"
  }));
}

Paralelné volania funkcií

Agent sa môže rozhodnúť zavolať niekoľko funkcií naraz. V takom prípade prijmeš viacero udalostí function_call_arguments.done. Pravidlá sú nasledovné:

  1. Vyrieš každú funkciu predtým, než odpovieš
  2. Odošli každý výsledok pomocou jednej správy conversation.item.create na každý výsledok
  3. Odošli jedinú správu response.create na záver
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) {
    // Každá funkcia je vyriešená
    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)
        }
      }));
    }
    // Jediná správa response.create pre všetky výstupy
    ws.send(JSON.stringify({ type: "response.create" }));
    pendingCalls.clear();
  }
  break;

Osvedčené postupy

  • Jasné popisy: kvalita popisov tvojich funkcií určuje, kedy ich agent použije
  • Rýchle vykonávanie: funkcia, ktorá trvá viac ako 2 alebo 3 sekundy, vytvorí nepríjemné ticho
  • Ošetrenie chýb: vráť čitateľnú chybovú správu namiesto technickej výnimky
  • Hlasové potvrdenie: pri citlivých akciách (platby, mazanie) si vyžiadaj potvrdenie od používateľa pred ich vykonaním

Kľúčové poznatky

  • Volanie funkcií hlasom prebieha v štvorkrokovom cykle: detekcia, vykonanie, vrátenie výsledku, pokračovanie
  • Funkcie deklaruješ v session.update pomocou schémy JSON pre ich parametre
  • Výsledok musíš odoslať späť prostredníctvom conversation.item.create s type: "function_call_output"
  • Po odoslaní výsledkov vždy odošli response.create
  • Pri paralelných volaniach počkaj na všetky výsledky pred odoslaním jedinej správy response.create