Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Volání funkcí hlasem

Lekce 13 z 16 Aktualizováno 30. července 2026 Vývojář
Na této stránce
  1. Spouštění funkcí během hlasové konverzace
  2. Deklarace funkce
  3. Přijetí a zpracování volání funkce
  4. Paralelní volání funkcí
  5. Doporučené postupy
  6. Klíčové poznatky

Spouštění funkcí během hlasové konverzace

Volání funkcí hlasem umožňuje tvému agentovi spouštět skutečné akce přímo během konverzace: dotazovat se do databáze, zadávat objednávky, odesílat e-maily nebo volat externí API. Agent se sám rozhodne, kdy funkci zavolat, na základě toho, co uživatel řekne.

1

Agent identifikuje potřebu

Uživatel řekne něco, co vyžaduje zavolání funkce. Agent vygeneruje potřebné argumenty.

2

Tvá aplikace spustí funkci

Obdržíš argumenty prostřednictvím události function_call_arguments.done a spustíš svou obchodní logiku.

3

Odešleš výsledek zpět

Odešli conversation.item.create s typem function_call_output a příslušným call_id.

4

Agent pokračuje v konverzaci

Odešli response.create, aby agent mohl výsledek zapracovat do své hlasové odpovědi.

Deklarace funkce

Funkce deklaruješ v poli tools uvnitř 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"]
        }
      }
    ]
  }
}

Přijetí a zpracování volání funkce

Když se agent rozhodne zavolat funkci, obdržíš argumenty nejprve jako stream a následně najednou:

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"
  }));
}

Paralelní volání funkcí

Agent se může rozhodnout zavolat několik funkcí najednou. V takovém případě obdržíš několik událostí function_call_arguments.done. Pravidlo zní:

  1. Vyřeš každou funkci před odesláním odpovědi
  2. Odešli každý výsledek pomocí jedné zprávy conversation.item.create pro každý výsledek
  3. Odešli pouze jednu zprávu response.create na závěr
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;

Doporučené postupy

  • Jasné popisy: kvalita popisů tvých funkcí určuje, kdy je agent použije
  • Rychlé provádění: funkce, která trvá déle než 2 nebo 3 sekundy, vytvoří nepříjemné ticho
  • Ošetření chyb: vracej čitelnou chybovou zprávu místo technické výjimky
  • Hlasové potvrzení: u citlivých akcí (platby, mazání) nech uživatele akci před spuštěním potvrdit

Klíčové poznatky

  • Volání funkcí hlasem probíhá ve čtyřkrokovém cyklu: detekce, provedení, vrácení výsledku, pokračování
  • Funkce deklaruješ v session.update pomocí schématu JSON pro jejich parametry
  • Výsledek musíš odeslat zpět prostřednictvím conversation.item.create s type: "function_call_output"
  • Po odeslání výsledků vždy odešli response.create
  • U paralelních volání vyčkej na všechny výsledky před odesláním jediné zprávy response.create