CSTA Routing & Events

import { CtiSession } from "@clutchcall/sdk/cti";

// A connected, authenticated CTI leg (see the CTI overview).
// Token must carry the `routing` scope for routeRegister.
const cti = await CtiSession.connect({
  host: "engine.clutchcall.dev",
  token: ctiToken,        // short-lived, control-plane-minted, scopes: ["routing"]
  tenant: workspaceId,
});

// 1) Subscribe the per-tenant CSTA event stream.
const events = cti.subscribeEvents(); // async iterator over cti/<tenant>

// 2) Claim the route point. Renew before the lease expires.
await cti.send("routeRegister", { timeoutMs: 4000, ttlSec: 300 });
const renew = setInterval(
  () => cti.send("routeRegister", { timeoutMs: 4000, ttlSec: 300 }),
  240_000, // renew comfortably inside ttlSec
);

// 3) One loop for routing decisions AND state observation.
for await (const ev of events) {
  switch (ev.kind) {
    case "route": {
      // The engine is asking where this call should go.
      const dest = await pickDestination(ev); // your ACD logic
      // Answer with the destination on the same correlated request.
      await cti.selectRoute(ev, { destination: dest });
      break;
    }
    case "delivered":
      console.log("ringing", ev.callId);
      break;
    case "established":
      console.log("answered", ev.callId);
      break;
    case "held":
    case "retrieved":
    case "transferred":
      console.log(ev.kind, ev.callId);
      break;
    case "cleared":
      console.log("hung up", ev.callId, ev.cause);
      break;
    case "failed":
      console.warn("failed", ev.callId, ev.cause);
      break;
  }
}

clearInterval(renew);

from clutchcall.cti import CtiSession

# A connected, authenticated CTI leg (see the CTI overview).
# Token must carry the `routing` scope for routeRegister.
cti = await CtiSession.connect(
    host="engine.clutchcall.dev",
    token=cti_token,        # short-lived, control-plane-minted, scopes: ["routing"]
    tenant=workspace_id,
)

# 1) Subscribe the per-tenant CSTA event stream.
events = cti.subscribe_events()  # async iterator over cti/<tenant>

# 2) Claim the route point, then renew before the lease expires.
await cti.send("routeRegister", {"timeoutMs": 4000, "ttlSec": 300})

async def renew():
    while True:
        await asyncio.sleep(240)  # comfortably inside ttlSec
        await cti.send("routeRegister", {"timeoutMs": 4000, "ttlSec": 300})

asyncio.create_task(renew())

# 3) One loop for routing decisions AND state observation.
async for ev in events:
    if ev.kind == "route":
        dest = await pick_destination(ev)          # your ACD logic
        await cti.select_route(ev, destination=dest)
    elif ev.kind == "delivered":
        print("ringing", ev.call_id)
    elif ev.kind == "established":
        print("answered", ev.call_id)
    elif ev.kind in ("held", "retrieved", "transferred"):
        print(ev.kind, ev.call_id)
    elif ev.kind == "cleared":
        print("hung up", ev.call_id, ev.cause)
    elif ev.kind == "failed":
        print("failed", ev.call_id, ev.cause)