Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Klicanje funkcij z glasom

Lekcija 13 od 16 Posodobljeno 30. julij 2026 Razvijalec
Na tej strani
  1. Izvajanje funkcij med glasovnim pogovorom
  2. Deklaracija funkcije
  3. Prejem in obdelava klica funkcije
  4. Vzporedni klici funkcij
  5. Najboljše prakse
  6. Ključne ugotovitve

Izvajanje funkcij med glasovnim pogovorom

Klicanje funkcij z glasom omogoča tvojemu agentu, da med pogovorom sproži dejanska dejanja: poizvedbo v bazi podatkov, oddajo naročila, pošiljanje e-pošte ali klic zunanjega API-ja. Agent se sam odloči, kdaj poklicati funkcijo, glede na to, kaj uporabnik reče.

1

Agent prepozna potrebo

Uporabnik izreče nekaj, kar zahteva klic funkcije. Agent generira argumente.

2

Tvoja aplikacija izvede funkcijo

Argumente prejmeš prek dogodka function_call_arguments.done in izvedeš svojo poslovno logiko.

3

Pošlješ rezultat nazaj

Pošlji conversation.item.create s tipom function_call_output in call_id.

4

Agent nadaljuje pogovor

Pošlji response.create, da agent rezultat vključi v svoj govorni odgovor.

Deklaracija funkcije

Funkcije deklariraš v polju tools znotraj 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"]
        }
      }
    ]
  }
}

Prejem in obdelava klica funkcije

Ko se agent odloči za klic funkcije, argumente najprej prejmeš kot tok, nato pa vse hkrati:

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

Vzporedni klici funkcij

Agent se lahko odloči, da bo hkrati poklical več funkcij. V tem primeru prejmeš več dogodkov function_call_arguments.done. Pravilo je naslednje:

  1. Razreši vsako funkcijo pred odgovorom
  2. Pošlji vsak rezultat z enim conversation.item.create na rezultat
  3. Pošlji en sam response.create na koncu
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;

Najboljše prakse

  • Jasni opisi: kakovost opisov tvojih funkcij določa, kdaj jih agent uporabi
  • Hitro izvajanje: funkcija, ki traja več kot 2 ali 3 sekunde, ustvari neprijetno tišino
  • Obdelava napak: vrni berljivo sporočilo o napaki namesto tehnične izjeme
  • Govorna potrditev: za občutljiva dejanja (plačila, brisanja) naj uporabnik potrdi dejanje, preden ga izvedeš

Ključne ugotovitve

  • Klicanje funkcij z glasom sledi štiristopenjskemu ciklu: zaznava, izvedba, vrnitev rezultata, nadaljevanje
  • Funkcije deklariraš v session.update s shemo JSON za njihove parametre
  • Rezultat moraš poslati nazaj prek conversation.item.create s type: "function_call_output"
  • Po pošiljanju rezultatov vedno pošlji response.create
  • Pri vzporednih klicih počakaj na vse rezultate, preden pošlješ en sam response.create