@tyvm/knowhow 0.0.138 → 0.0.141

package/tests/agents/tools/sendAgentMessage.test.ts

@@ -0,0 +1,99 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { sendAgentMessage } from "../../../src/agents/tools/sendAgentMessage";
+
+describe("sendAgentMessage", () => {
+  let tmpCwd: string;
+  let originalCwd: string;
+  let agentsDir: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), "send-msg-"));
+    process.chdir(tmpCwd);
+    agentsDir = path.join(tmpCwd, ".knowhow", "processes", "agents");
+    fs.mkdirSync(agentsDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpCwd, { recursive: true, force: true });
+  });
+
+  function makeTask(taskId: string): string {
+    const dir = path.join(agentsDir, taskId);
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+
+  it("requires taskId and message", async () => {
+    expect(await sendAgentMessage({ taskId: "", message: "hi" })).toMatch(
+      /taskId is required/
+    );
+    expect(await sendAgentMessage({ taskId: "x", message: "" })).toMatch(
+      /message is required/
+    );
+  });
+
+  it("errors when the target task dir doesn't exist", async () => {
+    const res = await sendAgentMessage({ taskId: "nope", message: "hi" });
+    expect(res).toMatch(/target task directory not found/);
+  });
+
+  it("appends an envelope with sender identity from _ctx", async () => {
+    makeTask("child-1");
+    const res = await sendAgentMessage({
+      taskId: "child-1",
+      message: "do the thing",
+      _ctx: { taskId: "parent-1", caller: { name: "Developer" } },
+    });
+    expect(res).toMatch(/Sent message to task child-1/);
+    const input = fs.readFileSync(
+      path.join(agentsDir, "child-1", "input.txt"),
+      "utf8"
+    );
+    expect(input).toContain("[from:parent-1/Developer] do the thing");
+  });
+
+  it("uses explicit from when provided", async () => {
+    makeTask("child-2");
+    await sendAgentMessage({
+      taskId: "child-2",
+      message: "msg",
+      from: "orchestrator",
+    });
+    const input = fs.readFileSync(
+      path.join(agentsDir, "child-2", "input.txt"),
+      "utf8"
+    );
+    expect(input).toContain("[from:orchestrator] msg");
+  });
+
+  it("delivers as /poke when poke:true (interrupts recipient)", async () => {
+    makeTask("child-3");
+    await sendAgentMessage({
+      taskId: "child-3",
+      message: "stop and reconsider",
+      from: "boss",
+      poke: true,
+    });
+    const input = fs.readFileSync(
+      path.join(agentsDir, "child-3", "input.txt"),
+      "utf8"
+    );
+    expect(input).toMatch(/^\/poke \[from:boss\] stop and reconsider/);
+  });
+
+  it("appends without clobbering existing pending messages", async () => {
+    const dir = makeTask("child-4");
+    fs.writeFileSync(path.join(dir, "input.txt"), "existing line\n", "utf8");
+    await sendAgentMessage({
+      taskId: "child-4",
+      message: "second",
+      from: "a",
+    });
+    const input = fs.readFileSync(path.join(dir, "input.txt"), "utf8");
+    expect(input).toBe("existing line\n[from:a] second\n");
+  });
+});

package/tests/agents/tools/waitForAgentCompleted.test.ts

