Voice Agent Platform Backend

// control-plane.ts — privileged; runs server-side only.
import { randomBytes } from "node:crypto";

export class ControlPlane {
  constructor(
    private readonly host = "https://portal.telequick.dev",
    private readonly adminKey = process.env.TELEQUICK_API_KEY!, // platform-admin credential
  ) {}

  private async rpc<T>(proc: string, input: unknown): Promise<T> {
    const res = await fetch(`${this.host}/api/trpc/${proc}`, {
      method: "POST",
      headers: {
        "content-type": "application/json",
        "authorization": `Bearer ${this.adminKey}`,
      },
      body: JSON.stringify(input),
    });
    if (!res.ok) throw new Error(`${proc} ${res.status}: ${(await res.text()).slice(0, 200)}`);
    const body = await res.json() as { result?: { data?: T }; error?: { message?: string } };
    if (body.error) throw new Error(body.error.message ?? `${proc} failed`);
    return body.result!.data as T;
  }

  /** Create the org's endpoints + data isolation. Idempotent. */
  bootstrap(orgId: string, adminToken: string) {
    return this.rpc<{ ok: true; provisioned: unknown }>("admin.bootstrapOrg", {
      orgId, adminToken,
    });
  }

  /**
   * Register a scoped key for one tenant. You generate the token value; the
   * control plane binds it to `orgId` with the given scopes. Returns nothing
   * secret — you already hold the token, so hand it to the tenant now.
   */
  async mintTenantKey(orgId: string, scopes: string[]): Promise<string> {
    const token = "sk_" + randomBytes(24).toString("hex");
    await this.rpc<{ ok: true }>("admin.publishServiceAccount", {
      orgId, token, scopes, isGlobalAdmin: false,
    });
    return token;
  }

  revokeTenantKey(orgId: string, token: string) {
    return this.rpc<{ ok: true }>("admin.revokeServiceAccount", { orgId, token });
  }

  /** Point the tenant's SIP trunk at their realm. */
  addTrunk(orgId: string, trunk: Record<string, unknown>) {
    return this.rpc<{ ok: true }>("admin.addTrunk", { orgId, trunk });
  }

  /** Map a DID to a trunk + agent for inbound routing. */
  upsertNumber(orgId: string, number: Record<string, unknown>) {
    return this.rpc<{ ok: true }>("admin.upsertPhoneNumber", { orgId, number });
  }

  /** Seal a tenant's provider key (BYO OpenAI / Deepgram / ElevenLabs / …). */
  setProviderCredentials(orgId: string, provider: string, payload: Record<string, string>) {
    return this.rpc<{ ok: true }>("admin.setProviderCredentials", { orgId, provider, payload });
  }

  /** Publish a saved agent's pipeline config to the engine. */
  hydrateAgent(orgId: string, agentId: string) {
    return this.rpc<{ ok: true; ready: boolean; missing_providers: string[] }>(
      "admin.hydrateAgent", { orgId, agentId },
    );
  }
}

import { ControlPlane } from "./control-plane";

const cp = new ControlPlane();

export async function onboardTenant(orgId: string, opts: {
  trunkId: string;
  sipHost: string;          // carrier SIP host
  did: string;              // E.164 the tenant answers on
  agentId: string;          // an agent the customer already saved
  openaiKey?: string;       // optional BYO provider key
}): Promise<{ orgId: string; tenantKey: string }> {
  // 1. Endpoints + isolation. Idempotent — safe to re-run on retry.
  const adminToken = "at_" + crypto.randomUUID().replace(/-/g, "");
  await cp.bootstrap(orgId, adminToken);

  // 2. Trunk + DID. The engine derives tenant_id from the INVITE's DNS label,
  //    so the trunk just needs to target this org's realm.
  await cp.addTrunk(orgId, {
    trunk_id: opts.trunkId,
    direction: "inbound",
    realm: "external",
    external_sip_ip: opts.sipHost,
    media_mode: "proxy",
    inbound_rule: "ai_bidirectional_stream",
  });
  await cp.upsertNumber(orgId, {
    e164: opts.did,
    trunk_id: opts.trunkId,
    agent_id: opts.agentId,
    provider: "manual",
  });

  // 3. BYO provider key (sealed under the org). Skip to inherit the platform's.
  if (opts.openaiKey) {
    await cp.setProviderCredentials(orgId, "openai", { api_key: opts.openaiKey });
  }

  // 4. Publish the agent's pipeline config to the engine.
  const pub = await cp.hydrateAgent(orgId, opts.agentId);
  if (!pub.ready) {
    console.warn(`agent ${opts.agentId} not ready — missing:`, pub.missing_providers);
  }

  // 5. Scoped key for the tenant's backend. Least privilege.
  const tenantKey = await cp.mintTenantKey(orgId, ["voice:read", "voice:write"]);
  return { orgId, tenantKey };
}

import { Voice } from "@telequick/sdk/voice";

// Look up the tenant's key from your own store (you saved it at onboarding).
function voiceFor(orgId: string, tenantKey: string): Voice {
  return new Voice({
    baseUrl: "https://engine.telequick.dev",
    apiKey:  tenantKey,   // scoped to this org only
    orgId,
  });
}

// Place an outbound call on the tenant's trunk with their agent attached.
// The engine wires the audio bridge on answer — no bridge in your process.
export async function callForTenant(orgId: string, tenantKey: string, args: {
  to: string; from: string; trunkId: string; agent: string;
}) {
  const v = voiceFor(orgId, tenantKey);
  const call = await v.calls.originate({
    to: args.to,
    from: args.from,
    trunkId: args.trunkId,
    agent: args.agent,
    ringTimeoutSec: 25,
  });

  // Poll until it leaves the ringing states.
  for (;;) {
    const c = await v.calls.get({ sid: call.sid });
    if (c.status === "in_progress") return { sid: call.sid, status: c.status };
    if (c.status === "failed" || c.status === "no_answer") {
      return { sid: call.sid, status: c.status };
    }
    await new Promise((r) => setTimeout(r, 500));
  }
}

import { serve } from "@hono/node-server";
import { Hono } from "hono";
import { onboardTenant, callForTenant } from "./platform";
import { lookupTenantKey } from "./store"; // your own tenant→key store

const app = new Hono();

// Privileged: your staff / signup flow only.
app.post("/tenants", async (c) => {
  const body = await c.req.json();
  const { orgId, tenantKey } = await onboardTenant(body.orgId, body);
  // Persist tenantKey in YOUR store; return an id, not the raw key, to the UI.
  await lookupTenantKey.save(orgId, tenantKey);
  return c.json({ orgId, provisioned: true });
});

// Per-tenant: authenticate the caller as a member of :orgId first (your auth).
app.post("/tenants/:orgId/calls", async (c) => {
  const orgId = c.req.param("orgId");
  const key = await lookupTenantKey.get(orgId);
  if (!key) return c.json({ error: "unknown tenant" }, 404);
  const result = await callForTenant(orgId, key, await c.req.json());
  return c.json(result);
});

serve({ fetch: app.fetch, port: 8787 });