Refactor apps/api service

apps/api/src/billing.ts

@@ -1,8 +1,8 @@
 // https://github.com/t3dotgg/stripe-recommendations/blob/main/README.md
 import Stripe from "stripe";
 
-import { stripe } from "./stripe";
-import { supabaseAdmin } from "./supabase";
+import { stripe } from "./integration/stripe";
+import { supabaseAdmin } from "./integration/supabase";
 
 const HANDLED_EVENTS: Stripe.Event.Type[] = [
   "checkout.session.completed",

apps/api/src/hono-bindings.ts

@@ -1,7 +1,9 @@
+import type * as Sentry from "@sentry/bun";
 import type Stripe from "stripe";
 
 export type AppBindings = {
   Variables: {
     stripeEvent: Stripe.Event;
+    sentrySpan: Sentry.Span;
   };
 };

apps/api/src/index.ts

@@ -11,11 +11,13 @@ import { logger } from "hono/logger";
 
 import { env } from "./env";
 import type { AppBindings } from "./hono-bindings";
-import { loadTestOverride } from "./load-test-auth";
+import {
+  loadTestOverride,
+  sentryMiddleware,
+  supabaseAuthMiddleware,
+  verifyStripeWebhook,
+} from "./middleware";
 import { API_TAGS, routes } from "./routes";
-import { sentryMiddleware } from "./sentry/middleware";
-import { verifyStripeWebhook } from "./stripe";
-import { requireSupabaseAuth } from "./supabase";
 
 const app = new Hono<AppBindings>();
 
@@ -44,12 +46,12 @@ app.use("*", (c, next) => {
   return corsMiddleware(c, next);
 });
 
-app.use("/chat/completions", loadTestOverride, requireSupabaseAuth);
+app.use("/chat/completions", loadTestOverride, supabaseAuthMiddleware);
 app.use("/webhook/stripe", verifyStripeWebhook);
 
 if (env.NODE_ENV !== "development") {
-  app.use("/listen", loadTestOverride, requireSupabaseAuth);
-  app.use("/transcribe", loadTestOverride, requireSupabaseAuth);
+  app.use("/listen", loadTestOverride, supabaseAuthMiddleware);
+  app.use("/transcribe", loadTestOverride, supabaseAuthMiddleware);
 }
 
 app.route("/", routes);

apps/api/src/integration/index.ts

@@ -0,0 +1,4 @@
+export * from "./supabase";
+export * from "./stripe";
+export * from "./openrouter";
+export * from "./posthog";

apps/api/src/integration/openrouter.ts

@@ -0,0 +1,23 @@
+import { OpenAI as PostHogOpenAI } from "@posthog/ai";
+
+import { env } from "../env";
+import { posthog } from "./posthog";
+
+export const openai = new PostHogOpenAI({
+  baseURL: "https://openrouter.ai/api/v1",
+  apiKey: env.OPENROUTER_API_KEY,
+  posthog,
+});
+
+const MODELS = {
+  toolCalling: [
+    "moonshotai/kimi-k2-0905:exacto",
+    "anthropic/claude-haiku-4.5",
+    "openai/gpt-oss-120b:exacto",
+  ],
+  default: ["moonshotai/kimi-k2-0905", "openai/gpt-5.1-chat"],
+} as const;
+
+export function getModels(needsToolCalling: boolean): string[] {
+  return needsToolCalling ? [...MODELS.toolCalling] : [...MODELS.default];
+}

apps/api/src/posthog.ts → apps/api/src/integration/posthog.ts

@@ -1,6 +1,6 @@
 import { PostHog } from "posthog-node";
 
-import { env } from "./env";
+import { env } from "../env";
 
 export const posthog = new PostHog(env.POSTHOG_API_KEY, {
   host: "https://us.i.posthog.com",

apps/api/src/integration/stripe.ts

@@ -0,0 +1,7 @@
+import Stripe from "stripe";
+
+import { env } from "../env";
+
+export const stripe = new Stripe(env.STRIPE_SECRET_KEY, {
+  apiVersion: "2025-10-29.clover",
+});

apps/api/src/integration/supabase.ts

@@ -0,0 +1,8 @@
+import { createClient } from "@supabase/supabase-js";
+
+import { env } from "../env";
+
+export const supabaseAdmin = createClient(
+  env.SUPABASE_URL,
+  env.SUPABASE_SERVICE_ROLE_KEY,
+);

apps/api/src/listen.ts

@@ -2,7 +2,7 @@ import * as Sentry from "@sentry/bun";
 import type { Handler } from "hono";
 import { upgradeWebSocket } from "hono/bun";
 
-import { Metrics } from "./sentry/metrics";
+import { Metrics } from "./metrics";
 import {
   createProxyFromRequest,
   normalizeWsData,

apps/api/src/sentry/metrics.ts → apps/api/src/metrics.ts

@@ -1,35 +1,43 @@
 import * as Sentry from "@sentry/bun";
 
-export const Metrics = {
+const billing = {
+  billingSync: (success: boolean, eventType: string) => {
+    Sentry.metrics.count("billing.sync", 1, {
+      attributes: { success: String(success), event_type: eventType },
+    });
+  },
+};
+
+const stt = {
   websocketConnected: (provider: string) => {
     Sentry.metrics.count("websocket.connected", 1, {
       attributes: { provider },
     });
   },
-
   websocketDisconnected: (provider: string, durationMs: number) => {
     Sentry.metrics.distribution("websocket.duration", durationMs, {
       unit: "millisecond",
       attributes: { provider },
     });
   },
+};
 
-  billingSync: (success: boolean, eventType: string) => {
-    Sentry.metrics.count("billing.sync", 1, {
-      attributes: { success: String(success), event_type: eventType },
-    });
-  },
-
+const llm = {
   chatCompletion: (streaming: boolean, statusCode: number) => {
     Sentry.metrics.count("chat.completion", 1, {
       attributes: { streaming: String(streaming), status: String(statusCode) },
     });
   },
+};
 
+export const Metrics = {
+  ...stt,
+  ...llm,
   upstreamLatency: (provider: string, durationMs: number) => {
     Sentry.metrics.distribution("upstream.latency", durationMs, {
       unit: "millisecond",
       attributes: { provider },
     });
   },
+  ...billing,
 };

apps/api/src/middleware/index.ts

@@ -0,0 +1,4 @@
+export * from "./load-test-auth";
+export * from "./sentry";
+export * from "./supabase";
+export * from "./stripe";

apps/api/src/load-test-auth.ts → apps/api/src/middleware/load-test-auth.ts

@@ -1,6 +1,6 @@
 import { createMiddleware } from "hono/factory";
 
-import { env } from "./env";
+import { env } from "../env";
 
 export const loadTestOverride = createMiddleware<{
   Variables: { supabaseUserId: string };

apps/api/src/middleware/sentry.ts

@@ -0,0 +1,29 @@
+import * as Sentry from "@sentry/bun";
+import { createMiddleware } from "hono/factory";
+
+import type { AppBindings } from "../hono-bindings";
+
+export const sentryMiddleware = createMiddleware<AppBindings>(
+  async (c, next) => {
+    const sentryTrace = c.req.header("sentry-trace");
+    const baggage = c.req.header("baggage");
+
+    return Sentry.continueTrace({ sentryTrace, baggage }, async () => {
+      return Sentry.startSpan(
+        {
+          name: `${c.req.method} ${c.req.path}`,
+          op: "http.server",
+          attributes: {
+            "http.method": c.req.method,
+            "http.url": c.req.url,
+          },
+        },
+        async (span) => {
+          c.set("sentrySpan", span);
+          await next();
+          span.setAttribute("http.status_code", c.res.status);
+        },
+      );
+    });
+  },
+);

apps/api/src/stripe.ts → apps/api/src/middleware/stripe.ts

@@ -2,11 +2,8 @@ import * as Sentry from "@sentry/bun";
 import { createMiddleware } from "hono/factory";
 import Stripe from "stripe";
 
-import { env } from "./env";
-
-export const stripe = new Stripe(env.STRIPE_SECRET_KEY, {
-  apiVersion: "2025-10-29.clover",
-});
+import { env } from "../env";
+import { stripe } from "../integration/stripe";
 
 const cryptoProvider = Stripe.createSubtleCryptoProvider();
 

apps/api/src/supabase.ts → apps/api/src/middleware/supabase.ts

@@ -1,14 +1,9 @@
 import { createClient } from "@supabase/supabase-js";
 import { createMiddleware } from "hono/factory";
 
-import { env } from "./env";
+import { env } from "../env";
 
-export const supabaseAdmin = createClient(
-  env.SUPABASE_URL,
-  env.SUPABASE_SERVICE_ROLE_KEY,
-);
-
-export const requireSupabaseAuth = createMiddleware<{
+export const supabaseAuthMiddleware = createMiddleware<{
   Variables: { supabaseUserId: string };
 }>(async (c, next) => {
   const authHeader = c.req.header("Authorization");