Number Masking

import os
from contextlib import suppress

from fastapi import FastAPI, HTTPException, Request
from unpod import AsyncClient
from unpod.telephony import TelephonyAPIError, WebhookSignatureError, parse_call_event

FROM = "+919000000001"             # your Unpod number: all either person sees
BASE = "https://abc123.ngrok.app"  # this server's public https URL
SECRET = os.environ["UNPOD_WEBHOOK_SECRET"]
client = AsyncClient()  # one client, reused for every request
app = FastAPI()
# In memory: run one process, or use your database.
ours: set[str] = set()  # call and leg ids seen on signed events
outcomes: dict = {}  # call id -> role -> hangup cause


async def start_masked_call(agent: str, customer: str) -> str:
    """Dial the agent; /call-status adds the customer once they answer."""
    call = await client.telephony.calls.create(
        FROM, agent, role="agent", record=True,
        status_callback_url=f"{BASE}/call-status",
        recording_callback_url=f"{BASE}/recording",
        metadata={"customer": customer},  # comes back on every event
    )
    return call.call_id

curl -s -X POST "https://unpod.ai/api/v2/platform/sbc/v1/calls" \
  -H "Authorization: Token $UNPOD_PLATFORM_TOKEN" -H "Org-Handle: $UNPOD_ORG_HANDLE" \
  -H "Idempotency-Key: $(uuidgen)" -H "Content-Type: application/json" \
  -d '{"from": "+919000000001", "to": "+919000000002", "role": "agent",
       "record": true,
       "status_callback_url": "https://abc123.ngrok.app/call-status",
       "recording_callback_url": "https://abc123.ngrok.app/recording",
       "metadata": {"customer": "+919000000003"}}'

@app.post("/call-status")
async def call_status(request: Request):
    try:
        ev = parse_call_event(await request.body(), request.headers, secret=SECRET)
    except WebhookSignatureError:
        raise HTTPException(401)

    ours.update(filter(None, (ev.call_id, ev.leg_id)))  # signed: it's yours
    calls = client.telephony.calls
    customer = ev.metadata.get("customer")
    adding = ev.event == "Answered" and ev.role == "agent" and bool(customer)
    try:
        if adding:
            await calls.add_participant(
                ev.call_id, FROM, customer, role="customer",
                status_callback_url=f"{BASE}/call-status",
                idempotency_key=f"{ev.call_id}:customer",  # a resend never redials
            )
        elif ev.event == "Hangup":
            # an upsert by role: a resent Hangup overwrites, never duplicates
            outcomes.setdefault(ev.call_id, {})[ev.role] = ev.hangup_cause
            await calls.end(ev.call_id)  # never leave the other person alone
    except TelephonyAPIError as e:
        print(ev.call_id, e.status_code, e.message)
        if e.status_code == 429 or e.status_code >= 500:
            raise HTTPException(503)  # transient: Unpod sends the event again
        if adding and e.status_code not in (404, 409):  # 404 gone, 409 dialed
            outcomes.setdefault(ev.call_id, {})["customer"] = "Not dialed"
            with suppress(TelephonyAPIError):
                await calls.end(ev.call_id)  # can't dial the customer: free the agent
    return {"ok": True}  # 2xx once signed, or Unpod resends


@app.post("/recording")
async def recording(request: Request):
    # Recording events aren't signed yet: trust only what the API returns
    ev = parse_call_event(await request.body(), request.headers, None, verify=False)
    if ev.call_id not in ours:  # not a call you started, or already saved
        return {"ok": True}
    try:
        rec = await client.telephony.calls.get_recording(ev.call_id)
    except TelephonyAPIError as e:
        if e.status_code not in (403, 404):
            raise HTTPException(503)  # e.g. not ready yet: Unpod sends it again
        return {"ok": True}
    if rec.available:
        ours.discard(ev.call_id)
        print("recording", rec.call_id, rec.duration_secs)  # save with the outcome
    return {"ok": True}


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="127.0.0.1", port=8000)