@@ -0,0 +1,147 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { waitForAgentCompleted } from "../../../src/agents/tools/waitForAgentCompleted";
+
+describe("waitForAgentCompleted", () => {
+  let tmpCwd: string;
+  let originalCwd: string;
+  let agentsDir: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    tmpCwd = fs.mkdtempSync(path.join(os.tmpdir(), "wait-agent-"));
+    process.chdir(tmpCwd);
+    agentsDir = path.join(tmpCwd, ".knowhow", "processes", "agents");
+    fs.mkdirSync(agentsDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tmpCwd, { recursive: true, force: true });
+  });
+
+  function makeTask(taskId: string, meta: Record<string, any> = {}, status?: string) {
+    const dir = path.join(agentsDir, taskId);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, "metadata.json"),
+      JSON.stringify({ taskId, ...meta }, null, 2),
+      "utf8"
+    );
+    if (status !== undefined) {
+      fs.writeFileSync(path.join(dir, "status.txt"), status, "utf8");
+    }
+    return dir;
+  }
+
+  it("returns error when taskId missing", async () => {
+    const res = JSON.parse(await waitForAgentCompleted({ taskId: "" }));
+    expect(res.status).toBe("error");
+    expect(res.error).toMatch(/taskId is required/);
+  });
+
+  it("returns error when task directory does not exist", async () => {
+    const res = JSON.parse(await waitForAgentCompleted({ taskId: "nope" }));
+    expect(res.status).toBe("error");
+    expect(res.error).toMatch(/No agent task directory/);
+  });
+
+  it("returns immediately with structured result for a completed task", async () => {
+    makeTask("done-1", {
+      status: "completed",
+      totalCostUsd: 1.23,
+      result: "the final answer",
+      artifacts: ["a.txt"],
+    });
+
+    const res = JSON.parse(await waitForAgentCompleted({ taskId: "done-1" }));
+    expect(res.status).toBe("completed");
+    expect(res.costUsd).toBe(1.23);
+    expect(res.finalAnswer).toBe("the final answer");
+    expect(res.artifacts).toEqual(["a.txt"]);
+  });
+
+  it("falls back to last assistant message when no result field", async () => {
+    makeTask("done-2", {
+      status: "completed",
+      totalCostUsd: 0.5,
+      threads: [
+        [
+          { role: "user", content: "do it" },
+          { role: "assistant", content: "I did it" },
+        ],
+      ],
+    });
+
+    const res = JSON.parse(await waitForAgentCompleted({ taskId: "done-2" }));
+    expect(res.finalAnswer).toBe("I did it");
+  });
+
+  it("treats inProgress:false with no status as completed", async () => {
+    makeTask("done-3", { inProgress: false, totalCostUsd: 0.1, result: "ok" });
+    const res = JSON.parse(await waitForAgentCompleted({ taskId: "done-3" }));
+    expect(res.status).toBe("completed");
+  });
+
+  it("times out on a still-running task", async () => {
+    makeTask("running-1", { status: "running", totalCostUsd: 0.2 });
+    const res = JSON.parse(
+      await waitForAgentCompleted({
+        taskId: "running-1",
+        timeoutMs: 300,
+        pollIntervalMs: 100,
+      })
+    );
+    expect(res.timedOut).toBe(true);
+    expect(res.status).toBe("running");
+    expect(res.costUsd).toBe(0.2);
+  });
+
+  it("resolves when a running task transitions to completed mid-poll", async () => {
+    const dir = makeTask("running-2", { status: "running", totalCostUsd: 0 });
+
+    // Flip to completed shortly after we start waiting.
+    setTimeout(() => {
+      fs.writeFileSync(
+        path.join(dir, "metadata.json"),
+        JSON.stringify(
+          {
+            taskId: "running-2",
+            status: "completed",
+            totalCostUsd: 2.0,
+            result: "eventually done",
+          },
+          null,
+          2
+        ),
+        "utf8"
+      );
+    }, 150);
+
+    const res = JSON.parse(
+      await waitForAgentCompleted({
+        taskId: "running-2",
+        timeoutMs: 3000,
+        pollIntervalMs: 100,
+      })
+    );
+    expect(res.status).toBe("completed");
+    expect(res.finalAnswer).toBe("eventually done");
+    expect(res.costUsd).toBe(2.0);
+  });
+
+  it("fails a task whose pid is dead without a terminal status", async () => {
+    // Use a pid that is virtually guaranteed not to exist.
+    makeTask("crashed-1", { status: "running", totalCostUsd: 0.3, pid: 999999 });
+    const res = JSON.parse(
+      await waitForAgentCompleted({
+        taskId: "crashed-1",
+        timeoutMs: 5000,
+        pollIntervalMs: 100,
+      })
+    );
+    expect(res.status).toBe("failed");
+    expect(res.error).toMatch(/exited without writing a terminal status/);
+  });
+});

package/tests/chat/detach-attach-rendering.test.ts

