> ## Documentation Index
> Fetch the complete documentation index at: https://docs.thunderphone.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Dinamikus hívásonkénti konfiguráció

> Válasszon ügynököt — vagy írjon át egy promptot — minden bejövő hívásnál egy webhookban megadott egyéni logika alapján.

Alapértelmezés szerint minden telefonszámhoz és közzétehető kulcshoz statikus AI-ügynök
van hozzárendelve. Ha **hívónkénti** vagy **látogatónkénti** testreszabásra
van szüksége — VIP-irányítás, bejelentkezett felhasználói kontextus, A/B prompttesztek — váltson
webhook módra, és hagyja, hogy a szervere döntsön.

## Hogyan működik

1. Iratkozzon fel a [`telephony.incoming`](/hu/webhooks/events)
   (telefon) vagy a [`web.incoming`](/hu/webhooks/events) (widget)
   eseményre. Mindkettő **blokkoló** webhook: a ThunderPhone legfeljebb
   10 másodpercig vár a válaszára, mielőtt folytatná a hívást.
2. A ThunderPhone elküldi Önnek a következőt: `{call_id, from_number, to_number}` (a widgetes
   munkamenetek számok helyett widgetspecifikus mezőket tartalmaznak — lásd a
   [kérési sémát](/hu/webhooks/call-incoming)).
3. A szervere egy ügynökkonfigurációval válaszol (prompt, hang,
   termék, eszközök). A ThunderPhone ezt a konfigurációt használja a híváshoz.
4. Ha `{}` értéket ad vissza, időtúllépés történik, vagy hiba lép fel, a statikusan hozzárendelt
   AI-ügynök lesz használva tartalékként. Biztonságos alapértelmezés.

<Note>
  Telefonhívásoknál (`telephony.incoming`) és widgetes
  munkameneteknél (`web.incoming`) is ugyanúgy működik, függetlenül attól, hogy webhookvégpontra
  vagy a régi, egyetlen URL-es webhookra érkezik.
</Note>

## 1. Konfigurálja a webhook célhelyét

<Tabs>
  <Tab title="Telefonhívások">
    Telefonszámok esetén iratkoztassa fel a végpontját a `telephony.incoming` eseményre:

    ```bash theme={null}
    curl -X POST https://api.thunderphone.com/v1/developer/webhook-endpoints \
      -H "Authorization: Bearer sk_live_YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "label":  "Prod call-incoming",
        "url":    "https://example.com/thunderphone/incoming",
        "events": ["telephony.incoming"]
      }'
    ```

    A válasz egy egyszer használatos `secret` értéket tartalmaz — mentse el; ezt fogja használni
    az aláírás ellenőrzéséhez.
  </Tab>

  <Tab title="Webes widget">
    Widgetes munkamenetekhez hozzon létre egy `mode="webhook"` módú közzétehető kulcsot,
    amelybe be van építve a végpont URL-je:

    ```bash theme={null}
    curl -X POST https://api.thunderphone.com/v1/publishable-key \
      -H "Authorization: Bearer sk_live_YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "name":            "Dynamic widget",
        "mode":            "webhook",
        "webhook_url":     "https://example.com/thunderphone/widget-incoming",
        "allowed_domains": ["example.com"]
      }'
    ```

    A widget minden munkamenet indításakor POST kérést küld erre az URL-re.
  </Tab>
</Tabs>

## 2. A kezelő implementálása

Három alapszabály:

* **Ellenőrizze az aláírást** minden kérésnél (lásd:
  [Webhook-aláírások ellenőrzése](/hu/guides/verify-webhook-signatures)).
  Ezt fejlesztés közben se hagyja ki — egyszer állítsa be helyesen, majd használja újra.
* **Válaszoljon gyorsan**. Tíz másodperc a szigorú felső korlát, és minden másodperc
  néma várakozás a hívó számára. Szükség esetén végezzen adatbázis-lekérdezéseket, de
  ne hívjon szinkron módon későbbi LLM-eket — ha dinamikus promptgenerálást szeretne,
  számítsa ki előre és tárolja gyorsítótárban.
* **Alkalmazzon tiszta tartalék megoldást**. Minden váratlan állapotnak `{}` értéket kell
  visszaadnia, hogy a statikusan hozzárendelt ügynök kezelje a hívást.

