fix(ollama): route models by advertised capability (#11088)

Landed with the design call resolved per the owner's pick — **option 1**: the synced store is now endpoint-agnostic (persistDiscoveredModels and managedModelImport no longer drop non-chat models at write time), and chat selectability moved to read time (auto-pool expansion in autoStrategy applies filterChatSelectableModels; the models-route projection already had its chatOnly filter). Your discovery test now passes end-to-end (3/3): /api/show capabilities persist per connection and image/embedding requests route through the advertising host.

Reconciliation notes: conflicted areas merged onto the current tip (adobe discovery import, requestedModel preflight signature, resolvedProvider fast-path coexists with the synced-route override — explicit resolution wins); carried base-red drains (#10055 memoization, #11071 test variants) dropped as already-landed; the managed-model-import exclusion test was propagated to the new contract (image/video models persist; the read filter still hides them from chat pickers — pinned by a new assertion). Full battery: 205/206 focused (the one red is a confirmed periodic-timer timing flake on the loaded devbox — 20/20 isolated), autoCombo vitest 30/30, combo suites 46/46, gates + typecheck clean.

Thank you @yourspraveen — the capability probe + routing design was right; it just needed the store contract opened up. Fixes #11087.

tests/unit/command-code-usage.test.ts

@@ -0,0 +1,260 @@
+/**
+ * tests/unit/command-code-usage.test.ts
+ *
+ * Command Code usage.ts dispatch + Provider Limits allowlists for
+ * monthly credits + 5h/weekly rolling windows (Bearer /alpha APIs).
+ */
+
+import { describe, it, afterEach } from "node:test";
+import assert from "node:assert/strict";
+
+const { __testing, USAGE_FETCHER_PROVIDERS, getUsageForProvider } =
+  await import("../../open-sse/services/usage.ts");
+const { USAGE_SUPPORTED_PROVIDERS } = await import("../../src/shared/constants/providers.ts");
+const { isSupportedUsageConnection } = await import("../../src/lib/usage/providerLimits.ts");
+const { convertUsageToQuotaInfo } = await import("../../open-sse/services/genericQuotaFetcher.ts");
+const { getCommandCodeUsage } = __testing;
+
+const originalFetch = globalThis.fetch;
+
+type QuotaShape = {
+  used: number;
+  total: number;
+  remaining?: number;
+  remainingPercentage?: number;
+  resetAt: string | null;
+  currency?: string;
+  displayName?: string;
+};
+
+function jsonResponse(body: unknown, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+const CREDITS_PAYLOAD = {
+  credits: {
+    belowThreshold: false,
+    creditThreshold: 0,
+    monthlyCredits: 34.9522404823,
+    purchasedCredits: 0.0446690956,
+    freeCredits: 0,
+  },
+  windowLimits: {
+    limited: true,
+    exceeded: "weekly",
+    fiveHour: {
+      used: 0,
+      cap: 14,
+      exceeded: false,
+      resetAt: 0,
+    },
+    weekly: {
+      used: 35.0477595177,
+      cap: 35,
+      exceeded: true,
+      resetAt: 1786575240518,
+    },
+  },
+};
+
+const WHOAMI_PERSONAL = {
+  success: true,
+  user: { id: "u1", name: "dev", email: "dev@example.com", userName: "dev" },
+  org: null,
+};
+
+const SUBSCRIPTION_GOAT = {
+  success: true,
+  data: {
+    id: "sub_1",
+    status: "active",
+    orgId: null,
+    currentPeriodStart: "2026-08-05T22:27:41.000Z",
+    currentPeriodEnd: "2026-09-05T22:27:41.000Z",
+    planId: "individual-goat",
+  },
+};
+
+const USAGE_SUMMARY = {
+  totalCount: 1260,
+  totalCost: 55.0030904221,
+  totalMonthlyCredits: 35.0477595177,
+  totalPurchasedCredits: 19.9553309044,
+  periodBasis: "billing-period",
+};
+
+function installMockFetch(handlers: Record<string, () => Response>) {
+  globalThis.fetch = async (input: RequestInfo | URL) => {
+    const url = String(input);
+    for (const [needle, handler] of Object.entries(handlers)) {
+      if (url.includes(needle)) return handler();
+    }
+    return jsonResponse({ error: `unhandled fetch: ${url}` }, 500);
+  };
+}
+
+describe("Command Code usage dispatch", () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it("registers command-code in USAGE_FETCHER_PROVIDERS and USAGE_SUPPORTED_PROVIDERS", () => {
+    assert.ok((USAGE_FETCHER_PROVIDERS as readonly string[]).includes("command-code"));
+    assert.ok((USAGE_SUPPORTED_PROVIDERS as readonly string[]).includes("command-code"));
+  });
+
+  it("isSupportedUsageConnection accepts command-code apikey connections", () => {
+    assert.equal(
+      isSupportedUsageConnection({
+        id: "c1",
+        provider: "command-code",
+        authType: "apikey",
+      }),
+      true
+    );
+  });
+
+  it("getCommandCodeUsage maps credits + windows + period spend", async () => {
+    installMockFetch({
+      "/alpha/whoami": () => jsonResponse(WHOAMI_PERSONAL),
+      "/alpha/billing/credits": () => jsonResponse(CREDITS_PAYLOAD),
+      "/alpha/billing/subscriptions": () => jsonResponse(SUBSCRIPTION_GOAT),
+      "/alpha/usage/summary": () => jsonResponse(USAGE_SUMMARY),
+    });
+
+    const r = (await getCommandCodeUsage("cc-key")) as {
+      plan?: string;
+      message?: string;
+      quotas?: {
+        five_hour?: QuotaShape;
+        weekly?: QuotaShape;
+        credits?: QuotaShape;
+      };
+    };
+
+    assert.ok(r.quotas?.five_hour, `expected five_hour, got: ${JSON.stringify(r)}`);
+    assert.ok(r.quotas?.weekly, `expected weekly, got: ${JSON.stringify(r)}`);
+    assert.ok(r.quotas?.credits, `expected credits, got: ${JSON.stringify(r)}`);
+    assert.match(r.plan || "", /GOAT/i);
+
+    assert.equal(r.quotas!.five_hour!.used, 0);
+    assert.equal(r.quotas!.five_hour!.total, 14);
+    assert.equal(r.quotas!.five_hour!.resetAt, null);
+    assert.equal(r.quotas!.five_hour!.currency, "USD");
+
+    // used clamped to total when upstream reports slight overshoot
+    assert.equal(r.quotas!.weekly!.used, 35);
+    assert.equal(r.quotas!.weekly!.total, 35);
+    assert.equal(r.quotas!.weekly!.remaining, 0);
+    assert.equal(r.quotas!.weekly!.remainingPercentage, 0);
+    assert.ok(r.quotas!.weekly!.resetAt?.startsWith("2026-"));
+
+    const remainingCredits = 34.9522404823 + 0.0446690956;
+    assert.ok(Math.abs((r.quotas!.credits!.remaining ?? 0) - remainingCredits) < 1e-9);
+    assert.equal(r.quotas!.credits!.used, USAGE_SUMMARY.totalCost);
+    assert.ok(
+      Math.abs(r.quotas!.credits!.total - (USAGE_SUMMARY.totalCost + remainingCredits)) < 1e-9
+    );
+    assert.equal(r.quotas!.credits!.resetAt, "2026-09-05T22:27:41.000Z");
+    assert.equal(r.quotas!.credits!.currency, "USD");
+  });
+
+  it("getCommandCodeUsage works for org:null without orgId query params", async () => {
+    const seen: string[] = [];
+    globalThis.fetch = async (input: RequestInfo | URL) => {
+      const url = String(input);
+      seen.push(url);
+      if (url.includes("/alpha/whoami")) return jsonResponse(WHOAMI_PERSONAL);
+      if (url.includes("/alpha/billing/credits")) return jsonResponse(CREDITS_PAYLOAD);
+      if (url.includes("/alpha/billing/subscriptions")) return jsonResponse(SUBSCRIPTION_GOAT);
+      if (url.includes("/alpha/usage/summary")) return jsonResponse(USAGE_SUMMARY);
+      return jsonResponse({ error: "unhandled" }, 500);
+    };
+
+    await getCommandCodeUsage("cc-key");
+    assert.ok(seen.some((u) => u.includes("/alpha/billing/credits")));
+    assert.ok(!seen.some((u) => /[?&]orgId=/.test(u)));
+  });
+
+  it("getCommandCodeUsage returns message when apiKey missing", async () => {
+    const r = (await getCommandCodeUsage("")) as { message?: string; quotas?: unknown };
+    assert.ok(r.message && !r.quotas);
+  });
+
+  it("getCommandCodeUsage returns message-only on 401", async () => {
+    installMockFetch({
+      "/alpha/whoami": () => jsonResponse({ success: false }, 401),
+      "/alpha/billing/credits": () =>
+        jsonResponse(
+          {
+            success: false,
+            error: { code: "UNAUTHORIZED", status: 401, message: "Invalid token" },
+          },
+          401
+        ),
+    });
+
+    const r = (await getCommandCodeUsage("bad-key")) as { message?: string; quotas?: unknown };
+    assert.ok(r.message && !r.quotas);
+  });
+
+  it("getCommandCodeUsage soft-fails when subscription/summary unavailable", async () => {
+    installMockFetch({
+      "/alpha/whoami": () => jsonResponse(WHOAMI_PERSONAL),
+      "/alpha/billing/credits": () => jsonResponse(CREDITS_PAYLOAD),
+      "/alpha/billing/subscriptions": () => jsonResponse({ success: false }, 500),
+      "/alpha/usage/summary": () => jsonResponse({ error: "boom" }, 500),
+    });
+
+    const r = (await getCommandCodeUsage("cc-key")) as {
+      plan?: string;
+      quotas?: { five_hour?: QuotaShape; weekly?: QuotaShape; credits?: QuotaShape };
+    };
+
+    assert.ok(r.quotas?.five_hour);
+    assert.ok(r.quotas?.weekly);
+    assert.ok(r.quotas?.credits);
+    // Without summary spend, used defaults to 0; remaining still from credit pools
+    assert.equal(r.quotas!.credits!.used, 0);
+    assert.ok((r.quotas!.credits!.remaining ?? 0) > 0);
+  });
+
+  it("getUsageForProvider('command-code', ...) delegates to getCommandCodeUsage", async () => {
+    installMockFetch({
+      "/alpha/whoami": () => jsonResponse(WHOAMI_PERSONAL),
+      "/alpha/billing/credits": () => jsonResponse(CREDITS_PAYLOAD),
+      "/alpha/billing/subscriptions": () => jsonResponse(SUBSCRIPTION_GOAT),
+      "/alpha/usage/summary": () => jsonResponse(USAGE_SUMMARY),
+    });
+
+    const r = (await getUsageForProvider({
+      id: "conn-cc",
+      provider: "command-code",
+      apiKey: "dispatch-key",
+    } as Parameters<typeof getUsageForProvider>[0])) as {
+      quotas?: { weekly?: QuotaShape };
+      plan?: string;
+    };
+
+    assert.match(r.plan || "", /GOAT/i);
+    assert.equal(r.quotas?.weekly?.total, 35);
+  });
+
+  it("convertUsageToQuotaInfo marks weekly-exhausted Command Code as limitReached", async () => {
+    installMockFetch({
+      "/alpha/whoami": () => jsonResponse(WHOAMI_PERSONAL),
+      "/alpha/billing/credits": () => jsonResponse(CREDITS_PAYLOAD),
+      "/alpha/billing/subscriptions": () => jsonResponse(SUBSCRIPTION_GOAT),
+      "/alpha/usage/summary": () => jsonResponse(USAGE_SUMMARY),
+    });
+
+    const usage = await getCommandCodeUsage("cc-key");
+    const info = convertUsageToQuotaInfo(usage);
+    assert.ok(info);
+    assert.equal(info!.limitReached, true);
+    assert.ok((info!.windows.weekly?.percentUsed ?? 0) >= 1 - 1e-9);
+  });
+});