aigetwey 1.0.1

package/dashboard/src/components/UsageView.tsx

@@ -0,0 +1,151 @@
+"use client";
+
+import { useEffect, useState, useCallback } from "react";
+import { AreaChart, type SeriesPoint } from "@/components/AreaChart";
+import { Stat, fmt, Empty } from "@/components/ui";
+import { RichCard } from "@/components/RichCard";
+import type { UsageSummary } from "@/lib/gateway";
+
+type Window = { label: string; ms: number; bucketMs: number };
+
+// window -> (lookback, chart bucket size). Buckets keep ~24-48 points per range.
+const WINDOWS: Window[] = [
+  { label: "24h", ms: 24 * 3600_000, bucketMs: 3600_000 },
+  { label: "7d", ms: 7 * 86400_000, bucketMs: 6 * 3600_000 },
+  { label: "30d", ms: 30 * 86400_000, bucketMs: 86400_000 },
+];
+
+export function UsageView() {
+  const [win, setWin] = useState<Window>(WINDOWS[0]!);
+  const [summary, setSummary] = useState<UsageSummary | null>(null);
+  const [series, setSeries] = useState<SeriesPoint[]>([]);
+  const [error, setError] = useState("");
+  const [loading, setLoading] = useState(true);
+
+  const load = useCallback(async (w: Window) => {
+    setLoading(true);
+    setError("");
+    const since = Date.now() - w.ms;
+    const [sumRes, serRes] = await Promise.all([
+      fetch(`/api/gw/admin/usage?since=${since}`),
+      fetch(`/api/gw/admin/usage/series?since=${since}&bucket=${w.bucketMs}`),
+    ]);
+    if (!sumRes.ok) {
+      setError("could not load usage");
+      setLoading(false);
+      return;
+    }
+    setSummary((await sumRes.json()) as UsageSummary);
+    const ser = serRes.ok ? ((await serRes.json()) as { series: SeriesPoint[] }) : { series: [] };
+    setSeries(ser.series);
+    setLoading(false);
+  }, []);
+
+  useEffect(() => {
+    void load(win);
+  }, [win, load]);
+
+  const total = summary?.total;
+
+  return (
+    <div>
+      <div className="mb-6 flex items-center justify-between gap-3">
+        <div>
+          <h1 className="text-[22px] font-semibold tracking-tight text-text">Usage</h1>
+          <p className="mt-1 text-[13px] text-text-muted">Tokens and cost across providers and models.</p>
+        </div>
+        <div className="flex items-center gap-1 rounded-full border border-border bg-surface p-1">
+          {WINDOWS.map((w) => (
+            <button
+              key={w.label}
+              onClick={() => setWin(w)}
+              className={`rounded-full px-3 py-1 text-[12px] font-medium transition-colors ${
+                win.label === w.label ? "bg-surface-2 text-text" : "text-text-muted hover:text-text"
+              }`}
+            >
+              {w.label}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {error ? (
+        <Empty>{error}</Empty>
+      ) : (
+        <>
+          <div className="mb-5 grid grid-cols-2 gap-3 sm:grid-cols-4">
+            <Stat label="Requests" value={fmt.int(total?.requests ?? 0)} />
+            <Stat label="Tokens in" value={fmt.compact(total?.tokens_in ?? 0)} />
+            <Stat label="Tokens out" value={fmt.compact(total?.tokens_out ?? 0)} />
+            <Stat label="Cost" value={fmt.cost(total?.cost ?? 0)} />
+          </div>
+
+          <div className="mb-5">
+            <AreaChart series={series} />
+          </div>
+
+          <div className="grid gap-4 lg:grid-cols-2">
+            <RichCard header={<span className="text-[13px] font-semibold text-text">By provider</span>}>
+              {summary?.by_provider.length ? (
+                <BreakdownTable
+                  rows={summary.by_provider.map((p) => ({ label: p.provider, ...p }))}
+                  loading={loading}
+                />
+              ) : (
+                <Empty>No usage in this window.</Empty>
+              )}
+            </RichCard>
+            <RichCard header={<span className="text-[13px] font-semibold text-text">By model</span>}>
+              {summary?.by_model.length ? (
+                <BreakdownTable
+                  rows={summary.by_model.map((m) => ({ label: `${m.alias} → ${m.model}`, ...m }))}
+                  loading={loading}
+                />
+              ) : (
+                <Empty>No usage in this window.</Empty>
+              )}
+            </RichCard>
+          </div>
+        </>
+      )}
+    </div>
+  );
+}
+
+function BreakdownTable({
+  rows,
+  loading,
+}: {
+  rows: Array<{ label: string; requests: number; tokens_in: number; tokens_out: number; cost: number }>;
+  loading: boolean;
+}) {
+  return (
+    <div className={`table-wrap ${loading ? "opacity-50" : ""}`}>
+      <table className="w-full border-collapse">
+        <thead>
+          <tr className="text-text-subtle">
+            {["", "Reqs", "In", "Out", "Cost"].map((h, i) => (
+              <th
+                key={h + i}
+                className={`pb-2 text-[10px] font-medium uppercase tracking-wider ${i === 0 ? "text-left" : "text-right"}`}
+              >
+                {h}
+              </th>
+            ))}
+          </tr>
+        </thead>
+        <tbody>
+          {rows.map((r) => (
+            <tr key={r.label} className="border-t border-border-subtle">
+              <td className="py-2 text-[12.5px] text-text">{r.label}</td>
+              <td className="py-2 text-right tnum text-[12.5px] text-text-muted">{fmt.int(r.requests)}</td>
+              <td className="py-2 text-right tnum text-[12.5px] text-text-muted">{fmt.compact(r.tokens_in)}</td>
+              <td className="py-2 text-right tnum text-[12.5px] text-text-muted">{fmt.compact(r.tokens_out)}</td>
+              <td className="py-2 text-right tnum text-[12.5px] text-text">{fmt.cost(r.cost)}</td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}

package/dashboard/src/components/ui.tsx

@@ -0,0 +1,54 @@
+/** Small formatting helpers shared across the console. */
+export const fmt = {
+  int(n: number): string {
+    return n.toLocaleString("en-US");
+  },
+  /** compact number: 1.2K, 3.4M */
+  compact(n: number): string {
+    if (Math.abs(n) >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+    if (Math.abs(n) >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
+    return String(Math.round(n));
+  },
+  cost(n: number): string {
+    if (n === 0) return "$0";
+    return n < 0.01 ? `$${n.toFixed(4)}` : `$${n.toFixed(2)}`;
+  },
+  time(ts: number): string {
+    return new Date(ts).toLocaleString("en-US", { hour12: false });
+  },
+  /** "3m", "2h", "5d" — coarse relative age */
+  ago(ts: number): string {
+    const s = Math.max(0, Math.round((Date.now() - ts) / 1000));
+    if (s < 60) return `${s}s`;
+    if (s < 3600) return `${Math.floor(s / 60)}m`;
+    if (s < 86400) return `${Math.floor(s / 3600)}h`;
+    return `${Math.floor(s / 86400)}d`;
+  },
+  /** ms duration -> "Xs", "Xm Ys", "Xh Ym" for quota/cooldown countdowns */
+  duration(ms: number): string {
+    const s = Math.max(0, Math.round(ms / 1000));
+    if (s < 60) return `${s}s`;
+    if (s < 3600) return `${Math.floor(s / 60)}m ${s % 60}s`;
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    if (h < 24) return `${h}h ${m}m`;
+    const d = Math.floor(h / 24);
+    return `${d}d ${h % 24}h`;
+  },
+};
+
+/** A labelled stat block — number over a caption. */
+export function Stat({ label, value, sub }: { label: string; value: React.ReactNode; sub?: string }) {
+  return (
+    <div className="rounded-brand-lg border border-border bg-surface px-4 py-3.5 shadow-soft">
+      <div className="text-[11px] font-medium uppercase tracking-wider text-text-subtle">{label}</div>
+      <div className="mt-1 tnum text-[22px] font-semibold tracking-tight text-text">{value}</div>
+      {sub && <div className="mt-0.5 text-[12px] text-text-muted">{sub}</div>}
+    </div>
+  );
+}
+
+/** Empty-state hint inside a card body. */
+export function Empty({ children }: { children: React.ReactNode }) {
+  return <div className="px-1 py-8 text-center text-[13px] text-text-muted">{children}</div>;
+}

package/dashboard/src/lib/capabilities.ts

@@ -0,0 +1,318 @@
+// Model capabilities — what each model can read/do beyond plain text.
+//
+// Fallback order (first match wins), result merged over DEFAULT_CAPABILITIES:
+//   1. PROVIDER_CAPABILITIES[provider][model]  — provider-specific override
+//   2. MODEL_CAPABILITIES[model]               — canonical exact id (handles exceptions)
+//   3. PATTERN_CAPABILITIES                     — glob match, ordered specific -> generic
+//   4. DEFAULT_CAPABILITIES                     — safe floor (always returned)
+//
+// ── HOW TO ADD / UPDATE A MODEL ──────────────────────────────────────
+// Authoritative data source: https://models.dev/api.json (145 providers, 4000+
+// models, MIT). Each model exposes the exact fields we map below:
+//   modalities.input  ["text","image","pdf","audio","video"] -> vision / pdf / audioInput / videoInput
+//   modalities.output ["text","image","audio"]               -> imageOutput / audioOutput
+//   reasoning   -> reasoning      tool_call    -> tools
+//   limit.context -> contextWindow   limit.output -> maxOutput
+// Look up the model id, then:
+//   • If a PATTERN below already covers it correctly -> nothing to do.
+//   • If it is an exception (pattern would mis-match) -> add an exact entry to
+//     MODEL_CAPABILITIES (only the fields that differ from DEFAULT).
+//   • If a whole new family -> add an ordered PATTERN (specific before generic).
+// NOTE: models.dev has NO "search" flag (web search is a runtime tool, not a
+// model spec); set `search` from vendor docs (Claude 4.x+, GPT-5.x/4o, Gemini
+// 2.0+, Grok, Perplexity). Verify with: curl -s https://models.dev/api.json
+
+
+/**
+ * Safe floor — every resolved result is merged over this so consumers
+ * never need null-checks. Most modern LLMs meet these limits.
+ */
+export interface Caps {
+  vision: boolean;
+  pdf: boolean;
+  audioInput: boolean;
+  videoInput: boolean;
+  imageOutput: boolean;
+  audioOutput: boolean;
+  search: boolean;
+  tools: boolean;
+  reasoning: boolean;
+  thinkingFormat: string | null;
+  thinkingCanDisable: boolean;
+  thinkingRange: { min: number; max: number } | null;
+  contextWindow: number;
+  maxOutput: number;
+}
+
+/**
+ * Glob (* = wildcard) match, anchored + case-insensitive. aigetwey's
+ * pricing.matchPattern so capabilities resolve identically.
+ */
+export function matchPattern(pattern: string, model: string): boolean {
+  const regex = new RegExp(
+    "^" + pattern.split("*").map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$",
+    "i",
+  );
+  return regex.test(model);
+}
+
+export const DEFAULT_CAPABILITIES: Caps = {
+  // input modalities
+  vision: false,        // read images
+  pdf: false,           // read PDF / documents
+  audioInput: false,    // read audio
+  videoInput: false,    // read video
+  // output modalities
+  imageOutput: false,   // generate images
+  audioOutput: false,   // generate audio
+  // features
+  search: false,        // built-in web search tool / grounding
+  tools: true,          // function / tool calling
+  reasoning: false,     // thinking / reasoning
+  // thinking wire format (only meaningful when reasoning:true). null → derive from transport.format.
+  // enum: openai|claude-adaptive|claude-budget|gemini-level|gemini-budget|zai|qwen|deepseek|kimi|minimax|hunyuan|step
+  thinkingFormat: null,
+  thinkingCanDisable: true,  // false → model cannot turn thinking off (clamp to min instead of disable)
+  thinkingRange: null,       // { min, max } for budget formats; null = no clamp
+  // limits (tokens)
+  contextWindow: 200000,
+  maxOutput: 64000,
+};
+
+// User-added model metadata can carry dashboard service kinds instead of the
+// runtime capability names used here. Map those typed model kinds into input /
+// output capabilities so custom vision models are not treated as text-only.
+const SERVICE_KIND_CAPABILITIES: Record<string, Partial<Caps>> = {
+  imageToText: { vision: true },
+  image: { imageOutput: true },
+  stt: { audioInput: true },
+  tts: { audioOutput: true },
+  embedding: { tools: false },
+};
+
+export function capabilitiesFromServiceKind(kind: string): Partial<Caps> | null {
+  return SERVICE_KIND_CAPABILITIES[kind] || null;
+}
+
+/**
+ * Canonical exact-id overrides — used for exceptions that patterns would
+ * otherwise mis-match. Only declare deltas vs DEFAULT.
+ */
+export const MODEL_CAPABILITIES: Record<string, Partial<Caps>> = {
+  // Claude 4.6/4.7 have 1M context + adaptive thinking (override generic claude pattern)
+  "claude-opus-4.6":   { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive", contextWindow: 1000000, maxOutput: 128000 },
+  "claude-opus-4.7":   { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive", contextWindow: 1000000, maxOutput: 128000 },
+  "claude-opus-4-6":   { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive", contextWindow: 1000000, maxOutput: 128000 },
+  "claude-sonnet-4.6": { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive", contextWindow: 1000000, maxOutput: 64000 },
+  "claude-sonnet-4-6": { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive", contextWindow: 1000000, maxOutput: 64000 },
+
+  // Gemini image-gen / OpenAI image / xai image variants
+  "gpt-image-1":       { imageOutput: true, tools: false },
+
+  // GLM vision variant (text GLM has no vision)
+  "glm-4.6v":          { vision: true, reasoning: true, thinkingFormat: "zai", contextWindow: 128000 },
+
+  // Qwen plain coder/text (no vision) — registry "vision-model" / "coder-model" aliases
+  "vision-model":      { vision: true, reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000 },
+  "coder-model":       { reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000 },
+};
+
+/**
+ * Provider-specific capability overrides. Keyed by provider alias/id.
+ */
+export const PROVIDER_CAPABILITIES: Record<string, Record<string, Partial<Caps>>> = {
+  // CodeBuddy.cn — authoritative per-model metadata from the gateway's model
+  // config (contextWindow=maxInputTokens, maxOutput=maxOutputTokens, vision=
+  // supportsImages). Every model reasons via OpenAI-style reasoning_effort
+  // (see registry thinkingFormat). `onlyReasoning` models can't turn thinking
+  // off → thinkingCanDisable:false (clamped to minimal instead of disabled).
+  "codebuddy-cn": {
+    "glm-5.2":            { reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 1000000, maxOutput: 48000 },
+    "glm-5.1":            { reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 200000, maxOutput: 48000 },
+    "glm-5.0":            { reasoning: true, thinkingFormat: "openai", contextWindow: 200000, maxOutput: 48000 },
+    "glm-5.0-turbo":      { reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 200000, maxOutput: 48000 },
+    "glm-5v-turbo":       { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 200000, maxOutput: 38000 },
+    "glm-4.7":            { reasoning: true, thinkingFormat: "openai", contextWindow: 200000, maxOutput: 48000 },
+    "minimax-m3":         { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 512000, maxOutput: 48000 },
+    "minimax-m2.7":       { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 200000, maxOutput: 48000 },
+    "kimi-k2.7":          { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 256000, maxOutput: 32000 },
+    "kimi-k2.6":          { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 256000, maxOutput: 32000 },
+    "kimi-k2.5":          { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 164000, maxOutput: 32000 },
+    "hy3-preview":        { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 192000, maxOutput: 64000 },
+    "deepseek-v4-pro":    { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 1000000, maxOutput: 50000 },
+    "deepseek-v4-flash":  { vision: true, reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 1000000, maxOutput: 50000 },
+    "deepseek-v3-2-volc": { reasoning: true, thinkingFormat: "openai", thinkingCanDisable: false, contextWindow: 96000, maxOutput: 32000 },
+  },
+};
+
+/**
+ * Pattern fallback — glob (* = wildcard), matched case-insensitively and
+ * anchored (^...$) so a pattern must match the full model id. ORDER MATTERS:
+ * vision/specific variants first, text-only/generic families last, to avoid
+ * a broad family pattern swallowing an exception (e.g. glm-4.6v vs glm-5).
+ */
+export const PATTERN_CAPABILITIES: Array<{ pattern: string; caps: Partial<Caps> }> = [
+  // ── Claude (4.6+ = adaptive thinking; older/haiku = budget) ──────
+  { pattern: "*claude*opus-4.6*",   caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" } },
+  { pattern: "*claude*opus-4.7*",   caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" } },
+  { pattern: "*claude*opus-4.8*",   caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" } },
+  { pattern: "*claude*sonnet-4.6*", caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" } },
+  { pattern: "*claude*sonnet-4.7*", caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-adaptive" } },
+  { pattern: "*claude*haiku*",  caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget" } },
+  { pattern: "*claude*opus*",   caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget" } },
+  { pattern: "*claude*sonnet*", caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget" } },
+  { pattern: "*claude*fable*",  caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget", contextWindow: 1000000, maxOutput: 128000 } },
+  { pattern: "*claude*mythos*", caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget", contextWindow: 1000000, maxOutput: 128000 } },
+  { pattern: "*claude-3*",      caps: { vision: true } },
+  { pattern: "*claude*",        caps: { vision: true, reasoning: true, search: true, thinkingFormat: "claude-budget" } },
+
+  // ── Gemini (all 2.0+ multimodal + google_search grounding, 1M ctx) ─
+  { pattern: "*gemini*image*",  caps: { vision: true, imageOutput: true, contextWindow: 1048576 } },
+  { pattern: "*gemini-3*pro*",  caps: { vision: true, audioInput: true, videoInput: true, reasoning: true, search: true, thinkingFormat: "gemini-level", thinkingCanDisable: false, contextWindow: 1048576, maxOutput: 65535 } },
+  { pattern: "*gemini-3*",      caps: { vision: true, audioInput: true, videoInput: true, reasoning: true, search: true, thinkingFormat: "gemini-level", thinkingCanDisable: false, contextWindow: 1048576, maxOutput: 65536 } },
+  { pattern: "*gemini-2.5*",    caps: { vision: true, audioInput: true, videoInput: true, reasoning: true, search: true, thinkingFormat: "gemini-budget", thinkingRange: { min: 0, max: 24576 }, contextWindow: 1048576, maxOutput: 65536 } },
+  { pattern: "*gemini-2*",      caps: { vision: true, audioInput: true, videoInput: true, search: true, contextWindow: 1048576, maxOutput: 65536 } },
+  { pattern: "*gemini*",        caps: { vision: true, search: true, contextWindow: 1048576 } },
+  { pattern: "*gemma*",         caps: { vision: true, contextWindow: 128000 } },
+  { pattern: "*nanobanana*",    caps: { vision: true, imageOutput: true } },
+
+  // ── OpenAI GPT-5.x (vision + thinking + web search) ──────────────
+  { pattern: "*gpt-5*image*",   caps: { imageOutput: true } },
+  { pattern: "*gpt-5*codex*",   caps: { reasoning: true, search: true, thinkingFormat: "openai", contextWindow: 400000, maxOutput: 128000 } },
+  { pattern: "*gpt-5*",         caps: { vision: true, reasoning: true, search: true, thinkingFormat: "openai", contextWindow: 400000, maxOutput: 128000 } },
+  { pattern: "*gpt-4o*",        caps: { vision: true, search: true, contextWindow: 128000, maxOutput: 16384 } },
+  { pattern: "*gpt-4.1*",       caps: { vision: true, contextWindow: 1000000, maxOutput: 32768 } },
+  { pattern: "*gpt-4-turbo*",   caps: { vision: true, contextWindow: 128000 } },
+  { pattern: "*gpt-4*",         caps: { contextWindow: 128000 } },
+  { pattern: "*gpt-3.5*",       caps: { contextWindow: 16385, maxOutput: 4096 } },
+  { pattern: "*gpt-oss*",       caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 128000 } },
+
+  // ── OpenAI o-series (reasoning, vision) ──────────────────────────
+  { pattern: "*o1-mini*",       caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 128000 } },
+  { pattern: "*o1*",            caps: { vision: true, reasoning: true, thinkingFormat: "openai", contextWindow: 200000, maxOutput: 100000 } },
+  { pattern: "*o3*",            caps: { vision: true, reasoning: true, thinkingFormat: "openai", contextWindow: 200000, maxOutput: 100000 } },
+  { pattern: "*o4*",            caps: { vision: true, reasoning: true, thinkingFormat: "openai", contextWindow: 200000, maxOutput: 100000 } },
+
+  // ── Grok (vision + Live Search) ──────────────────────────────────
+  { pattern: "*grok*image*",    caps: { imageOutput: true } },
+  { pattern: "*grok-code*",     caps: { reasoning: true, thinkingFormat: "openai", contextWindow: 256000 } },
+  { pattern: "*grok-4*",        caps: { vision: true, reasoning: true, search: true, thinkingFormat: "openai", contextWindow: 256000 } },
+  { pattern: "*grok-3*",        caps: { vision: true, reasoning: true, search: true, thinkingFormat: "openai", contextWindow: 131072 } },
+  { pattern: "*grok*",          caps: { vision: true, reasoning: true, search: true, thinkingFormat: "openai", contextWindow: 256000 } },
+
+  // ── Qwen (enable_thinking + thinking_budget; QwQ = thinking-only) ─
+  { pattern: "*qwen*vl*",       caps: { vision: true, reasoning: true, thinkingFormat: "qwen", contextWindow: 262144 } },
+  { pattern: "*qwen*max*",      caps: { vision: true, reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000, maxOutput: 65536 } },
+  { pattern: "*qwen*plus*",     caps: { vision: true, reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000, maxOutput: 65536 } },
+  { pattern: "*qwen*235b*",     caps: { reasoning: true, thinkingFormat: "qwen", contextWindow: 262144 } },
+  { pattern: "*qwen*coder*",    caps: { reasoning: true, thinkingFormat: "qwen", contextWindow: 1000000 } },
+  { pattern: "*qwq*",           caps: { reasoning: true, thinkingFormat: "qwen", thinkingCanDisable: false, contextWindow: 131072 } },
+  { pattern: "*qwen*",          caps: { reasoning: true, thinkingFormat: "qwen", contextWindow: 262144 } },
+
+  // ── Kimi (enabled→reasoning_effort; K2.7-code cannot disable) ─────
+  { pattern: "*kimi*k2.7*code*", caps: { vision: true, reasoning: true, thinkingFormat: "kimi", thinkingCanDisable: false, contextWindow: 262144, maxOutput: 262144 } },
+  { pattern: "*kimi*k2*",       caps: { vision: true, reasoning: true, thinkingFormat: "kimi", contextWindow: 262144, maxOutput: 262144 } },
+  { pattern: "*kimi*",          caps: { reasoning: true, thinkingFormat: "kimi", contextWindow: 262144 } },
+
+  // ── GLM / Z.ai (thinking.enabled; disable via enable_thinking:false) ─
+  { pattern: "*glm-5*",         caps: { reasoning: true, thinkingFormat: "zai", contextWindow: 200000, maxOutput: 128000 } },
+  { pattern: "*glm-4.7*",       caps: { reasoning: true, thinkingFormat: "zai", contextWindow: 200000, maxOutput: 128000 } },
+  { pattern: "*glm-4*",         caps: { reasoning: true, thinkingFormat: "zai", contextWindow: 200000 } },
+  { pattern: "*glm*",           caps: { reasoning: true, thinkingFormat: "zai", contextWindow: 200000 } },
+
+  // ── DeepSeek (thinking.enabled + reasoning_effort; r1 = thinking-only) ─
+  { pattern: "*deepseek-v4*",   caps: { reasoning: true, thinkingFormat: "deepseek", contextWindow: 1000000, maxOutput: 384000 } },
+  { pattern: "*reasoner*",      caps: { reasoning: true, thinkingFormat: "deepseek", thinkingCanDisable: false, contextWindow: 128000 } },
+  { pattern: "*deepseek-r*",    caps: { reasoning: true, thinkingFormat: "deepseek", thinkingCanDisable: false, contextWindow: 128000 } },
+  { pattern: "*deepseek-chat*", caps: { contextWindow: 128000 } },
+  { pattern: "*deepseek*",      caps: { reasoning: true, thinkingFormat: "deepseek", contextWindow: 128000 } },
+
+  // ── MiniMax (M3 = adaptive; M2.x cannot disable) ─────────────────
+  { pattern: "*minimax*image*", caps: { imageOutput: true } },
+  { pattern: "*minimax-m3*",    caps: { vision: true, reasoning: true, thinkingFormat: "minimax", contextWindow: 1048576, maxOutput: 512000 } },
+  { pattern: "*minimax-m2.7*",  caps: { reasoning: true, thinkingFormat: "minimax", thinkingCanDisable: false, contextWindow: 204800, maxOutput: 131072 } },
+  { pattern: "*minimax*",       caps: { reasoning: true, thinkingFormat: "minimax", thinkingCanDisable: false, contextWindow: 200000, maxOutput: 131072 } },
+
+  // ── Xiaomi MiMo (vision, 1M / 262K ctx) ──────────────────────────
+  { pattern: "*mimo*v2.5*",     caps: { vision: true, contextWindow: 1048576, maxOutput: 131072 } },
+  { pattern: "*mimo*omni*",     caps: { vision: true, audioInput: true, contextWindow: 262144, maxOutput: 131072 } },
+  { pattern: "*mimo*",          caps: { vision: true, contextWindow: 262144, maxOutput: 131072 } },
+
+  // ── Llama (4 = vision/1M; 3.x = text-only/128K) ──────────────────
+  { pattern: "*llama-4*",       caps: { vision: true, contextWindow: 1000000 } },
+  { pattern: "*llama*",         caps: { contextWindow: 128000 } },
+
+  // ── Mistral (Large 3 = vision/256K; codestral text) ──────────────
+  { pattern: "*codestral*",     caps: { contextWindow: 256000 } },
+  { pattern: "*mistral-large*", caps: { vision: true, contextWindow: 256000 } },
+  { pattern: "*mistral*",       caps: { contextWindow: 128000 } },
+
+  // ── Cohere (Command A Vision = vision; others text) ──────────────
+  { pattern: "*command-a-vision*", caps: { vision: true, contextWindow: 128000 } },
+  { pattern: "*command*",       caps: { contextWindow: 128000 } },
+
+  // ── Perplexity (web search native) ───────────────────────────────
+  { pattern: "*sonar*",         caps: { search: true, contextWindow: 128000 } },
+  { pattern: "*pplx*",          caps: { search: true, contextWindow: 128000 } },
+  { pattern: "*perplexity*",    caps: { search: true, contextWindow: 128000 } },
+
+  // ── Others ───────────────────────────────────────────────────────
+  { pattern: "*hunyuan*",       caps: { reasoning: true, thinkingFormat: "hunyuan", contextWindow: 262144, maxOutput: 262144 } },
+  { pattern: "hy3*",            caps: { reasoning: true, thinkingFormat: "hunyuan", contextWindow: 262144, maxOutput: 262144 } },
+  { pattern: "*step-*",         caps: { reasoning: true, thinkingFormat: "step", contextWindow: 128000 } },
+  { pattern: "*nemotron*",      caps: { reasoning: true, contextWindow: 128000 } },
+  { pattern: "*ling-*",         caps: { reasoning: true, contextWindow: 128000 } },
+];
+
+/**
+ * Resolve capabilities for a model using the 4-step fallback chain,
+ * merged over DEFAULT_CAPABILITIES so the result is always complete.
+ *
+ * @param {string} provider
+ * @param {string} model
+ * @returns {object} full capabilities object
+ */
+/**
+ * models.dev-style modalities for a model ref, derived from its capabilities.
+ * Ref may be a `provider/model` (vendor prefix tolerated) or a bare combo alias.
+ * Mirrors what opencode/aigetwey store per model in opencode.json.
+ */
+export function modalitiesForModel(ref: string): { input: string[]; output: string[] } {
+  const slash = ref.indexOf("/");
+  const provider = slash > 0 ? ref.slice(0, slash) : null;
+  const model = slash > 0 ? ref.slice(slash + 1) : ref;
+  const c = getCapabilitiesForModel(provider, model);
+  const input = ["text"];
+  if (c.vision) input.push("image");
+  if (c.pdf) input.push("pdf");
+  if (c.audioInput) input.push("audio");
+  if (c.videoInput) input.push("video");
+  const output = ["text"];
+  if (c.imageOutput) output.push("image");
+  if (c.audioOutput) output.push("audio");
+  return { input, output };
+}
+
+export function getCapabilitiesForModel(provider: string | null, model: string): Caps {
+  if (!model) return { ...DEFAULT_CAPABILITIES };
+
+  // 1. Provider-specific override
+  if (provider && PROVIDER_CAPABILITIES[provider]?.[model]) {
+    return { ...DEFAULT_CAPABILITIES, ...PROVIDER_CAPABILITIES[provider][model] };
+  }
+
+  // 2. Canonical exact (strip vendor prefix: "anthropic/claude-opus-4.7" -> "claude-opus-4.7")
+  const baseModel = (model.includes("/") ? model.split("/").pop() : model) ?? model;
+  if (MODEL_CAPABILITIES[baseModel]) return { ...DEFAULT_CAPABILITIES, ...MODEL_CAPABILITIES[baseModel] };
+  if (MODEL_CAPABILITIES[model]) return { ...DEFAULT_CAPABILITIES, ...MODEL_CAPABILITIES[model] };
+
+  // 3. Pattern match (first match wins)
+  for (const { pattern, caps } of PATTERN_CAPABILITIES) {
+    if (matchPattern(pattern, baseModel) || matchPattern(pattern, model)) {
+      return { ...DEFAULT_CAPABILITIES, ...caps };
+    }
+  }
+
+  // 4. Floor
+  return { ...DEFAULT_CAPABILITIES };
+}

package/dashboard/src/lib/cliTools.ts

@@ -0,0 +1,120 @@
+/**
+ * CLI tool setup definitions. Each tool talks to the gateway in either OpenAI or
+ * Anthropic wire format; the gateway exposes both on the same port, so setup is
+ * just pointing the tool's base_url + key at us. `env` builders take the live
+ * gateway base URL + a gateway key and return ready-to-copy environment lines.
+ *
+ * `slots` are the model names this tool calls. Because our gateway routes by the
+ * combo alias (the alias IS the model name), the detail page checks whether a
+ * combo with each slot's alias exists, and prompts to create the missing ones.
+ */
+export type ToolFormat = "openai" | "anthropic";
+
+export interface CliTool {
+  id: string;
+  name: string;
+  /** Material Symbols ligature shown on the tool card + detail header. */
+  icon: string;
+  format: ToolFormat;
+  blurb: string;
+  /** true when the dashboard can detect + write this tool's local config file. */
+  autoConfig?: boolean;
+  /** one-line install command, when the tool ships via a package manager. */
+  install?: string;
+  /** model names the tool sends — pair each with a combo of the same name. */
+  slots: { label: string; alias: string }[];
+  /** environment variables to set, given the gateway base + a key. */
+  env: (base: string, key: string) => Array<{ name: string; value: string }>;
+  /** extra free-form steps shown on the detail page. */
+  steps: string[];
+}
+
+const KEY = (k: string) => k || "<your-gateway-key>";
+
+export const CLI_TOOLS: CliTool[] = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    icon: "smart_toy",
+    format: "anthropic",
+    blurb: "Anthropic CLI. Point its base URL + key at the gateway.",
+    autoConfig: true,
+    install: "npm i -g @anthropic-ai/claude-code",
+    slots: [
+      { label: "Opus · heavy", alias: "claude-opus-4-1" },
+      { label: "Sonnet · default", alias: "claude-sonnet-4-6" },
+      { label: "Haiku · fast", alias: "claude-haiku-4-5" },
+    ],
+    env: (base, key) => [
+      { name: "ANTHROPIC_BASE_URL", value: base },
+      { name: "ANTHROPIC_API_KEY", value: KEY(key) },
+    ],
+    steps: [
+      "Export the two variables in the shell you run `claude` from.",
+      "Create a combo named like each slot above so Claude Code's model ids resolve.",
+      "The gateway translates Anthropic ↔ provider format, so any provider works behind it.",
+    ],
+  },
+  {
+    id: "codex",
+    name: "Codex",
+    icon: "code",
+    format: "openai",
+    blurb: "OpenAI-compatible. Use the /v1 base URL.",
+    install: "npm i -g @openai/codex",
+    slots: [{ label: "Model", alias: "gpt-5" }],
+    env: (base, key) => [
+      { name: "OPENAI_BASE_URL", value: `${base}/v1` },
+      { name: "OPENAI_API_KEY", value: KEY(key) },
+    ],
+    steps: ["Set the base URL to the gateway's /v1 path.", "Create a combo named like the slot above, then use it as the model."],
+  },
+  {
+    id: "opencode",
+    name: "opencode",
+    icon: "code_blocks",
+    format: "openai",
+    blurb: "OpenAI-compatible provider. Set base_url to /v1.",
+    autoConfig: true,
+    install: "curl -fsSL https://opencode.ai/install | bash",
+    slots: [{ label: "Model", alias: "gpt-5" }],
+    env: (base, key) => [
+      { name: "OPENAI_BASE_URL", value: `${base}/v1` },
+      { name: "OPENAI_API_KEY", value: KEY(key) },
+    ],
+    steps: ["Add an OpenAI-compatible provider with the gateway /v1 base URL.", "Pick a combo alias as the model."],
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    icon: "edit_square",
+    format: "openai",
+    blurb: "OpenAI-compatible. Override the base URL in settings.",
+    slots: [{ label: "Model", alias: "gpt-5" }],
+    env: (base, key) => [
+      { name: "Base URL", value: `${base}/v1` },
+      { name: "API Key", value: KEY(key) },
+    ],
+    steps: [
+      "Settings → Models → OpenAI API Key → override base URL with the gateway /v1.",
+      "Add your combo aliases as custom model names.",
+    ],
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    icon: "extension",
+    format: "openai",
+    blurb: "OpenAI-compatible VS Code agent.",
+    slots: [{ label: "Model", alias: "gpt-5" }],
+    env: (base, key) => [
+      { name: "Base URL", value: `${base}/v1` },
+      { name: "API Key", value: KEY(key) },
+    ],
+    steps: ["Choose the OpenAI-compatible provider.", "Set the base URL to the gateway /v1 and use a combo alias."],
+  },
+];
+
+export function toolById(id: string): CliTool | undefined {
+  return CLI_TOOLS.find((t) => t.id === id);
+}