Feat : Skills

src/app/(dashboard)/dashboard/endpoint/EndpointPageClient.js

@@ -665,7 +665,10 @@ export default function APIPageClient({ machineId }) {
     <div className="flex flex-col gap-8">
       {/* Endpoint Card */}
       <Card>
-        <h2 className="text-lg font-semibold mb-4">API Endpoint</h2>
+        <h2 className="text-lg font-semibold mb-4 flex items-center gap-2">
+          <span className="material-symbols-outlined text-primary">api</span>
+          API Endpoint
+        </h2>
 
         {/* Endpoint rows */}
         <div className="flex flex-col gap-2">
@@ -851,7 +854,10 @@ export default function APIPageClient({ machineId }) {
       {/* Token Saver (RTK + Caveman) */}
       <Card id="rtk">
         <div className="flex items-center justify-between mb-2">
-          <h2 className="text-lg font-semibold">Token Saver</h2>
+          <h2 className="text-lg font-semibold flex items-center gap-2">
+            <span className="material-symbols-outlined text-primary">bolt</span>
+            Token Saver
+          </h2>
         </div>
         <div className="flex items-center justify-between pt-2 pb-4 border-b border-border gap-4">
           <div className="min-w-0 flex-1">
@@ -922,7 +928,10 @@ export default function APIPageClient({ machineId }) {
       {/* API Keys */}
       <Card id="require-api-key">
         <div className="flex items-center justify-between mb-4">
-          <h2 className="text-lg font-semibold">API Keys</h2>
+          <h2 className="text-lg font-semibold flex items-center gap-2">
+            <span className="material-symbols-outlined text-primary">vpn_key</span>
+            API Keys
+          </h2>
           <Button icon="add" onClick={() => setShowAddModal(true)}>
             Create Key
           </Button>

src/app/(dashboard)/dashboard/media-providers/[kind]/[id]/page.js

@@ -885,6 +885,10 @@ function GenericExampleCard({ providerId, kind }) {
 
   // Get models for this kind (e.g., type="image")
   const kindModels = getModelsByProviderId(providerId).filter((m) => m.type === kind);
+  // Kinds that need a model identifier in the request (image/video/music)
+  const KIND_NEEDS_MODEL = new Set(["image", "video", "music", "stt", "imageToText"]);
+  const needsModel = KIND_NEEDS_MODEL.has(kind);
+  const allowManualModel = needsModel && kindModels.length === 0;
   const [selectedModel, setSelectedModel] = useState(kindModels[0]?.id ?? "");
   const selectedModelObj = kindModels.find((m) => m.id === selectedModel);
   const supportsEdit = !!selectedModelObj?.capabilities?.includes("edit");
@@ -935,8 +939,10 @@ function GenericExampleCard({ providerId, kind }) {
 
   const endpoint = useTunnel ? tunnelEndpoint : localEndpoint;
   const apiPath = kindConfig.endpoint.path;
-  // For kinds without model concept (webSearch/webFetch), use providerAlias directly
-  const modelFull = kindModels.length === 0 ? providerAlias : (selectedModel ? `${providerAlias}/${selectedModel}` : "");
+  // webSearch/webFetch: use providerAlias only. Other kinds: append model when present.
+  const modelFull = !needsModel
+    ? providerAlias
+    : (selectedModel ? `${providerAlias}/${selectedModel}` : (allowManualModel ? "" : providerAlias));
 
   // Build request body with optional extra fields (only non-empty values)
   const extraBodyFromFields = Object.entries(extraValues).reduce((acc, [k, v]) => {
@@ -1060,8 +1066,8 @@ function GenericExampleCard({ providerId, kind }) {
     <Card>
       <h2 className="text-lg font-semibold mb-4">Example</h2>
       <div className="flex flex-col gap-2.5">
-        {/* Model selector - only show if models available */}
-        {kindModels.length > 0 && (
+        {/* Model selector — dropdown if presets exist, else manual input for media kinds */}
+        {kindModels.length > 0 ? (
           <Row label="Model">
             <select
               value={selectedModel}
@@ -1073,7 +1079,16 @@ function GenericExampleCard({ providerId, kind }) {
               ))}
             </select>
           </Row>
-        )}
+        ) : allowManualModel ? (
+          <Row label="Model">
+            <input
+              value={selectedModel}
+              onChange={(e) => setSelectedModel(e.target.value)}
+              placeholder="Enter model id (provider-specific)"
+              className="w-full px-3 py-1.5 text-sm border border-border rounded-lg bg-background focus:outline-none focus:border-primary font-mono"
+            />
+          </Row>
+        ) : null}
 
         {/* Endpoint */}
         <Row label="Endpoint">

src/app/(dashboard)/dashboard/skills/page.js

@@ -0,0 +1,112 @@
+"use client";
+
+import { Card, Badge } from "@/shared/components";
+import { useCopyToClipboard } from "@/shared/hooks/useCopyToClipboard";
+import {
+  SKILLS,
+  SKILLS_REPO_URL,
+  getSkillRawUrl,
+  getSkillBlobUrl,
+} from "@/shared/constants/skills";
+
+function CopyButton({ value, label = "Copy link" }) {
+  const { copied, copy } = useCopyToClipboard(2000);
+  return (
+    <button
+      onClick={() => copy(value)}
+      className="px-2 py-1 rounded-md bg-primary text-white text-[11px] font-medium hover:bg-primary/90 transition-colors cursor-pointer shrink-0 inline-flex items-center gap-1"
+      title={value}
+    >
+      <span className="material-symbols-outlined text-[12px]">
+        {copied ? "check" : "content_copy"}
+      </span>
+      {copied ? "Copied!" : label}
+    </button>
+  );
+}
+
+function SkillRow({ skill }) {
+  const url = getSkillRawUrl(skill.id);
+  return (
+    <div
+      className={`flex items-start gap-3 p-3 rounded-lg border transition-colors ${
+        skill.isEntry
+          ? "border-primary/40 bg-primary/5"
+          : "border-border-subtle hover:bg-surface-2"
+      }`}
+    >
+      <div
+        className={`size-9 rounded-lg flex items-center justify-center shrink-0 ${
+          skill.isEntry ? "bg-primary text-white" : "bg-primary/10 text-primary"
+        }`}
+      >
+        <span className="material-symbols-outlined text-[18px]">{skill.icon}</span>
+      </div>
+
+      <div className="min-w-0 flex-1">
+        <div className="flex items-center gap-2 flex-wrap">
+          <h3 className="font-semibold text-sm text-text-main">{skill.name}</h3>
+          {skill.isEntry && (
+            <Badge variant="primary" size="sm">START HERE</Badge>
+          )}
+          {skill.endpoint && (
+            <Badge variant="default" size="sm">
+              <code className="text-[10px]">{skill.endpoint}</code>
+            </Badge>
+          )}
+        </div>
+        <p className="text-xs text-text-muted mt-0.5">{skill.description}</p>
+        <a
+          href={getSkillBlobUrl(skill.id)}
+          target="_blank"
+          rel="noreferrer"
+          className="text-[11px] text-text-muted hover:text-primary mt-1 inline-flex items-center gap-1 break-all"
+        >
+          {url}
+          <span className="material-symbols-outlined text-[12px]">open_in_new</span>
+        </a>
+      </div>
+
+      <CopyButton value={url} />
+    </div>
+  );
+}
+
+export default function SkillsPage() {
+  return (
+    <div className="max-w-4xl mx-auto space-y-6">
+      <Card padding="md">
+        <div className="text-xs text-text-muted mb-2">Paste this to your AI:</div>
+        <div className="px-3 py-2 rounded bg-surface-2 font-mono text-[12px] text-text-main">
+          Read this skill and use it: {getSkillRawUrl("9router")}
+        </div>
+      </Card>
+
+      <div className="space-y-2">
+        {SKILLS.map((skill) => (
+          <SkillRow key={skill.id} skill={skill} />
+        ))}
+      </div>
+
+      <Card padding="md">
+        <div className="flex items-center justify-between gap-3 flex-wrap">
+          <div>
+            <h2 className="text-sm font-semibold text-text-main">More on GitHub</h2>
+            <p className="text-xs text-text-muted mt-0.5">
+              Browse source, README, and examples.
+            </p>
+          </div>
+          <a
+            href={`${SKILLS_REPO_URL}/tree/main/app/skills`}
+            target="_blank"
+            rel="noreferrer"
+            className="text-sm text-primary hover:underline inline-flex items-center gap-1"
+          >
+            <span className="material-symbols-outlined text-[16px]">open_in_new</span>
+            View on GitHub
+          </a>
+        </div>
+      </Card>
+    </div>
+  );
+}

src/app/api/providers/validate/route.js

@@ -40,38 +40,40 @@ async function probeWebProvider(provider, apiKey) {
   return res.status !== 401 && res.status !== 403;
 }
 
-// Probe a tts/embedding provider using ttsConfig/embeddingConfig.
-// Returns true if API key is accepted (status !== 401 && !== 403); null to skip.
+// Probe a media provider (tts/embedding/stt/image/video) using *Config.
+// Returns true if API key is accepted; null to skip (let default handler decide).
 async function probeMediaProvider(provider, apiKey) {
   const p = AI_PROVIDERS[provider];
   if (!p) return null;
-  // Only probe providers that are media-only (not LLM dual-purpose, let LLM validate handle those)
+  const MEDIA_KINDS = new Set(["tts", "embedding", "stt", "image", "video", "music", "imageToText"]);
   const kinds = p.serviceKinds || ["llm"];
-  const isMediaOnly = kinds.every((k) => k === "tts" || k === "embedding" || k === "stt");
+  const isMediaOnly = kinds.every((k) => MEDIA_KINDS.has(k));
   if (!isMediaOnly) return null;
-  const cfg = p.ttsConfig || p.embeddingConfig;
-  if (!cfg) return null;
+  const cfg = p.ttsConfig || p.embeddingConfig || p.imageConfig || p.videoConfig || p.musicConfig;
+  // No probe config → best-effort accept (validate at usage time)
+  if (!cfg) return true;
   if (p.noAuth || cfg.authType === "none") return true;
   // Skip auth schemes that need provider-specific data
-  if (cfg.authHeader === "playht" || cfg.authHeader === "aws-sigv4") return null;
+  if (cfg.authHeader === "playht" || cfg.authHeader === "aws-sigv4") return true;
 
-  const headers = { "Content-Type": "application/json" };
+  const headers = { "Content-Type": "application/json", ...(cfg.extraHeaders || {}) };
 
-  // Apply auth based on authHeader
   switch (cfg.authHeader) {
     case "bearer":     headers["Authorization"] = `Bearer ${apiKey}`; break;
+    case "key":        headers["Authorization"] = `Key ${apiKey}`; break;
     case "x-api-key":  headers["x-api-key"] = apiKey; break;
+    case "x-key":      headers["x-key"] = apiKey; break;
     case "xi-api-key": headers["xi-api-key"] = apiKey; break;
     case "token":      headers["Authorization"] = `Token ${apiKey}`; break;
     case "basic":      headers["Authorization"] = `Basic ${apiKey}`; break;
     default: return null;
   }
 
-  // Minimal POST body — server will reject auth before validating body
+  const method = cfg.method || "POST";
   const res = await fetch(cfg.baseUrl, {
-    method: "POST",
+    method,
     headers,
-    body: JSON.stringify({ input: "ping", text: "ping", model: cfg.models?.[0]?.id || "test" }),
+    body: method === "GET" ? undefined : JSON.stringify({ input: "ping", text: "ping", prompt: "ping", model: cfg.models?.[0]?.id || "test" }),
     signal: AbortSignal.timeout(8000),
   });
   return res.status !== 401 && res.status !== 403;

src/app/api/v1/models/[kind]/route.js

@@ -0,0 +1,55 @@
+import { buildModelsList } from "../route.js";
+
+// URL slug → service kind(s). `web` covers both webSearch and webFetch.
+const KIND_SLUG_MAP = {
+  "image": ["image"],
+  "tts": ["tts"],
+  "stt": ["stt"],
+  "embedding": ["embedding"],
+  "image-to-text": ["imageToText"],
+  "web": ["webSearch", "webFetch"],
+};
+
+export async function OPTIONS() {
+  return new Response(null, {
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, OPTIONS",
+      "Access-Control-Allow-Headers": "*",
+    },
+  });
+}
+
+/**
+ * GET /v1/models/{kind} - OpenAI-compatible models list filtered by capability.
+ * Supported kinds: image, tts, stt, embedding, image-to-text, web.
+ */
+export async function GET(_request, { params }) {
+  try {
+    const { kind } = await params;
+    const kindFilter = KIND_SLUG_MAP[kind];
+
+    if (!kindFilter) {
+      return Response.json(
+        {
+          error: {
+            message: `Unknown model kind: ${kind}. Supported: ${Object.keys(KIND_SLUG_MAP).join(", ")}`,
+            type: "invalid_request_error",
+          },
+        },
+        { status: 404, headers: { "Access-Control-Allow-Origin": "*" } }
+      );
+    }
+
+    const data = await buildModelsList(kindFilter);
+    return Response.json({ object: "list", data }, {
+      headers: { "Access-Control-Allow-Origin": "*" },
+    });
+  } catch (error) {
+    console.log("Error fetching models by kind:", error);
+    return Response.json(
+      { error: { message: error.message, type: "server_error" } },
+      { status: 500 }
+    );
+  }
+}

src/app/api/v1/models/route.js

@@ -1,5 +1,10 @@
 import { PROVIDER_MODELS, PROVIDER_ID_TO_ALIAS } from "@/shared/constants/models";
-import { getProviderAlias, isAnthropicCompatibleProvider, isOpenAICompatibleProvider } from "@/shared/constants/providers";
+import {
+  AI_PROVIDERS,
+  getProviderAlias,
+  isAnthropicCompatibleProvider,
+  isOpenAICompatibleProvider,
+} from "@/shared/constants/providers";
 import { getProviderConnections, getCombos, getCustomModels, getModelAliases } from "@/lib/localDb";
 
 const parseOpenAIStyleModels = (data) => {
@@ -10,6 +15,34 @@ const parseOpenAIStyleModels = (data) => {
 // Matches provider IDs that are upstream/cross-instance connections (contain a UUID suffix)
 const UPSTREAM_CONNECTION_RE = /[-_][0-9a-f]{8,}$/i;
 
+// LLM kind sentinel — combos/models with no explicit kind default to LLM
+const LLM_KIND = "llm";
+
+// Map per-model `type` field (in PROVIDER_MODELS) to service kind.
+// Models without `type` are treated as LLM.
+const MODEL_TYPE_TO_KIND = {
+  image: "image",
+  tts: "tts",
+  embedding: "embedding",
+  stt: "stt",
+  imageToText: "imageToText",
+};
+
+function modelKind(model) {
+  if (!model?.type) return LLM_KIND;
+  return MODEL_TYPE_TO_KIND[model.type] || LLM_KIND;
+}
+
+// For dynamic/unknown model IDs (compatible providers, alias map, custom models)
+// fall back to provider-level kind matching when per-model type is unavailable.
+function inferKindFromUnknownModelId(modelId) {
+  const lower = String(modelId).toLowerCase();
+  if (/embed/.test(lower)) return "embedding";
+  if (/tts|speech|audio|voice/.test(lower)) return "tts";
+  if (/image|imagen|dall-?e|flux|sdxl|sd-|stable-diffusion/.test(lower)) return "image";
+  return LLM_KIND;
+}
+
 async function fetchCompatibleModelIds(connection) {
   if (!connection?.apiKey) return [];
 
@@ -67,6 +100,271 @@ async function fetchCompatibleModelIds(connection) {
   }
 }
 
+// Provider matches kindFilter when its serviceKinds intersect the requested kinds.
+// LLM is the default kind for providers missing serviceKinds.
+function providerMatchesKinds(providerId, kindFilter) {
+  const provider = AI_PROVIDERS[providerId];
+  const kinds = Array.isArray(provider?.serviceKinds) && provider.serviceKinds.length > 0
+    ? provider.serviceKinds
+    : [LLM_KIND];
+  return kindFilter.some((k) => kinds.includes(k));
+}
+
+// Combo matches kindFilter when its `kind` field is in the list.
+// Combos with no kind are treated as LLM.
+function comboMatchesKinds(combo, kindFilter) {
+  const kind = combo?.kind || LLM_KIND;
+  return kindFilter.includes(kind);
+}
+
+/**
+ * Build OpenAI-format models list filtered by service kinds.
+ * @param {string[]} kindFilter - List of service kinds to include (e.g. ["llm"], ["webSearch","webFetch"]).
+ */
+export async function buildModelsList(kindFilter) {
+  let connections = [];
+  try {
+    connections = await getProviderConnections();
+    connections = connections.filter(c => c.isActive !== false);
+  } catch (e) {
+    console.log("Could not fetch providers, returning all models");
+  }
+
+  let combos = [];
+  try {
+    combos = await getCombos();
+  } catch (e) {
+    console.log("Could not fetch combos");
+  }
+
+  let customModels = [];
+  try {
+    customModels = await getCustomModels();
+  } catch (e) {
+    console.log("Could not fetch custom models");
+  }
+
+  let modelAliases = {};
+  try {
+    modelAliases = await getModelAliases();
+  } catch (e) {
+    console.log("Could not fetch model aliases");
+  }
+
+  const activeConnectionByProvider = new Map();
+  for (const conn of connections) {
+    if (!activeConnectionByProvider.has(conn.provider)) {
+      activeConnectionByProvider.set(conn.provider, conn);
+    }
+  }
+
+  const models = [];
+  const timestamp = Math.floor(Date.now() / 1000);
+
+  // Combos first (filtered by kind). Web combos expose `kind` so AI knows search vs fetch.
+  for (const combo of combos) {
+    if (!comboMatchesKinds(combo, kindFilter)) continue;
+    const entry = {
+      id: combo.name,
+      object: "model",
+      created: timestamp,
+      owned_by: "combo",
+    };
+    if (combo.kind === "webSearch" || combo.kind === "webFetch") {
+      entry.kind = combo.kind;
+    }
+    models.push(entry);
+  }
+
+  if (connections.length === 0) {
+    // DB unavailable -> return static models, filtered by per-model kind
+    const aliasToProviderId = Object.fromEntries(
+      Object.entries(PROVIDER_ID_TO_ALIAS).map(([id, alias]) => [alias, id])
+    );
+    for (const [alias, providerModels] of Object.entries(PROVIDER_MODELS)) {
+      const providerId = aliasToProviderId[alias] || alias;
+      if (!providerMatchesKinds(providerId, kindFilter)) continue;
+      for (const model of providerModels) {
+        if (!kindFilter.includes(modelKind(model))) continue;
+        models.push({
+          id: `${alias}/${model.id}`,
+          object: "model",
+          created: timestamp,
+          owned_by: alias,
+        });
+      }
+    }
+
+    for (const customModel of customModels) {
+      if (!customModel?.id || (customModel.type && customModel.type !== "llm")) continue;
+      // Custom models without active connection are LLM-only by current schema
+      if (!kindFilter.includes(LLM_KIND)) continue;
+      const providerAlias = customModel.providerAlias;
+      if (!providerAlias) continue;
+
+      const modelId = String(customModel.id).trim();
+      if (!modelId) continue;
+
+      models.push({
+        id: `${providerAlias}/${modelId}`,
+        object: "model",
+        created: timestamp,
+        owned_by: providerAlias,
+      });
+    }
+  } else {
+    for (const [providerId, conn] of activeConnectionByProvider.entries()) {
+      if (!providerMatchesKinds(providerId, kindFilter)) continue;
+
+      const staticAlias = PROVIDER_ID_TO_ALIAS[providerId] || providerId;
+      const outputAlias = (
+        conn?.providerSpecificData?.prefix
+        || getProviderAlias(providerId)
+        || staticAlias
+      ).trim();
+      const providerModels = PROVIDER_MODELS[staticAlias] || [];
+      const enabledModels = conn?.providerSpecificData?.enabledModels;
+      const hasExplicitEnabledModels =
+        Array.isArray(enabledModels) && enabledModels.length > 0;
+      const isCompatibleProvider =
+        isOpenAICompatibleProvider(providerId) || isAnthropicCompatibleProvider(providerId);
+
+      // Build kind lookup for static models so we can filter even when only IDs are exposed
+      const staticModelKindById = new Map(
+        providerModels.map((m) => [m.id, modelKind(m)])
+      );
+
+      let rawModelIds = hasExplicitEnabledModels
+        ? Array.from(
+            new Set(
+              enabledModels.filter(
+                (modelId) => typeof modelId === "string" && modelId.trim() !== "",
+              ),
+            ),
+          )
+        : providerModels.map((model) => model.id);
+
+      if (isCompatibleProvider && rawModelIds.length === 0 && !UPSTREAM_CONNECTION_RE.test(providerId)) {
+        rawModelIds = await fetchCompatibleModelIds(conn);
+      }
+
+      const modelIds = rawModelIds
+        .map((modelId) => {
+          if (modelId.startsWith(`${outputAlias}/`)) {
+            return modelId.slice(outputAlias.length + 1);
+          }
+          if (modelId.startsWith(`${staticAlias}/`)) {
+            return modelId.slice(staticAlias.length + 1);
+          }
+          if (modelId.startsWith(`${providerId}/`)) {
+            return modelId.slice(providerId.length + 1);
+          }
+          return modelId;
+        })
+        .filter((modelId) => typeof modelId === "string" && modelId.trim() !== "");
+
+      const customModelIds = customModels
+        .filter((m) => {
+          if (!m?.id || (m.type && m.type !== "llm")) return false;
+          const alias = m.providerAlias;
+          return alias === staticAlias || alias === outputAlias || alias === providerId;
+        })
+        .map((m) => String(m.id).trim())
+        .filter((modelId) => modelId !== "");
+
+      const aliasModelIds = Object.values(modelAliases || {})
+        .filter((fullModel) => {
+          if (typeof fullModel !== "string" || !fullModel.includes("/")) return false;
+          return (
+            fullModel.startsWith(`${outputAlias}/`) ||
+            fullModel.startsWith(`${staticAlias}/`) ||
+            fullModel.startsWith(`${providerId}/`)
+          );
+        })
+        .map((fullModel) => {
+          if (fullModel.startsWith(`${outputAlias}/`)) {
+            return fullModel.slice(outputAlias.length + 1);
+          }
+          if (fullModel.startsWith(`${staticAlias}/`)) {
+            return fullModel.slice(staticAlias.length + 1);
+          }
+          if (fullModel.startsWith(`${providerId}/`)) {
+            return fullModel.slice(providerId.length + 1);
+          }
+          return fullModel;
+        })
+        .filter((modelId) => typeof modelId === "string" && modelId.trim() !== "");
+
+      const mergedModelIds = Array.from(new Set([...modelIds, ...customModelIds, ...aliasModelIds]));
+
+      for (const modelId of mergedModelIds) {
+        // Resolve kind: prefer static metadata, otherwise infer from ID heuristics
+        const kind = staticModelKindById.get(modelId) || inferKindFromUnknownModelId(modelId);
+        if (!kindFilter.includes(kind)) continue;
+
+        models.push({
+          id: `${outputAlias}/${modelId}`,
+          object: "model",
+          created: timestamp,
+          owned_by: outputAlias,
+        });
+      }
+
+      // Merge sub-config models (TTS / embedding) that live on AI_PROVIDERS, not PROVIDER_MODELS
+      const providerInfo = AI_PROVIDERS[providerId];
+      const subConfigModels = [];
+      if (kindFilter.includes("tts") && Array.isArray(providerInfo?.ttsConfig?.models)) {
+        for (const m of providerInfo.ttsConfig.models) {
+          if (m?.id) subConfigModels.push(m.id);
+        }
+      }
+      if (kindFilter.includes("embedding") && Array.isArray(providerInfo?.embeddingConfig?.models)) {
+        for (const m of providerInfo.embeddingConfig.models) {
+          if (m?.id) subConfigModels.push(m.id);
+        }
+      }
+      for (const subId of subConfigModels) {
+        models.push({
+          id: `${outputAlias}/${subId}`,
+          object: "model",
+          created: timestamp,
+          owned_by: outputAlias,
+        });
+      }
+
+      // Web search/fetch — provider IS the model, expose as {alias}/search and/or {alias}/fetch with explicit kind
+      if (kindFilter.includes("webSearch") && providerInfo?.searchConfig) {
+        models.push({
+          id: `${outputAlias}/search`,
+          object: "model",
+          kind: "webSearch",
+          created: timestamp,
+          owned_by: outputAlias,
+        });
+      }
+      if (kindFilter.includes("webFetch") && providerInfo?.fetchConfig) {
+        models.push({
+          id: `${outputAlias}/fetch`,
+          object: "model",
+          kind: "webFetch",
+          created: timestamp,
+          owned_by: outputAlias,
+        });
+      }
+    }
+  }
+
+  const dedupedModels = [];
+  const seenModelIds = new Set();
+  for (const model of models) {
+    if (!model?.id || seenModelIds.has(model.id)) continue;
+    seenModelIds.add(model.id);
+    dedupedModels.push(model);
+  }
+
+  return dedupedModels;
+}
+
 /**
  * Handle CORS preflight
  */
@@ -81,203 +379,14 @@ export async function OPTIONS() {
 }
 
 /**
- * GET /v1/models - OpenAI compatible models list
- * Returns models from all active providers and combos in OpenAI format
+ * GET /v1/models - OpenAI compatible models list (LLM/chat models only by default).
+ * For other capabilities use /v1/models/{kind} (image, tts, stt, embedding, image-to-text, web).
  */
 export async function GET() {
   try {
-    // Get active provider connections
-    let connections = [];
-    try {
-      connections = await getProviderConnections();
-      // Filter to only active connections
-      connections = connections.filter(c => c.isActive !== false);
-    } catch (e) {
-      // If database not available, return all models
-      console.log("Could not fetch providers, returning all models");
-    }
-
-    // Get combos
-    let combos = [];
-    try {
-      combos = await getCombos();
-    } catch (e) {
-      console.log("Could not fetch combos");
-    }
-
-    let customModels = [];
-    try {
-      customModels = await getCustomModels();
-    } catch (e) {
-      console.log("Could not fetch custom models");
-    }
-
-    let modelAliases = {};
-    try {
-      modelAliases = await getModelAliases();
-    } catch (e) {
-      console.log("Could not fetch model aliases");
-    }
-
-    // Build first active connection per provider (connections already sorted by priority)
-    const activeConnectionByProvider = new Map();
-    for (const conn of connections) {
-      if (!activeConnectionByProvider.has(conn.provider)) {
-        activeConnectionByProvider.set(conn.provider, conn);
-      }
-    }
-
-    // Collect models from active providers (or all if none active)
-    const models = [];
-    const timestamp = Math.floor(Date.now() / 1000);
-
-    // Add combos first (they appear at the top)
-    for (const combo of combos) {
-      models.push({
-        id: combo.name,
-        object: "model",
-        created: timestamp,
-        owned_by: "combo",
-      });
-    }
-
-    // Add provider models
-    if (connections.length === 0) {
-      // DB unavailable or no active providers -> return all static models
-      for (const [alias, providerModels] of Object.entries(PROVIDER_MODELS)) {
-        for (const model of providerModels) {
-          models.push({
-            id: `${alias}/${model.id}`,
-            object: "model",
-            created: timestamp,
-            owned_by: alias,
-          });
-        }
-      }
-
-      // Also include custom LLM models when no active connections are available.
-      for (const customModel of customModels) {
-        if (!customModel?.id || (customModel.type && customModel.type !== "llm")) continue;
-        const providerAlias = customModel.providerAlias;
-        if (!providerAlias) continue;
-
-        const modelId = String(customModel.id).trim();
-        if (!modelId) continue;
-
-        models.push({
-          id: `${providerAlias}/${modelId}`,
-          object: "model",
-          created: timestamp,
-          owned_by: providerAlias,
-        });
-      }
-    } else {
-      for (const [providerId, conn] of activeConnectionByProvider.entries()) {
-        const staticAlias = PROVIDER_ID_TO_ALIAS[providerId] || providerId;
-        const outputAlias = (
-          conn?.providerSpecificData?.prefix
-          || getProviderAlias(providerId)
-          || staticAlias
-        ).trim();
-        const providerModels = PROVIDER_MODELS[staticAlias] || [];
-        const enabledModels = conn?.providerSpecificData?.enabledModels;
-        const hasExplicitEnabledModels =
-          Array.isArray(enabledModels) && enabledModels.length > 0;
-        const isCompatibleProvider =
-          isOpenAICompatibleProvider(providerId) || isAnthropicCompatibleProvider(providerId);
-
-        // Default: if no explicit selection, all static models are active.
-        // For compatible providers with no explicit selection, fetch remote /models dynamically.
-        // If explicit selection exists, expose exactly those model IDs (including non-static IDs).
-        let rawModelIds = hasExplicitEnabledModels
-          ? Array.from(
-              new Set(
-                enabledModels.filter(
-                  (modelId) => typeof modelId === "string" && modelId.trim() !== "",
-                ),
-              ),
-            )
-          : providerModels.map((model) => model.id);
-
-        if (isCompatibleProvider && rawModelIds.length === 0 && !UPSTREAM_CONNECTION_RE.test(providerId)) {
-          rawModelIds = await fetchCompatibleModelIds(conn);
-        }
-
-        const modelIds = rawModelIds
-          .map((modelId) => {
-            if (modelId.startsWith(`${outputAlias}/`)) {
-              return modelId.slice(outputAlias.length + 1);
-            }
-            if (modelId.startsWith(`${staticAlias}/`)) {
-              return modelId.slice(staticAlias.length + 1);
-            }
-            if (modelId.startsWith(`${providerId}/`)) {
-              return modelId.slice(providerId.length + 1);
-            }
-            return modelId;
-          })
-          .filter((modelId) => typeof modelId === "string" && modelId.trim() !== "");
-
-        const customModelIds = customModels
-          .filter((m) => {
-            if (!m?.id || (m.type && m.type !== "llm")) return false;
-            const alias = m.providerAlias;
-            return alias === staticAlias || alias === outputAlias || alias === providerId;
-          })
-          .map((m) => String(m.id).trim())
-          .filter((modelId) => modelId !== "");
-
-        const aliasModelIds = Object.values(modelAliases || {})
-          .filter((fullModel) => {
-            if (typeof fullModel !== "string" || !fullModel.includes("/")) return false;
-            return (
-              fullModel.startsWith(`${outputAlias}/`) ||
-              fullModel.startsWith(`${staticAlias}/`) ||
-              fullModel.startsWith(`${providerId}/`)
-            );
-          })
-          .map((fullModel) => {
-            if (fullModel.startsWith(`${outputAlias}/`)) {
-              return fullModel.slice(outputAlias.length + 1);
-            }
-            if (fullModel.startsWith(`${staticAlias}/`)) {
-              return fullModel.slice(staticAlias.length + 1);
-            }
-            if (fullModel.startsWith(`${providerId}/`)) {
-              return fullModel.slice(providerId.length + 1);
-            }
-            return fullModel;
-          })
-          .filter((modelId) => typeof modelId === "string" && modelId.trim() !== "");
-
-        const mergedModelIds = Array.from(new Set([...modelIds, ...customModelIds, ...aliasModelIds]));
-
-        for (const modelId of mergedModelIds) {
-          models.push({
-            id: `${outputAlias}/${modelId}`,
-            object: "model",
-            created: timestamp,
-            owned_by: outputAlias,
-          });
-        }
-      }
-    }
-
-    const dedupedModels = [];
-    const seenModelIds = new Set();
-    for (const model of models) {
-      if (!model?.id || seenModelIds.has(model.id)) continue;
-      seenModelIds.add(model.id);
-      dedupedModels.push(model);
-    }
-
-    return Response.json({
-      object: "list",
-      data: dedupedModels,
-    }, {
-      headers: {
-        "Access-Control-Allow-Origin": "*",
-      },
+    const data = await buildModelsList([LLM_KIND]);
+    return Response.json({ object: "list", data }, {
+      headers: { "Access-Control-Allow-Origin": "*" },
     });
   } catch (error) {
     console.log("Error fetching models:", error);