ompchamber 2.0.2 → 3.1.0

package/src/server/lib/usage/deepseek.ts

@@ -44,15 +44,14 @@ async function fetchDeepSeekBalance(apiKey: string): Promise<DeepSeekBalance> {
   return mapBalance(await response.json());
 }
 
-/** Build the DeepSeek usage report; a missing key yields `configured: false`. */
-export async function buildDeepSeekReport(): Promise<DeepSeekUsageReport> {
+/** Build the DeepSeek usage report, or `null` when DeepSeek has no credential. */
+export async function buildDeepSeekReport(): Promise<DeepSeekUsageReport | null> {
   const apiKey = await resolveDeepSeekApiKey();
-  if (!apiKey) return { configured: false };
+  if (!apiKey) return null;
   try {
-    return { configured: true, balance: await fetchDeepSeekBalance(apiKey) };
+    return { balance: await fetchDeepSeekBalance(apiKey) };
   } catch (error) {
     return {
-      configured: true,
       error: error instanceof Error ? error.message : 'Failed to load DeepSeek balance',
     };
   }

package/src/server/lib/usage/kenari.ts

@@ -215,15 +215,16 @@ function errorMessage(error: unknown, fallback: string): string {
 }
 
 /**
- * Build the Kenari usage report. The three upstream calls (quota REST + two
- * MCP tools) run independently so a failure in one does not lose the others;
- * failures are folded into the report's `error` field.
+ * Build the Kenari usage report, or `null` when kenari has no credential —
+ * the caller then omits kenari from the provider list entirely. The three
+ * upstream calls (quota REST + two MCP tools) run independently so a failure in
+ * one does not lose the others; failures are folded into the report's `error`.
  */
-export async function buildKenariReport(): Promise<KenariUsageReport> {
+export async function buildKenariReport(): Promise<KenariUsageReport | null> {
   const apiKey = await resolveKenariApiKey();
-  if (!apiKey) return { configured: false };
+  if (!apiKey) return null;
 
-  const report: KenariUsageReport = { configured: true };
+  const report: KenariUsageReport = {};
   const [quota, balance, usage] = await Promise.allSettled([
     fetchKenariQuota(apiKey),
     fetchKenariBalance(apiKey),

package/src/server/lib/usage/omp-usage.server.test.ts

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { parseOmpUsageSnapshot } from '@/server/lib/usage/omp-usage.server';
+
+/**
+ * `omp usage --json` is the only source of provider-REPORTED quota, and the
+ * shapes below are what omp 18.3.0 emits. The parser is the boundary that
+ * turns that external payload into the chamber's flat `UsageLimitWindow[]`,
+ * so its precedence rules and its tolerance of junk are the contract.
+ */
+describe('parseOmpUsageSnapshot', () => {
+  test('resolves usedFraction with omp precedence: explicit > used/limit > percent > inverted remaining', () => {
+    const snapshot = parseOmpUsageSnapshot({
+      reports: [
+        {
+          provider: 'anthropic',
+          limits: [
+            { id: 'a', label: 'explicit', amount: { used: 9, limit: 10, usedFraction: 0.25, unit: 'percent' }, scope: { provider: 'anthropic' } },
+            { id: 'b', label: 'ratio', amount: { used: 30, limit: 60, unit: 'requests' }, scope: { provider: 'anthropic' } },
+            { id: 'c', label: 'percent', amount: { used: 42, unit: 'percent' }, scope: { provider: 'anthropic' } },
+            { id: 'd', label: 'remaining', amount: { remainingFraction: 0.2, unit: 'percent' }, scope: { provider: 'anthropic' } },
+          ],
+        },
+      ],
+    });
+
+    const limits = snapshot.reports.get('anthropic')?.limits ?? [];
+    expect(limits.map((limit) => limit.usedFraction)).toEqual([0.25, 0.5, 0.42, 0.8]);
+  });
+
+  test('merges multiple accounts of one provider and keeps each window id', () => {
+    const snapshot = parseOmpUsageSnapshot({
+      reports: [
+        {
+          provider: 'anthropic',
+          limits: [{ id: 'acct-1:5h', label: '5 hour', scope: { provider: 'anthropic', accountId: 'a1' }, amount: { usedFraction: 0.1, unit: 'percent' } }],
+        },
+        {
+          provider: 'anthropic',
+          limits: [{ id: 'acct-2:5h', label: '5 hour', scope: { provider: 'anthropic', accountId: 'a2' }, amount: { usedFraction: 0.9, unit: 'percent' } }],
+        },
+      ],
+    });
+
+    const report = snapshot.reports.get('anthropic');
+    expect(report?.limits.length).toBe(2);
+    expect(report?.limits.map((limit) => limit.accountId)).toEqual(['a1', 'a2']);
+  });
+
+  test('carries window label, reset clock and notes through', () => {
+    const snapshot = parseOmpUsageSnapshot({
+      reports: [
+        {
+          provider: 'zai',
+          notes: ['OMP-observed spend only'],
+          limits: [
+            {
+              id: 'zai:5h',
+              label: 'Coding plan 5 hour',
+              window: { id: '5h', label: '5 Hour', resetsAt: 1_760_000_000_000 },
+              scope: { provider: 'zai', modelId: 'glm-5.3' },
+              amount: { used: 7, limit: 10, unit: 'requests' },
+              status: 'warning',
+              notes: ['Overage requests: 3'],
+            },
+          ],
+        },
+      ],
+    });
+
+    const report = snapshot.reports.get('zai');
+    const limit = report?.limits[0];
+    expect(limit?.windowLabel).toBe('5h');
+    expect(limit?.resetsAt).toBe(1_760_000_000_000);
+    expect(limit?.modelId).toBe('glm-5.3');
+    expect(limit?.status).toBe('warning');
+    expect(limit?.notes).toEqual(['Overage requests: 3']);
+    expect(report?.notes).toEqual(['OMP-observed spend only']);
+  });
+
+  test('collects providers whose credentials produced no report', () => {
+    const snapshot = parseOmpUsageSnapshot({
+      reports: [],
+      accountsWithoutUsage: [
+        { provider: 'commandcode', type: 'oauth' },
+        { provider: 'commandcode', type: 'oauth' },
+        { provider: 'deepseek', type: 'api_key' },
+      ],
+    });
+
+    expect(snapshot.reports.size).toBe(0);
+    expect(snapshot.accountsWithoutUsage).toEqual(['commandcode', 'deepseek']);
+  });
+
+  test('degrades junk to an empty snapshot instead of throwing', () => {
+    for (const payload of [null, 'nope', 42, { reports: 'no' }, { reports: [null, 7] }]) {
+      const snapshot = parseOmpUsageSnapshot(payload);
+      expect(snapshot.reports.size).toBe(0);
+      expect(snapshot.accountsWithoutUsage).toEqual([]);
+    }
+  });
+
+  test('drops a limit without an id and defaults an unknown unit/status', () => {
+    const snapshot = parseOmpUsageSnapshot({
+      reports: [
+        {
+          provider: 'cursor',
+          limits: [
+            { label: 'no id', amount: { usedFraction: 0.5, unit: 'percent' } },
+            { id: 'cursor:fast', label: 'Fast requests', amount: { used: 1, unit: 'widgets' }, status: 'weird' },
+          ],
+        },
+      ],
+    });
+
+    const limits = snapshot.reports.get('cursor')?.limits ?? [];
+    expect(limits.length).toBe(1);
+    expect(limits[0].unit).toBe('unknown');
+    expect(limits[0].status).toBe('unknown');
+  });
+});

package/src/server/lib/usage/omp-usage.server.ts

@@ -0,0 +1,194 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Provider quota/limit windows straight from omp's own `omp usage --json`.
+ *
+ * This is the only source of provider-REPORTED limits: omp ships a usage
+ * adapter per provider (Anthropic, Codex, Z.ai, Copilot, Cursor, Gemini, …)
+ * and the CLI already normalizes every one of them into the same
+ * `UsageReport`/`UsageLimit` shape. Re-deriving that per provider here would
+ * mean re-implementing each vendor's endpoint and drifting from omp on every
+ * release.
+ *
+ * `omp usage` exits 0 even when nothing is reported (empty `reports`), so the
+ * parse path — not the exit code — decides whether the snapshot is usable.
+ * Cached briefly: the command walks every stored credential and calls each
+ * provider's endpoint, so it is far too expensive to run per panel poll.
+ */
+
+import { resolveOmpBin } from '@/server/lib/omp/core/cli';
+import { isRecord } from '@/shared/lib/util/guards';
+import type { UsageLimitWindow, UsageUnit, UsageWindowStatus } from '@/shared/types';
+
+const TIMEOUT_MS = 30_000;
+const CACHE_TTL_MS = 60_000;
+const MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+
+const UNITS: readonly UsageUnit[] = [
+  'percent', 'tokens', 'requests', 'credits', 'usd', 'minutes', 'bytes', 'unknown',
+];
+const STATUSES: readonly UsageWindowStatus[] = ['ok', 'warning', 'exhausted', 'unknown'];
+
+/** One provider section of `omp usage --json`. */
+export interface OmpUsageReportEntry {
+  provider: string;
+  limits: UsageLimitWindow[];
+  notes?: string[];
+}
+
+export interface OmpUsageSnapshot {
+  /** Per-provider reports, keyed by lowercased provider id. */
+  reports: Map<string, OmpUsageReportEntry>;
+  /** Providers whose credentials produced no usage report at all. */
+  accountsWithoutUsage: string[];
+}
+
+function emptySnapshot(): OmpUsageSnapshot {
+  return { reports: new Map(), accountsWithoutUsage: [] };
+}
+
+function toNumber(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function toStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const items = value.filter((item): item is string => typeof item === 'string' && item.length > 0);
+  return items.length > 0 ? items : undefined;
+}
+
+/**
+ * Resolve a limit's used fraction exactly as omp does: explicit `usedFraction`
+ * first, then `used`/`limit`, then a percent-unit `used`, then an inverted
+ * `remainingFraction`. Resolved here so the client never re-derives it.
+ */
+function resolveUsedFraction(amount: Record<string, unknown>): number | undefined {
+  const usedFraction = toNumber(amount.usedFraction);
+  if (usedFraction !== undefined) return usedFraction;
+  const used = toNumber(amount.used);
+  const limit = toNumber(amount.limit);
+  if (used !== undefined && limit !== undefined && limit > 0) return used / limit;
+  if (amount.unit === 'percent' && used !== undefined) return used / 100;
+  const remainingFraction = toNumber(amount.remainingFraction);
+  if (remainingFraction !== undefined) return Math.max(0, 1 - remainingFraction);
+  return undefined;
+}
+
+function mapLimit(raw: unknown): UsageLimitWindow | null {
+  if (!isRecord(raw)) return null;
+  const id = typeof raw.id === 'string' ? raw.id : '';
+  if (!id) return null;
+  const amount = isRecord(raw.amount) ? raw.amount : {};
+  const scope = isRecord(raw.scope) ? raw.scope : {};
+  const window = isRecord(raw.window) ? raw.window : {};
+  const unit = UNITS.find((candidate) => candidate === amount.unit) ?? 'unknown';
+  const status = STATUSES.find((candidate) => candidate === raw.status) ?? 'unknown';
+  const used = toNumber(amount.used);
+  const limit = toNumber(amount.limit);
+  const remaining = toNumber(amount.remaining);
+  const usedFraction = resolveUsedFraction(amount);
+  const resetsAt = toNumber(window.resetsAt);
+  const notes = toStringArray(raw.notes);
+  const windowId = typeof window.id === 'string' ? window.id : '';
+  const modelId = typeof scope.modelId === 'string' ? scope.modelId : '';
+  const accountId = typeof scope.accountId === 'string' ? scope.accountId : '';
+
+  return {
+    id,
+    label: typeof raw.label === 'string' && raw.label ? raw.label : id,
+    ...(windowId ? { windowLabel: windowId } : {}),
+    ...(modelId ? { modelId } : {}),
+    ...(accountId ? { accountId } : {}),
+    ...(used !== undefined ? { used } : {}),
+    ...(limit !== undefined ? { limit } : {}),
+    ...(remaining !== undefined ? { remaining } : {}),
+    ...(usedFraction !== undefined ? { usedFraction } : {}),
+    unit,
+    status,
+    ...(resetsAt !== undefined ? { resetsAt } : {}),
+    ...(notes ? { notes } : {}),
+  };
+}
+
+/** Fold the parsed CLI payload into a snapshot; unknown shapes degrade to empty. */
+export function parseOmpUsageSnapshot(payload: unknown): OmpUsageSnapshot {
+  if (!isRecord(payload)) return emptySnapshot();
+  const snapshot = emptySnapshot();
+
+  const reports = Array.isArray(payload.reports) ? payload.reports : [];
+  for (const entry of reports) {
+    if (!isRecord(entry)) continue;
+    const provider = typeof entry.provider === 'string' ? entry.provider.trim().toLowerCase() : '';
+    if (!provider) continue;
+    const limits = (Array.isArray(entry.limits) ? entry.limits : [])
+      .map(mapLimit)
+      .filter((limit): limit is UsageLimitWindow => limit !== null);
+    const existing = snapshot.reports.get(provider);
+    // One provider can report several accounts; their limits are additive, and
+    // the account id already travels on each limit.
+    const merged: OmpUsageReportEntry = existing ?? { provider, limits: [] };
+    merged.limits = [...merged.limits, ...limits];
+    const notes = toStringArray(entry.notes);
+    if (notes) merged.notes = [...(merged.notes ?? []), ...notes];
+    snapshot.reports.set(provider, merged);
+  }
+
+  const withoutUsage = Array.isArray(payload.accountsWithoutUsage) ? payload.accountsWithoutUsage : [];
+  for (const entry of withoutUsage) {
+    const provider = isRecord(entry) && typeof entry.provider === 'string'
+      ? entry.provider.trim().toLowerCase()
+      : '';
+    if (provider && !snapshot.accountsWithoutUsage.includes(provider)) {
+      snapshot.accountsWithoutUsage.push(provider);
+    }
+  }
+  return snapshot;
+}
+
+let cached: { at: number; data: OmpUsageSnapshot } | null = null;
+let inFlight: Promise<OmpUsageSnapshot> | null = null;
+
+/**
+ * Read (and cache) the provider usage snapshot. Never throws — an unusable
+ * snapshot degrades to an empty one so the panel still shows local burn.
+ *
+ * `force` bypasses the TTL: the command calls every provider's endpoint, so a
+ * poll must be cheap, but the user's own Refresh button is entitled to fresh
+ * numbers rather than a minute-old snapshot.
+ */
+export async function fetchOmpUsageSnapshot(options: { force?: boolean } = {}): Promise<OmpUsageSnapshot> {
+  if (!options.force && cached && Date.now() - cached.at < CACHE_TTL_MS) return cached.data;
+  if (inFlight) return inFlight;
+
+  inFlight = (async () => {
+    const bin = resolveOmpBin();
+    if (!bin) return emptySnapshot();
+    try {
+      const proc = Bun.spawn({
+        cmd: [bin, 'usage', '--json'],
+        stdout: 'pipe',
+        stderr: 'pipe',
+        timeout: TIMEOUT_MS,
+        maxBuffer: MAX_BUFFER_BYTES,
+        windowsHide: true,
+      });
+      const stdout = await new Response(proc.stdout).text();
+      await proc.exited;
+      return parseOmpUsageSnapshot(JSON.parse(stdout));
+    } catch {
+      // no-excuse-ok: catch — a failed/timed-out/malformed probe is a soft miss
+      return emptySnapshot();
+    }
+  })();
+
+  try {
+    const data = await inFlight;
+    cached = { at: Date.now(), data };
+    return data;
+  } finally {
+    inFlight = null;
+  }
+}

package/src/server/lib/usage/provider-key.ts

@@ -1,11 +1,12 @@
 import { getDb } from '@/server/db.server';
-import { readOmpProviderApiKey } from '@/server/lib/omp/core/auth-credentials';
+import { fetchOmpRegistrySnapshot } from '@/server/lib/models/provider-registry.server';
+import { listAgentDbCredentialSlugs, listModelsYmlCredentialSlugs, readOmpProviderApiKey } from '@/server/lib/omp/core/auth-credentials';
 import { isRecord } from '@/shared/lib/util/guards';
 
 const SETTINGS_KEY = 'omp_providers_config';
 const MASKED_KEY_PATTERN = /•{3,}/;
 
-interface ProviderEntry {
+export interface ProviderEntry {
   name: string;
   slug: string;
   baseUrl: string;
@@ -22,7 +23,8 @@ function toProviderEntry(value: unknown): ProviderEntry | null {
   };
 }
 
-async function loadProviderEntries(): Promise<ProviderEntry[]> {
+/** The chamber's own provider overlay rows (app DB), unvalidated. */
+export async function loadProviderEntries(): Promise<ProviderEntry[]> {
   const db = await getDb();
   const row = await db.get<{ value?: string }>(
     'SELECT value FROM app_settings WHERE key = ?',
@@ -81,3 +83,79 @@ export function resolveDeepSeekApiKey(): Promise<string | null> {
     entry.slug.toLowerCase().includes('deepseek'),
   );
 }
+
+/** A provider slug with at least one usable credential, and where it came from. */
+export interface CredentialedProvider {
+  slug: string;
+  /** Human-readable credential stores, e.g. ["models.yml", "agent.db"]. */
+  sources: string[];
+}
+
+/** Slugs configured in the chamber's own provider overlay (app DB). */
+async function appDbSlugs(): Promise<Set<string>> {
+  const slugs = new Set<string>();
+  for (const entry of await loadProviderEntries()) {
+    const key = entry.apiKey.trim();
+    if (key.length === 0 || MASKED_KEY_PATTERN.test(key)) continue;
+    const slug = (entry.slug || entry.name).trim().toLowerCase();
+    if (slug) slugs.add(slug);
+  }
+  return slugs;
+}
+
+/**
+ * Slugs omp itself considers usable. This is the authoritative signal, because
+ * omp resolves credentials from places the chamber cannot enumerate — an
+ * `ANTHROPIC_API_KEY`-style environment variable is invisible to a models.yml /
+ * agent.db scan, yet omp happily runs on it. Two omp views are unioned:
+ *
+ *  - `get_login_providers` → `authenticated`, omp's own credential check;
+ *  - `get_available_models` → a provider serving models has a registered
+ *    credential (omp rejects a models.yml entry without an apiKey).
+ */
+async function ompRegistrySlugs(): Promise<Set<string>> {
+  const slugs = new Set<string>();
+  try {
+    const { providers, models } = await fetchOmpRegistrySnapshot();
+    for (const provider of providers) {
+      if (provider.authenticated) slugs.add(provider.id.trim().toLowerCase());
+    }
+    for (const model of models) slugs.add(model.provider.trim().toLowerCase());
+  } catch {
+    // no-excuse-ok: catch — a cold/busy omp degrades to the store-based scan
+  }
+  return slugs;
+}
+
+/**
+ * Every provider omp can currently authenticate, with the stores that supplied
+ * a credential. A provider absent from this list has no usable key and must not
+ * be surfaced in the usage UI. Never returns credential values.
+ */
+export async function listCredentialedProviders(): Promise<CredentialedProvider[]> {
+  const [appDb, modelsYml, agentDb, registry] = await Promise.all([
+    appDbSlugs(),
+    listModelsYmlCredentialSlugs(),
+    listAgentDbCredentialSlugs(),
+    ompRegistrySlugs(),
+  ]);
+
+  const sourcesBySlug = new Map<string, string[]>();
+  const add = (slug: string, source: string) => {
+    const sources = sourcesBySlug.get(slug) ?? [];
+    if (!sources.includes(source)) sources.push(source);
+    sourcesBySlug.set(slug, sources);
+  };
+  for (const slug of modelsYml) add(slug, 'models.yml');
+  for (const slug of agentDb) add(slug, 'agent.db');
+  for (const slug of appDb) add(slug, 'app DB');
+  // A provider omp resolves but no store accounts for: an environment variable
+  // or one of omp's own bundled defaults.
+  for (const slug of registry) {
+    if (!sourcesBySlug.has(slug)) add(slug, 'environment');
+  }
+
+  return [...sourcesBySlug.entries()]
+    .map(([slug, sources]) => ({ slug, sources }))
+    .sort((a, b) => a.slug.localeCompare(b.slug));
+}

package/src/server/lib/usage/providers.server.test.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { resolveUsageTracking } from '@/server/lib/usage/providers.server';
+
+/**
+ * `tracked` decides which explanation the Usage card shows when a provider has
+ * no quota windows: "omp has no usage endpoint for this" versus "omp tracks it
+ * but the endpoint returned nothing". Getting this backwards tells the user a
+ * supported provider is unsupported (or vice versa), so the rule is pinned
+ * here against the shapes `omp usage --json` actually produces.
+ *
+ * Verified against omp 18.3.0: with a stored DeepSeek key and no adapter,
+ * `accountsWithoutUsage` does NOT list deepseek; with a stored Anthropic key
+ * whose fetch fails, it DOES list anthropic.
+ */
+describe('resolveUsageTracking', () => {
+  test('a provider with a report and windows is tracked', () => {
+    const result = resolveUsageTracking('anthropic', {
+      reports: new Map([['anthropic', { provider: 'anthropic', limits: [] }]]),
+      accountsWithoutUsage: [],
+    });
+    expect(result).toEqual({ tracked: true, limitsUnavailable: false });
+  });
+
+  test('a provider listed in accountsWithoutUsage is tracked but empty', () => {
+    const result = resolveUsageTracking('anthropic', {
+      reports: new Map(),
+      accountsWithoutUsage: ['anthropic'],
+    });
+    expect(result).toEqual({ tracked: true, limitsUnavailable: true });
+  });
+
+  test('a provider in neither list has no usage endpoint', () => {
+    // deepseek / kenari / arbitrary gateways: credentialed, but omp ships no
+    // adapter, so it appears in neither structure.
+    const result = resolveUsageTracking('deepseek', {
+      reports: new Map([['anthropic', { provider: 'anthropic', limits: [] }]]),
+      accountsWithoutUsage: ['anthropic'],
+    });
+    expect(result).toEqual({ tracked: false, limitsUnavailable: false });
+  });
+});