test(catalog): cover TTL expiry, retired models, malformed payloads

Closes the four gaps flagged in the review of PR #8:
- TTL expiry actually elapses and refetches (Date.now spy)
- static entries survive when the API no longer lists them (retired
  upstream models keep static name/context, source: "static")
- malformed payloads: data:null keeps the catalog; id-less and null
  items are skipped instead of discarding the whole refresh (also
  hardened the filter in catalog.ts for this); null context_length
  falls back to 128k
- resolveAnthropicModel keeps the claude-* default pinned to the static
  first entry even when the API returns a reordered list

166 tests pass, typecheck clean.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: thaolaptrinh

src/translate/catalog.ts

@@ -115,7 +115,12 @@ export async function refreshCatalog(
   inflight = (async () => {
     try {
       const apiModels = await fetchApiModels(apiBase, apiKey);
-      const open = apiModels.filter((m) => m.id && !isClosedModel(m.id));
+      // Tolerate junk entries (null items, missing ids) rather than letting
+      // one malformed record discard the whole refresh.
+      const open = apiModels.filter(
+        (m): m is ApiModel & { id: string } =>
+          typeof m === "object" && m !== null && typeof m.id === "string" && !isClosedModel(m.id),
+      );
       if (open.length > 0) {
         const apiById = new Map(open.map((m) => [m.id, m]));
         const merged: CatalogModel[] = [];

tests/anthropic-models.test.ts

@@ -1,16 +1,20 @@
-import { describe, test, expect, beforeEach, afterEach } from "vitest";
+import { describe, test, expect, beforeEach, afterEach, vi } from "vitest";
 import { resolveAnthropicModel } from "@/translate/anthropic-models.js";
+import { refreshCatalog, __resetCatalogForTests } from "@/translate/catalog.js";
+import { mockCcModelsFetch } from "./helpers.js";
 
 describe("resolveAnthropicModel", () => {
   let originalEnv: NodeJS.ProcessEnv;
 
   beforeEach(() => {
     originalEnv = { ...process.env };
     delete process.env.ANTHROPIC_DEFAULT_MODEL;
+    __resetCatalogForTests();
   });
 
   afterEach(() => {
     process.env = originalEnv;
+    vi.restoreAllMocks();
   });
 
   test("claude-* uses ANTHROPIC_DEFAULT_MODEL env", () => {
@@ -27,4 +31,16 @@ describe("resolveAnthropicModel", () => {
   test("non-claude model passes through", () => {
     expect(resolveAnthropicModel("custom-model")).toBe("custom-model");
   });
+
+  test("claude-* default stays stable even when the API returns a reordered list", async () => {
+    // The API lists models in its own order (closed models first in the wild).
+    // The static-first merge must keep getDefaultModels()[0] — and thus the
+    // claude-* fallback — pinned to the static builtin's first entry.
+    mockCcModelsFetch([
+      { id: "zai-org/GLM-5.3", name: "GLM-5.3", context_length: 1000000 },
+      { id: "deepseek/deepseek-v4-flash", name: "DeepSeek V4 Flash", context_length: 1000000 },
+    ]);
+    await refreshCatalog("https://api.test-cc.example", "test-key");
+    expect(resolveAnthropicModel("claude-opus-4-1")).toBe("deepseek/deepseek-v4-pro");
+  });
 });

tests/catalog.test.ts

@@ -89,6 +89,57 @@ describe("refreshCatalog", () => {
     await refreshCatalog(API_BASE, API_KEY, { force: true });
     expect(calls.count).toBe(2);
   });
+
+  it("refetches once the TTL has elapsed", async () => {
+    const calls = { count: 0 };
+    mockFetch(API_MODELS, calls);
+    const now = vi.spyOn(Date, "now");
+    await refreshCatalog(API_BASE, API_KEY);
+    expect(calls.count).toBe(1);
+    // Jump past the 1h TTL.
+    now.mockReturnValue(Date.now() + 60 * 60 * 1000 + 1);
+    try {
+      await refreshCatalog(API_BASE, API_KEY);
+      expect(calls.count).toBe(2);
+    } finally {
+      now.mockRestore();
+    }
+  });
+
+  it("keeps static entries the API no longer lists (retired upstream models)", async () => {
+    // The payload only knows deepseek-v4-pro — every other static builtin
+    // model has "disappeared" from the API.
+    mockFetch([{ id: "deepseek/deepseek-v4-pro", name: "DeepSeek V4 Pro", context_length: 1 }]);
+    const catalog = await refreshCatalog(API_BASE, API_KEY);
+    const glm = catalog.models.find((m) => m.id === "zai-org/GLM-5.2");
+    expect(glm).toBeDefined();
+    expect(glm?.source).toBe("static");
+    // Static fallbacks fill in name + context when the API is silent.
+    expect(glm?.displayName).toBe("GLM-5.2");
+    expect(glm?.contextWindow).toBe(1048576);
+    // The one model the API still knows is flagged as api-sourced.
+    expect(catalog.models.find((m) => m.id === "deepseek/deepseek-v4-pro")?.source).toBe("api");
+  });
+
+  it("tolerates malformed API payloads without corrupting the catalog", async () => {
+    const before = getCatalog().ids;
+
+    // data: null
+    mockFetch(null);
+    expect((await refreshCatalog(API_BASE, API_KEY, { force: true })).ids).toEqual(before);
+
+    // items missing id are skipped; null context_length falls back
+    mockFetch([
+      null,
+      { name: "No Id Model" },
+      { id: "neworg/No-Context", name: "No Context", context_length: null },
+    ]);
+    const catalog = await refreshCatalog(API_BASE, API_KEY, { force: true });
+    expect(catalog.ids).toContain("neworg/No-Context");
+    expect(catalog.contextWindows["neworg/No-Context"]).toBe(128_000);
+    // The id-less entries never made it in.
+    expect(catalog.ids.length).toBe(before.length + 1);
+  });
 });
 
 describe("resolveModel against the dynamic catalog", () => {