@@ -0,0 +1,315 @@
+
+/**
+ * Tests for detach / re-attach rendering correctness.
+ *
+ * Bug: after calling /detach and then /attach again, the agent's tool calls
+ * and messages were not rendering to the console.
+ *
+ * Root cause: both SessionsModule.attachToFsAgent / attachToWebAgent AND
+ * AgentModule.attachedAgentChatLoop were calling wireAgentRendering().
+ * Since wireAgentRendering uses setListener (keyed, replaces-on-conflict),
+ * the second call on the SAME EventService replaced the first — but the
+ * watcher's `done` event handler registered by SessionsModule was also
+ * removed. More critically: after /detach, unwireAgentRendering() removes
+ * the keyed listeners from `_wireAgentEvents` and clears the stored ref.
+ * On re-attach a new FsSyncedAgentWatcher is created with a fresh
+ * EventService, but the double-wire means the stored `_wireAgentEvents`
+ * ref held by the AgentModule was pointing at the WRONG EventService
+ * (the one from the second wireAgentRendering call).
+ *
+ * The fix: SessionsModule no longer calls wireAgentRendering itself —
+ * it delegates entirely to attachedAgentChatLoop which already calls it.
+ *
+ * These tests verify the wireAgentRendering / unwireAgentRendering contract
+ * using real EventService instances so we catch regressions in EventService
+ * changes too.
+ */
+
+import { EventService } from "../../src/services/EventService";
+
+// ─── Minimal harness that mirrors AgentModule's wire/unwire logic exactly ────
+
+const EVENT_TYPES = {
+  done: "done",
+  toolCall: "tool:pre_call",
+  toolUsed: "tool:post_call",
+  agentSay: "agent:say",
+  threadUpdate: "thread_update",
+};
+
+interface RenderEvent {
+  type: string;
+  taskId: string;
+  agentName: string;
+  data: any;
+}
+
+class RenderingHarness {
+  // Mirror of AgentModule's stored wire params
+  private _wireAgentEvents: EventService | undefined;
+  private _wireTaskId: string | undefined;
+  private _wireAgentName: string | undefined;
+  private _wireEventTypes:
+    | { toolCall?: string; toolUsed?: string; agentSay?: string; done: string }
+    | undefined;
+
+  public rendered: RenderEvent[] = [];
+
+  /**
+   * Mirrors AgentModule.wireAgentRendering exactly (uses real EventService.setListener).
+   */
+  wireAgentRendering(
+    taskId: string,
+    agentEvents: EventService,
+    eventTypes: { toolCall?: string; toolUsed?: string; agentSay?: string; done: string },
+    agentName: string
+  ): void {
+    if (eventTypes.toolCall) {
+      agentEvents.setListener(
+        { key: "agentModule:render:toolCall", event: eventTypes.toolCall },
+        (data: any) => this.rendered.push({ type: "toolCall", taskId, agentName, data })
+      );
+    }
+    if (eventTypes.toolUsed) {
+      agentEvents.setListener(
+        { key: "agentModule:render:toolUsed", event: eventTypes.toolUsed },
+        (data: any) => this.rendered.push({ type: "toolResult", taskId, agentName, data })
+      );
+    }
+    if (eventTypes.agentSay) {
+      agentEvents.setListener(
+        { key: "agentModule:render:agentSay", event: eventTypes.agentSay },
+        (data: any) => this.rendered.push({ type: "agentMessage", taskId, agentName, data })
+      );
+    }
+    this._wireAgentEvents = agentEvents;
+    this._wireTaskId = taskId;
+    this._wireAgentName = agentName;
+    this._wireEventTypes = eventTypes;
+  }
+
+  /**
+   * Mirrors AgentModule.unwireAgentRendering exactly.
+   */
+  unwireAgentRendering(): void {
+    if (this._wireAgentEvents) {
+      this._wireAgentEvents.removeManagedListenersByPrefix("agentModule:render:");
+      this._wireAgentEvents = undefined;
+    }
+    this._wireTaskId = undefined;
+    this._wireAgentName = undefined;
+    this._wireEventTypes = undefined;
+  }
+
+  reset() {
+    this.rendered = [];
+  }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("detach / re-attach rendering", () => {
+  let harness: RenderingHarness;
+
+  beforeEach(() => {
+    harness = new RenderingHarness();
+  });
+
+  // 1. Basic: emitted events reach the renderer after wireAgentRendering ────────
+
+  it("emitted events reach the renderer after wireAgentRendering", () => {
+    const events = new EventService();
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
+
+    events.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "execCommand" } } });
+    events.emit(EVENT_TYPES.agentSay, { message: "hello" });
+    events.emit(EVENT_TYPES.toolUsed, { toolCall: {}, functionResp: "output" });
+
+    expect(harness.rendered).toHaveLength(3);
+    expect(harness.rendered[0].type).toBe("toolCall");
+    expect(harness.rendered[1].type).toBe("agentMessage");
+    expect(harness.rendered[2].type).toBe("toolResult");
+  });
+
+  // 2. After detach (unwire), old EventService no longer triggers renders ───────
+
+  it("old EventService does NOT render after unwireAgentRendering (detach)", () => {
+    const events = new EventService();
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
+
+    // Verify wired first
+    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+    expect(harness.rendered).toHaveLength(1);
+    harness.reset();
+
+    // Detach
+    harness.unwireAgentRendering();
+
+    // Emit on the OLD EventService — nothing should render
+    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+    events.emit(EVENT_TYPES.agentSay, { message: "zombie" });
+    events.emit(EVENT_TYPES.toolUsed, { toolCall: {}, functionResp: "output" });
+
+    expect(harness.rendered).toHaveLength(0);
+  });
+
+  // 3. Re-attach on a NEW EventService renders correctly ───────────────────────
+
+  it("events on a NEW EventService render after re-wiring (re-attach)", () => {
+    const oldEvents = new EventService();
+    harness.wireAgentRendering("task-1", oldEvents, EVENT_TYPES, "Dev");
+    harness.unwireAgentRendering();
+
+    // Re-attach: new watcher = new EventService
+    const newEvents = new EventService();
+    harness.wireAgentRendering("task-1", newEvents, EVENT_TYPES, "Dev");
+
+    newEvents.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "readFile" } } });
+    newEvents.emit(EVENT_TYPES.agentSay, { message: "re-attached message" });
+
+    expect(harness.rendered).toHaveLength(2);
+    expect(harness.rendered[0].type).toBe("toolCall");
+    expect(harness.rendered[0].data.toolCall.function.name).toBe("readFile");
+    expect(harness.rendered[1].type).toBe("agentMessage");
+    expect(harness.rendered[1].data.message).toBe("re-attached message");
+  });
+
+  // 4. Old EventService still silent after re-attach on new EventService ────────
+
+  it("old EventService stays silent after re-attach on new EventService", () => {
+    const oldEvents = new EventService();
+    harness.wireAgentRendering("task-1", oldEvents, EVENT_TYPES, "Dev");
+    harness.unwireAgentRendering();
+
+    const newEvents = new EventService();
+    harness.wireAgentRendering("task-1", newEvents, EVENT_TYPES, "Dev");
+
+    // New events render
+    newEvents.emit(EVENT_TYPES.agentSay, { message: "new" });
+    expect(harness.rendered).toHaveLength(1);
+
+    // Old events still silent
+    oldEvents.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+    oldEvents.emit(EVENT_TYPES.agentSay, { message: "old" });
+    expect(harness.rendered).toHaveLength(1); // unchanged
+  });
+
+  // 5. Double-wire on the SAME EventService does NOT double-render ──────────────
+  //
+  // This is the bug that existed: SessionsModule.attachToFsAgent called
+  // wireAgentRendering, then attachedAgentChatLoop also called it.
+  // Since setListener is keyed (replaces), the net result is one listener —
+  // but the done handler registered by SessionsModule was lost.
+  // The fix removes the extra wireAgentRendering from SessionsModule.
+
+  it("calling wireAgentRendering twice on same EventService does NOT double-render", () => {
+    const events = new EventService();
+
+    // Simulate the OLD (buggy) behavior: SessionsModule wires, then attachedAgentChatLoop wires again
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev"); // first call
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev"); // second call (setListener replaces)
+
+    events.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+
+    // setListener keyed — only ONE render expected, not two
+    expect(harness.rendered).toHaveLength(1);
+  });
+
+  // 6. Full cycle: attach → emit → detach → re-attach → emit all render correctly
+
+  it("full attach → detach → re-attach cycle: all phases render correctly", () => {
+    // ── First attach ──────────────────────────────────────────────────────────
+    const watcher1 = new EventService();
+    harness.wireAgentRendering("task-A", watcher1, EVENT_TYPES, "Developer");
+
+    watcher1.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "execCommand" } } });
+    watcher1.emit(EVENT_TYPES.agentSay, { message: "initial work" });
+    expect(harness.rendered).toHaveLength(2);
+    harness.reset();
+
+    // ── /detach ───────────────────────────────────────────────────────────────
+    harness.unwireAgentRendering();
+
+    // Events from watcher1 after detach should NOT render
+    watcher1.emit(EVENT_TYPES.toolCall, { toolCall: {} });
+    watcher1.emit(EVENT_TYPES.agentSay, { message: "zombie message" });
+    expect(harness.rendered).toHaveLength(0);
+
+    // ── Re-attach (new FsSyncedAgentWatcher creates a new EventService) ───────
+    const watcher2 = new EventService();
+    harness.wireAgentRendering("task-A", watcher2, EVENT_TYPES, "Developer");
+
+    watcher2.emit(EVENT_TYPES.toolCall, { toolCall: { function: { name: "readFile" } } });
+    watcher2.emit(EVENT_TYPES.agentSay, { message: "continuing after re-attach" });
+
+    // THE CRITICAL ASSERTION: renders must arrive after re-attach
+    expect(harness.rendered).toHaveLength(2);
+    expect(harness.rendered[0].type).toBe("toolCall");
+    expect(harness.rendered[0].data.toolCall.function.name).toBe("readFile");
+    expect(harness.rendered[1].type).toBe("agentMessage");
+    expect(harness.rendered[1].data.message).toBe("continuing after re-attach");
+  });
+
+  // 7. toolResult renders after re-attach ──────────────────────────────────────
+
+  it("toolResult events render after re-attach", () => {
+    const events1 = new EventService();
+    harness.wireAgentRendering("task-1", events1, EVENT_TYPES, "Dev");
+    harness.unwireAgentRendering();
+
+    const events2 = new EventService();
+    harness.wireAgentRendering("task-1", events2, EVENT_TYPES, "Dev");
+
+    events2.emit(EVENT_TYPES.toolUsed, {
+      toolCall: { function: { name: "execCommand" } },
+      functionResp: "$ echo hello\nhello",
+    });
+
+    expect(harness.rendered).toHaveLength(1);
+    expect(harness.rendered[0].type).toBe("toolResult");
+    expect(harness.rendered[0].data.functionResp).toBe("$ echo hello\nhello");
+  });
+
+  // 8. Multiple sequential attach/detach cycles all work ───────────────────────
+
+  it("3 sequential attach/detach cycles all render correctly", () => {
+    for (let i = 0; i < 3; i++) {
+      harness.reset();
+      const events = new EventService();
+      harness.wireAgentRendering(`task-${i}`, events, EVENT_TYPES, "Dev");
+
+      events.emit(EVENT_TYPES.agentSay, { message: `cycle ${i}` });
+      expect(harness.rendered).toHaveLength(1);
+      expect(harness.rendered[0].data.message).toBe(`cycle ${i}`);
+      expect(harness.rendered[0].taskId).toBe(`task-${i}`);
+
+      // Detach: old events stop rendering
+      harness.unwireAgentRendering();
+      events.emit(EVENT_TYPES.agentSay, { message: "should not render" });
+      expect(harness.rendered).toHaveLength(1); // still 1, not 2
+    }
+  });
+
+  // 9. hasManagedListener confirms listener is present/absent at right times ───
+
+  it("hasManagedListener reflects wired/unwired state correctly", () => {
+    const events = new EventService();
+
+    // Before wiring: no managed render listeners
+    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(false);
+    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(false);
+
+    harness.wireAgentRendering("task-1", events, EVENT_TYPES, "Dev");
+
+    // After wiring: listeners registered
+    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(true);
+    expect(events.hasManagedListener("agentModule:render:toolUsed")).toBe(true);
+    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(true);
+
+    harness.unwireAgentRendering();
+
+    // After detach: listeners removed
+    expect(events.hasManagedListener("agentModule:render:toolCall")).toBe(false);
+    expect(events.hasManagedListener("agentModule:render:agentSay")).toBe(false);
+  });
+});