<CodeGroup>
  ```python FastAPI theme={null}
  import hashlib
  import hmac
  import json
  import os

  from fastapi import FastAPI, HTTPException, Request

  app = FastAPI()
  SECRET = os.environ["THUNDERPHONE_WEBHOOK_SECRET"]

  def verify(body: bytes, sig: str) -> bool:
      expected = hmac.new(SECRET.encode(), body, hashlib.sha256).hexdigest()
      return hmac.compare_digest(expected, sig or "")

  @app.post("/thunderphone/incoming")
  async def incoming(request: Request):
      body = await request.body()
      if not verify(body, request.headers.get("X-ThunderPhone-Signature", "")):
          raise HTTPException(401)

      event = json.loads(body)
      if event["type"] not in ("telephony.incoming", "web.incoming"):
          return {}  # fall back to default

      caller = event["data"]["from_number"]
      # Cheap DB lookup: is this a known VIP?
      customer = lookup_customer(caller)
      if customer and customer.tier == "vip":
          return {
              "prompt":  f"You are a VIP concierge for {customer.name}. Be proactive…",
              "voice":   "john",
              "product": "storm-base",
          }
      return {}  # default agent handles non-VIPs

  def lookup_customer(phone: str):
      # ... your CRM integration ...
      pass
  ```

  ```javascript Express theme={null}
  import crypto from "node:crypto";
  import express from "express";

  const app = express();
  const SECRET = process.env.THUNDERPHONE_WEBHOOK_SECRET;

  function verify(body, sig) {
    const expected = crypto.createHmac("sha256", SECRET).update(body).digest("hex");
    return sig &&
      crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(sig));
  }

  app.post(
    "/thunderphone/incoming",
    express.raw({ type: "application/json" }),
    async (req, res) => {
      if (!verify(req.body, req.header("X-ThunderPhone-Signature"))) {
        return res.sendStatus(401);
      }
      const event = JSON.parse(req.body.toString("utf8"));

      const IMPORTANT_TYPES = new Set([
        "telephony.incoming",
        "web.incoming",
      ]);
      if (!IMPORTANT_TYPES.has(event.type)) return res.json({});

      const customer = await lookupCustomer(event.data.from_number);
      if (customer?.tier === "vip") {
        return res.json({
          prompt:  `You are a VIP concierge for ${customer.name}. Be proactive…`,
          voice:   "john",
          product: "storm-base",
        });
      }
      res.json({}); // fall back to default agent
    },
  );
  ```
</CodeGroup>

## 3. Válaszséma

A válasz törzse pontosan megfelel a
[bejövő hívások válaszsémájának](/hu/webhooks/call-incoming).
A gyakran használt mezők:

| Mező                          | Típus                   | Leírás                                                                       |
| ----------------------------- | ----------------------- | ---------------------------------------------------------------------------- |
| `prompt`                      | karakterlánc (kötelező) | Az ügynök rendszerszintű promptja                                            |
| `voice`                       | karakterlánc (kötelező) | Hangazonosító a [`GET /v1/voices`](/api-reference/agents#voices) végpontból  |
| `product`                     | karakterlánc            | Alapértelmezett értéke: `spark`                                              |
| `background_track`            | karakterlánc \| null    | Környezeti hang azonosítója                                                  |
| `acknowledgement_prompt_mode` | karakterlánc            | `auto` vagy `manual` (csak Storm-with-ack esetén)                            |
| `acknowledgement_prompt`      | karakterlánc            | Kötelező, ha a mód `manual`                                                  |
| `tools`                       | tömb                    | Beágyazott funkcióeszköz-sémák — lásd: [Funkcióeszközök](/hu/tools/overview) |

<Note>
  A hívásonkénti beszédsorrend és a `max_hold_seconds` nem érhető el a
  webhookválaszban. Állítsa be ezeket a hivatkozott
  [AI-ügynökön](/api-reference/agents).
</Note>

## Minták

### Bejelentkezett felhasználói környezet

Webhook módú widgeteknél a látogató oldala már tudja, ki ő.
Hívja meg webhookját egy olyan lekérdezési sztringparaméterrel, amelyet a widget SDK
továbbít (`?customer_id=123`), és keresse ki az ügyfelet szerveroldalon.

### A/B prompt bevezetése

Mielőtt ezt saját maga valósítaná meg, vegye figyelembe, hogy a ThunderPhone natív
[Kísérletek](/hu/guides/concepts) funkcióval rendelkezik
(`/dashboard/experiments` és az ügynökszerkesztő **A/B** lapja), amely
változatokat határoz meg, felosztja a forgalmat, és változatonként hasonlítja össze az eredményeket —
webhook nélkül.

Ha mégis webhookoldali vezérlésre van szüksége: hashelje a `call_id` értékét → kosár;
a `0..49` esetén az A promptot, az `50..99` esetén a B promptot szolgálja ki. Rögzítse,
melyik kosarat választotta a saját adatbázisában, majd később vesse össze a
befejezett hívás értékelésével.

### Időalapú útválasztás

Nyitvatartási idő → „élő támogatási” ügynök; nyitvatartási időn kívül → „üzenet rögzítése”
ügynök. Egyszerű elágaztatás a kezelőben a `new Date().getUTCHours()` alapján.

***

## Következő lépések

<CardGroup cols={2}>
  <Card title="Bejövő hívások webhook-referenciája" icon="phone" href="/hu/webhooks/call-incoming">
    Pontos kérés- és válaszsémák, minden konfigurációs kulccsal együtt.
  </Card>

  <Card title="Webhook-aláírások ellenőrzése" icon="shield-check" href="/hu/guides/verify-webhook-signatures">
    Állítsa be helyesen egyszer a HMAC-et; használja újra mindenhol.
  </Card>

  <Card title="Eszközintegráció létrehozása" icon="screwdriver-wrench" href="/hu/guides/build-tool-integration">
    Kombinálja a dinamikus útválasztást ügynökönkénti eszközökkel.
  </Card>

  <Card title="Kézbesítési szemantika" icon="bolt" href="/hu/webhooks/overview">
    Újrapróbálkozások, sorrendiség, időkorlátok.
  </Card>
</CardGroup>
