Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Funkcijų kvietimas balsu

Paskaita 13 iš 16 Atnaujinta 2026 m. liepos 30 d. Kūrėjas
Šiame puslapyje
  1. Funkcijų vykdymas pokalbio balsu metu
  2. Funkcijos deklaravimas
  3. Funkcijos kvietimo gavimas ir apdorojimas
  4. Lygiagretūs funkcijų kvietimai
  5. Geriausios praktikos
  6. Svarbiausi punktai

Funkcijų vykdymas pokalbio balsu metu

Funkcijų kvietimas balsu leidžia tavo agentui pokalbio metu atlikti realius veiksmus: užklausti duomenų bazę, pateikti užsakymą, išsiųsti el. laišką arba iškviesti išorinį API. Agentas pats nusprendžia, kada iškviesti funkciją, remdamasis tuo, ką sako vartotojas.

1

Agentas nustato poreikį

Vartotojas pasako ką nors, dėl ko reikia iškviesti funkciją. Agentas sugeneruoja argumentus.

2

Tavo programa vykdo funkciją

Gauni argumentus per įvykį `function_call_arguments.done` ir vykdai savo verslo logiką.

3

Grąžini rezultatą

Siųsk `conversation.item.create` su tipu `function_call_output` ir `call_id`.

4

Agentas tęsia pokalbį

Siųsk `response.create`, kad agentas įtrauktų rezultatą į savo žodinį atsakymą.

Funkcijos deklaravimas

Funkcijas deklaruoji session.update masyve 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"]
        }
      }
    ]
  }
}

Funkcijos kvietimo gavimas ir apdorojimas

Kai agentas nusprendžia iškviesti funkciją, argumentus gauni kaip srautą, o tada visus kartu:

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;

      // Vykdyti funkciją
      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" };
  }

  // Grąžinti rezultatą
  ws.send(JSON.stringify({
    type: "conversation.item.create",
    item: {
      type: "function_call_output",
      call_id: callId,
      output: JSON.stringify(result)
    }
  }));

  // Paprašyti agento tęsti
  ws.send(JSON.stringify({
    type: "response.create"
  }));
}

Lygiagretūs funkcijų kvietimai

Agentas gali nuspręsti vienu metu iškviesti kelias funkcijas. Tuomet gauni kelis įvykius function_call_arguments.done. Taisyklė tokia:

  1. Įvykdyk kiekvieną funkciją prieš atsakydamas
  2. Pateik kiekvieną rezultatą naudodamas po vieną conversation.item.create kiekvienam rezultatui
  3. Siųsk vieną response.create pabaigoje
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) {
    // Kiekviena funkcija įvykdyta
    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)
        }
      }));
    }
    // Vienas response.create visiems rezultatams
    ws.send(JSON.stringify({ type: "response.create" }));
    pendingCalls.clear();
  }
  break;

Geriausios praktikos

  • Aiškūs aprašymai: tavo funkcijų aprašymų kokybė lemia, kada agentas jas naudos
  • Greitas vykdymas: funkcija, trunkanti ilgiau nei 2–3 sekundes, sukelia nepatogią tylą
  • Klaidų apdorojimas: grąžink suprantamą klaidos pranešimą, o ne techninę išimtį
  • Žodinis patvirtinimas: atliekant jautrius veiksmus (mokėjimai, trynimai), paprašyk vartotojo patvirtinti prieš vykdydamas juos

Svarbiausi punktai

  • Funkcijų kvietimas balsu vyksta keturių žingsnių ciklu: aptikimas, vykdymas, rezultato grąžinimas, tęsimas
  • Funkcijas deklaruoji session.update naudodamas jų parametrų JSON schemą
  • Rezultatas turi būti grąžintas per conversation.item.create su type: "function_call_output"
  • Pateikęs rezultatus, visada siųsk response.create
  • Vykdant lygiagrečius kvietimus, palauk visų rezultatų prieš siųsdamas vieną response.create