feat(api): use db models + providers

apps/admin/src/lib/api/v1.d.ts

@@ -207,6 +207,46 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/internal/models": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get all models
+         * @description Returns all models with their provider mappings, sorted by createdAt descending
+         */
+        get: operations["internal_get_models"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/internal/providers": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get all providers
+         * @description Returns all providers, sorted by createdAt descending
+         */
+        get: operations["internal_get_providers"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/user/me": {
         parameters: {
             query?: never;
@@ -3542,4 +3582,105 @@ export interface components {
     pathItems: never;
 }
 export type $defs = Record<string, never>;
-export type operations = Record<string, never>;
+export interface operations {
+    internal_get_models: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of all models with their provider mappings */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        models: {
+                            id: string;
+                            createdAt: string | null;
+                            releasedAt: string | null;
+                            name: string | null;
+                            aliases: string[] | null;
+                            description: string | null;
+                            family: string;
+                            free: boolean | null;
+                            output: string[] | null;
+                            /** @enum {string|null} */
+                            stability: "stable" | "beta" | "unstable" | "experimental" | null;
+                            /** @enum {string} */
+                            status: "active" | "inactive";
+                            mappings: {
+                                id: string;
+                                createdAt: string | null;
+                                modelId: string;
+                                providerId: string;
+                                modelName: string;
+                                inputPrice: string | null;
+                                outputPrice: string | null;
+                                cachedInputPrice: string | null;
+                                imageInputPrice: string | null;
+                                requestPrice: string | null;
+                                contextSize: number | null;
+                                maxOutput: number | null;
+                                streaming: boolean;
+                                vision: boolean | null;
+                                reasoning: boolean | null;
+                                reasoningOutput: string | null;
+                                tools: boolean | null;
+                                jsonOutput: boolean | null;
+                                jsonOutputSchema: boolean | null;
+                                webSearch: boolean | null;
+                                discount: string | null;
+                                /** @enum {string|null} */
+                                stability: "stable" | "beta" | "unstable" | "experimental" | null;
+                                supportedParameters: string[] | null;
+                                deprecatedAt: string | null;
+                                deactivatedAt: string | null;
+                                /** @enum {string} */
+                                status: "active" | "inactive";
+                            }[];
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+    internal_get_providers: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description List of all providers */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        providers: {
+                            id: string;
+                            createdAt: string | null;
+                            name: string | null;
+                            description: string | null;
+                            streaming: boolean | null;
+                            cancellation: boolean | null;
+                            color: string | null;
+                            website: string | null;
+                            announcement: string | null;
+                            /** @enum {string} */
+                            status: "active" | "inactive";
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+}

apps/api/src/index.ts

@@ -20,6 +20,7 @@ import { authHandler } from "./auth/handler.js";
 import { tracingMiddleware } from "./middleware/tracing.js";
 import { beacon } from "./routes/beacon.js";
 import { routes } from "./routes/index.js";
+import { internalModels } from "./routes/internal-models.js";
 import { referral } from "./routes/referral.js";
 import { stripeRoutes } from "./stripe.js";
 
@@ -181,6 +182,8 @@ app.route("/", beacon);
 
 app.route("/", referral);
 
+app.route("/internal", internalModels);
+
 app.doc("/json", config);
 
 app.get("/docs", swaggerUI({ url: "./json" }));

apps/api/src/routes/internal-models.ts

@@ -0,0 +1,152 @@
+import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { z } from "zod";
+
+import { db } from "@llmgateway/db";
+
+import type { ServerTypes } from "@/vars.js";
+
+export const internalModels = new OpenAPIHono<ServerTypes>();
+
+// Provider schema
+const providerSchema = z.object({
+	id: z.string(),
+	createdAt: z.coerce.date(),
+	name: z.string().nullable(),
+	description: z.string().nullable(),
+	streaming: z.boolean().nullable(),
+	cancellation: z.boolean().nullable(),
+	color: z.string().nullable(),
+	website: z.string().nullable(),
+	announcement: z.string().nullable(),
+	status: z.enum(["active", "inactive"]),
+});
+
+// Model provider mapping schema
+const modelProviderMappingSchema = z.object({
+	id: z.string(),
+	createdAt: z.coerce.date(),
+	modelId: z.string(),
+	providerId: z.string(),
+	modelName: z.string(),
+	inputPrice: z.string().nullable(),
+	outputPrice: z.string().nullable(),
+	cachedInputPrice: z.string().nullable(),
+	imageInputPrice: z.string().nullable(),
+	requestPrice: z.string().nullable(),
+	contextSize: z.number().nullable(),
+	maxOutput: z.number().nullable(),
+	streaming: z.boolean(),
+	vision: z.boolean().nullable(),
+	reasoning: z.boolean().nullable(),
+	reasoningOutput: z.string().nullable(),
+	tools: z.boolean().nullable(),
+	jsonOutput: z.boolean().nullable(),
+	jsonOutputSchema: z.boolean().nullable(),
+	webSearch: z.boolean().nullable(),
+	discount: z.string().nullable(),
+	stability: z.enum(["stable", "beta", "unstable", "experimental"]).nullable(),
+	supportedParameters: z.array(z.string()).nullable(),
+	deprecatedAt: z.coerce.date().nullable(),
+	deactivatedAt: z.coerce.date().nullable(),
+	status: z.enum(["active", "inactive"]),
+});
+
+// Model schema with mappings
+const modelSchema = z.object({
+	id: z.string(),
+	createdAt: z.coerce.date(),
+	releasedAt: z.coerce.date().nullable(),
+	name: z.string().nullable(),
+	aliases: z.array(z.string()).nullable(),
+	description: z.string().nullable(),
+	family: z.string(),
+	free: z.boolean().nullable(),
+	output: z.array(z.string()).nullable(),
+	stability: z.enum(["stable", "beta", "unstable", "experimental"]).nullable(),
+	status: z.enum(["active", "inactive"]),
+	mappings: z.array(modelProviderMappingSchema),
+});
+
+// GET /internal/models - Returns models with mappings sorted by createdAt desc
+const getModelsRoute = createRoute({
+	operationId: "internal_get_models",
+	summary: "Get all models",
+	description:
+		"Returns all models with their provider mappings, sorted by createdAt descending",
+	method: "get",
+	path: "/models",
+	request: {},
+	responses: {
+		200: {
+			content: {
+				"application/json": {
+					schema: z.object({
+						models: z.array(modelSchema),
+					}),
+				},
+			},
+			description: "List of all models with their provider mappings",
+		},
+	},
+});
+
+internalModels.openapi(getModelsRoute, async (c) => {
+	const models = await db.query.model.findMany({
+		where: {
+			status: { eq: "active" },
+		},
+		with: {
+			modelProviderMappings: {
+				where: {
+					status: { eq: "active" },
+				},
+			},
+		},
+		orderBy: {
+			createdAt: "desc",
+		},
+	});
+
+	// Transform to match expected schema (rename modelProviderMappings to mappings)
+	const transformedModels = models.map((model) => ({
+		...model,
+		mappings: model.modelProviderMappings,
+	}));
+
+	return c.json({ models: transformedModels });
+});
+
+// GET /internal/providers - Returns providers sorted by createdAt desc
+const getProvidersRoute = createRoute({
+	operationId: "internal_get_providers",
+	summary: "Get all providers",
+	description: "Returns all providers, sorted by createdAt descending",
+	method: "get",
+	path: "/providers",
+	request: {},
+	responses: {
+		200: {
+			content: {
+				"application/json": {
+					schema: z.object({
+						providers: z.array(providerSchema),
+					}),
+				},
+			},
+			description: "List of all providers",
+		},
+	},
+});
+
+internalModels.openapi(getProvidersRoute, async (c) => {
+	const providers = await db.query.provider.findMany({
+		where: {
+			status: { eq: "active" },
+		},
+		orderBy: {
+			createdAt: "desc",
+		},
+	});
+
+	return c.json({ providers });
+});

apps/playground/src/app/group/page.tsx

@@ -3,10 +3,9 @@ import { notFound } from "next/navigation";
 
 import { LastUsedProjectTracker } from "@/components/last-used-project-tracker";
 import GroupChatClient from "@/components/playground/group-chat-client";
+import { fetchModels, fetchProviders } from "@/lib/fetch-models";
 import { fetchServerData } from "@/lib/server-api";
 
-import { models, providers } from "@llmgateway/models";
-
 import type { Project, Organization } from "@/lib/types";
 
 export interface GatewayModel {
@@ -24,6 +23,12 @@ export default async function GroupPage({
 }) {
 	const { orgId, projectId } = await searchParams;
 
+	// Fetch models and providers from API
+	const [models, providers] = await Promise.all([
+		fetchModels(),
+		fetchProviders(),
+	]);
+
 	// Fetch organizations server-side
 	const initialOrganizationsData = await fetchServerData("GET", "/orgs");
 

apps/playground/src/app/page.tsx

@@ -3,10 +3,9 @@ import { notFound, redirect } from "next/navigation";
 
 import { LastUsedProjectTracker } from "@/components/last-used-project-tracker";
 import ChatPageClient from "@/components/playground/chat-page-client";
+import { fetchModels, fetchProviders } from "@/lib/fetch-models";
 import { fetchServerData } from "@/lib/server-api";
 
-import { models, providers } from "@llmgateway/models";
-
 import type { Project, Organization } from "@/lib/types";
 
 export interface GatewayModel {
@@ -128,6 +127,12 @@ export default async function ChatPage({
 
 	const projects = (initialProjectsData?.projects || []) as Project[];
 
+	// Fetch models and providers from API
+	const [models, providers] = await Promise.all([
+		fetchModels(),
+		fetchProviders(),
+	]);
+
 	// Determine selected project: URL > cookie > first
 	let selectedProject: Project | null = null;
 	if (projectId) {