feat: cal.ai self serve

.env.example

@@ -383,10 +383,13 @@ TASKER_ENABLE_EMAILS=0
 # Ratelimiting via unkey
 UNKEY_ROOT_KEY=
 
-# Used for Cal.ai Enterprise Voice AI Agents
+# Used for Cal.ai Voice AI Agents
 # https://retellai.com
 RETELL_AI_KEY=
 
+# Used for buying phone number for cal ai voice agent
+STRIPE_PHONE_NUMBER_MONTHLY_PRICE_ID=
+
 # Used for the huddle01 integration
 HUDDLE01_API_TOKEN=
 

apps/web/app/api/phone-numbers/subscription/success/route.ts

@@ -0,0 +1,94 @@
+import { defaultResponderForAppDir } from "app/api/defaultResponderForAppDir";
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import type Stripe from "stripe";
+import { z } from "zod";
+
+import stripe from "@calcom/features/ee/payments/server/stripe";
+import { WEBAPP_URL } from "@calcom/lib/constants";
+import { HttpError } from "@calcom/lib/http-error";
+
+const querySchema = z.object({
+  session_id: z.string().min(1),
+});
+
+const checkoutSessionMetadataSchema = z.object({
+  userId: z.string().transform(Number),
+  teamId: z
+    .string()
+    .optional()
+    .transform((val) => (val ? Number(val) : undefined)),
+  eventTypeId: z
+    .string()
+    .optional()
+    .transform((val) => (val ? Number(val) : undefined)),
+  agentId: z.string().optional(),
+  workflowId: z.string().optional(),
+  type: z.literal("phone_number_subscription"),
+});
+
+type CheckoutSessionMetadata = z.infer<typeof checkoutSessionMetadataSchema>;
+
+async function handler(request: NextRequest) {
+  try {
+    const { session_id } = querySchema.parse(Object.fromEntries(request.nextUrl.searchParams));
+    const checkoutSession = await getCheckoutSession(session_id);
+    const metadata = validateAndExtractMetadata(checkoutSession);
+
+    return redirectToSuccess(metadata);
+  } catch (error) {
+    return handleError(error);
+  }
+}
+
+async function getCheckoutSession(sessionId: string) {
+  const session = await stripe.checkout.sessions.retrieve(sessionId, { expand: ["subscription"] });
+  if (!session) {
+    throw new HttpError({ statusCode: 404, message: "Checkout session not found" });
+  }
+  return session;
+}
+
+function validateAndExtractMetadata(session: Stripe.Checkout.Session): CheckoutSessionMetadata {
+  if (session.payment_status !== "paid") {
+    throw new HttpError({ statusCode: 402, message: "Payment required" });
+  }
+  if (!session.subscription) {
+    throw new HttpError({ statusCode: 400, message: "No subscription found in checkout session" });
+  }
+
+  const result = checkoutSessionMetadataSchema.safeParse(session.metadata);
+  if (!result.success) {
+    throw new HttpError({
+      statusCode: 400,
+      message: `Invalid checkout session metadata: ${result.error}`,
+    });
+  }
+
+  return result.data;
+}
+
+function redirectToSuccess(metadata: CheckoutSessionMetadata) {
+  const basePath = metadata.workflowId
+    ? `${WEBAPP_URL}/workflows/${metadata.workflowId}`
+    : `${WEBAPP_URL}/workflows`;
+
+  return NextResponse.redirect(basePath);
+}
+
+function handleError(error: unknown) {
+  console.error("Error handling phone number subscription success:", error);
+
+  const url = new URL(`${WEBAPP_URL}/workflows`);
+  url.searchParams.set("error", "true");
+
+  if (error instanceof HttpError) {
+    url.searchParams.set("message", error.message);
+  } else {
+    url.searchParams.set("message", "An error occurred while processing your subscription");
+  }
+
+  return NextResponse.redirect(url.toString());
+}
+
+export const GET = defaultResponderForAppDir(handler);