package/tests/clients/contextLimits.test.ts

@@ -4,6 +4,27 @@
  */
 import { Models } from "../../src/types";
 import { ContextLimits, getModelContextLimit, DEFAULT_CONTEXT_LIMIT } from "../../src/clients/contextLimits";
+import {
+  OpenAiTextPricing,
+  GeminiTextPricing,
+  AnthropicTextPricing,
+  XaiTextPricing,
+} from "../../src/clients/pricing";
+
+// Model ids explicitly marked deprecated across all pricing tables. Deprecated
+// models are allowed to be absent from ContextLimits — they can be trimmed from
+// Models.* / the context-limit map without breaking anything, since cost
+// tracking reads the *TextPricing tables directly by model id.
+const deprecatedModelIds = new Set<string>(
+  Object.entries({
+    ...OpenAiTextPricing,
+    ...GeminiTextPricing,
+    ...AnthropicTextPricing,
+    ...XaiTextPricing,
+  } as Record<string, { deprecated?: boolean }>)
+    .filter(([, p]) => p && p.deprecated === true)
+    .map(([id]) => id)
+);
 
 describe("ContextLimits", () => {
   describe("coverage - all Models.* values have a recorded context limit", () => {
@@ -19,7 +40,8 @@ describe("ContextLimits", () => {
         });
 
         for (const [key, modelId] of modelEntries) {
-          it(`${provider}.${key} (${modelId}) should have a context limit`, () => {
+          const testFn = deprecatedModelIds.has(modelId) ? it.skip : it;
+          testFn(`${provider}.${key} (${modelId}) should have a context limit`, () => {
             const limit = ContextLimits[modelId];
             expect(limit).toBeDefined();
             expect(typeof limit).toBe("number");

package/tests/clients/pricing.test.ts

@@ -150,15 +150,34 @@ describe("Model Catalog Coverage", () => {
    * Every model defined in Models.* and EmbeddingModels.* must have an entry
    * in ALL_MODEL_CATALOG. This ensures the catalog stays in sync and is the
    * single source of truth for model metadata and pricing.
+   *
+   * Exception: models flagged `deprecated` in their pricing entry are allowed to
+   * be absent from the catalog. Cost tracking for historical usage still works
+   * because calculateCost() reads the *TextPricing tables directly by model id,
+   * independently of the catalog — so deprecated models can be trimmed from the
+   * catalog/Models.* without breaking cost calculation.
    */
   const catalogIds = new Set(ALL_MODEL_CATALOG.map((m) => m.id));
 
+  // Model ids explicitly marked deprecated across all pricing tables.
+  const deprecatedModelIds = new Set<string>(
+    Object.entries({
+      ...OpenAiTextPricing,
+      ...GeminiTextPricing,
+      ...AnthropicTextPricing,
+      ...XaiTextPricing,
+    } as Record<string, { deprecated?: boolean }>)
+      .filter(([, p]) => p && p.deprecated === true)
+      .map(([id]) => id)
+  );
+
   describe("All Models.* entries are in the catalog", () => {
     for (const [provider, providerModels] of Object.entries(Models)) {
       for (const [modelKey, modelId] of Object.entries(
         providerModels as Record<string, string>
       )) {
-        it(`Models.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
+        const testFn = deprecatedModelIds.has(modelId) ? it.skip : it;
+        testFn(`Models.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
           expect(catalogIds.has(modelId)).toBe(true);
         });
       }