apps/web/app/api/webhooks/retell-ai/route.ts

@@ -0,0 +1,194 @@
+import { defaultResponderForAppDir } from "app/api/defaultResponderForAppDir";
+import type { NextRequest } from "next/server";
+import { NextResponse } from "next/server";
+import { Retell } from "retell-sdk";
+import { z } from "zod";
+
+import { CreditService } from "@calcom/features/ee/billing/credit-service";
+import { RETELL_API_KEY } from "@calcom/lib/constants";
+import logger from "@calcom/lib/logger";
+import { safeStringify } from "@calcom/lib/safeStringify";
+import { prisma } from "@calcom/prisma";
+
+const log = logger.getSubLogger({ prefix: ["retell-ai-webhook"] });
+
+const RetellWebhookSchema = z.object({
+  event: z.enum(["call_started", "call_ended", "call_analyzed"]),
+  call: z
+    .object({
+      call_id: z.string(),
+      agent_id: z.string().optional(),
+      from_number: z.string(),
+      to_number: z.string(),
+      direction: z.enum(["inbound", "outbound"]),
+      call_status: z.string(),
+      start_timestamp: z.number(),
+      end_timestamp: z.number().optional(),
+      disconnection_reason: z.string().optional(),
+      metadata: z.record(z.any()).optional(),
+      retell_llm_dynamic_variables: z.record(z.any()).optional(),
+      transcript: z.string().optional(),
+      opt_out_sensitive_data_storage: z.boolean().optional(),
+      call_cost: z
+        .object({
+          product_costs: z
+            .array(
+              z.object({
+                product: z.string(),
+                unitPrice: z.number().optional(),
+                cost: z.number().optional(),
+              })
+            )
+            .optional(),
+          total_duration_seconds: z.number().optional(),
+          total_duration_unit_price: z.number().optional(),
+          total_one_time_price: z.number().optional(),
+          combined_cost: z.number().optional(),
+        })
+        .optional(),
+      call_analysis: z
+        .object({
+          call_summary: z.string().optional(),
+          in_voicemail: z.boolean().optional(),
+          user_sentiment: z.string().optional(),
+          call_successful: z.boolean().optional(),
+          custom_analysis_data: z.record(z.any()).optional(),
+        })
+        .optional(),
+    })
+    .passthrough(),
+});
+
+async function handleCallAnalyzed(callData: any) {
+  const { from_number, call_id, call_cost } = callData;
+  if (!call_cost || typeof call_cost.combined_cost !== "number") {
+    log.error(`No call_cost.combined_cost in payload for call ${call_id}`);
+    return;
+  }
+
+  const phoneNumber = await prisma.calAiPhoneNumber.findFirst({
+    where: { phoneNumber: from_number },
+    include: {
+      user: { select: { id: true, email: true, name: true } },
+      team: { select: { id: true, name: true } },
+    },
+  });
+
+  if (!phoneNumber) {
+    log.error(`No phone number found for ${from_number}, cannot deduct credits`);
+    return;
+  }
+
+  // Support both personal and team phone numbers
+  const userId = phoneNumber.userId;
+  const teamId = phoneNumber.teamId;
+
+  if (!userId && !teamId) {
+    log.error(`Phone number ${from_number} has no associated user or team`);
+    return;
+  }
+
+  const baseCost = call_cost.combined_cost; // in cents
+  const creditsToDeduct = Math.ceil(baseCost * 1.8);
+
+  const creditService = new CreditService();
+  const hasCredits = await creditService.hasAvailableCredits({ userId, teamId });
+  if (!hasCredits) {
+    log.error(
+      `${
+        teamId ? `Team ${teamId}` : `User ${userId}`
+      } has insufficient credits for call ${call_id} (${creditsToDeduct} credits needed)`
+    );
+    return;
+  }
+
+  await creditService.chargeCredits({
+    userId: userId ?? undefined,
+    teamId: teamId ?? undefined,
+    credits: creditsToDeduct,
+  });
+
+  return {
+    success: true,
+    message: `Successfully charged ${creditsToDeduct} credits for ${
+      teamId ? `team ${teamId}` : `user ${userId}`
+    }, call ${call_id} (base cost: ${baseCost} cents)`,
+  };
+}
+
+/**
+ * Retell AI Webhook Handler
+ *
+ * Setup Instructions:
+ * 1. Add this webhook URL to your Retell AI dashboard: https://yourdomain.com/api/webhooks/retell-ai
+ * 2. Ensure your domain is accessible from the internet (for local development, use ngrok or similar)
+ * 3. Set the RETELL_API_KEY environment variable with your Retell API key (must have webhook badge)
+ *
+ * This webhook will:
+ * - Verify webhook signature for security
+ * - Receive call_analyzed events from Retell AI
+ * - Charge credits based on the call cost from the user's or team's credit balance
+ * - Log all transactions for audit purposes
+ */
+async function handler(request: NextRequest) {
+  // Get the raw body for signature verification
+  const rawBody = await request.text();
+  const body = JSON.parse(rawBody);
+
+  // Verify webhook signature
+  const signature = request.headers.get("x-retell-signature");
+  const apiKey = RETELL_API_KEY;
+
+  if (!signature || !apiKey) {
+    log.error("Missing signature or API key for webhook verification");
+    return NextResponse.json(
+      {
+        error: "Unauthorized",
+        message: "Missing signature or API key",
+      },
+      { status: 401 }
+    );
+  }
+
+  if (!Retell.verify(rawBody, apiKey, signature)) {
+    log.error("Invalid webhook signature");
+    return NextResponse.json(
+      {
+        error: "Unauthorized",
+        message: "Invalid signature",
+      },
+      { status: 401 }
+    );
+  }
+
+  if (body.event !== "call_analyzed") {
+    return NextResponse.json({
+      success: true,
+      message: `No handling for ${body.event} for call ${body.call?.call_id ?? "unknown"}`,
+    });
+  }
+
+  try {
+    const payload = RetellWebhookSchema.parse(body);
+    const callData = payload.call;
+    log.info(`Received Retell AI webhook: ${payload.event} for call ${callData.call_id}`);
+
+    const result = await handleCallAnalyzed(callData);
+
+    return NextResponse.json({
+      success: true,
+      message: result?.message ?? `Processed ${payload.event} for call ${callData.call_id}`,
+    });
+  } catch (error) {
+    log.error("Error processing Retell AI webhook:", safeStringify(error));
+    return NextResponse.json(
+      {
+        error: "Internal server error",
+        message: error instanceof Error ? error.message : "Unknown error",
+      },
+      { status: 500 }
+    );
+  }
+}
+
+export const POST = defaultResponderForAppDir(handler);

apps/web/package.json

@@ -138,6 +138,7 @@
     "react-use-intercom": "1.5.1",
     "recoil": "^0.7.7",
     "remove-markdown": "^0.5.0",
+    "retell-sdk": "^4.40.0",
     "rrule": "^2.7.1",
     "sanitize-html": "^2.10.0",
     "schema-dts": "^1.1.0",

apps/web/pages/api/trpc/ai/[trpc].ts

@@ -0,0 +1,4 @@
+import { createNextApiHandler } from "@calcom/trpc/server/createNextApiHandler";
+import { aiRouter } from "@calcom/trpc/server/routers/viewer/ai/_router";
+
+export default createNextApiHandler(aiRouter);

apps/web/pages/api/trpc/phoneNumber/[trpc].ts

@@ -0,0 +1,4 @@
+import { createNextApiHandler } from "@calcom/trpc/server/createNextApiHandler";
+import { phoneNumberRouter } from "@calcom/trpc/server/routers/viewer/phoneNumber/_router";
+
+export default createNextApiHandler(phoneNumberRouter);