@ilya-lesikov/pi-pi 0.5.0 → 0.6.0

package/extensions/orchestrator/log.test.ts

@@ -0,0 +1,219 @@
+import { existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, utimesSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import { addTaskDestination, flushLogs, getLogger, initSessionLogger, removeTaskDestination, resetLogger, setLogLevel } from "./log.js";
+
+const tempDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "pi-pi-log-test-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function readText(path: string): string {
+  return existsSync(path) ? readFileSync(path, "utf-8") : "";
+}
+
+async function waitForContent(path: string, substring: string, timeoutMs = 2000): Promise<string> {
+  const deadline = Date.now() + timeoutMs;
+  let text = readText(path);
+  while (!text.includes(substring) && Date.now() < deadline) {
+    await delay(10);
+    text = readText(path);
+  }
+  return text;
+}
+
+function sessionLogPath(ppDir: string): string {
+  const logsDir = join(ppDir, "logs");
+  const entries = existsSync(logsDir)
+    ? readdirSync(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".jsonl"))
+    : [];
+  if (entries.length === 0) return "";
+  return join(logsDir, entries.sort()[entries.length - 1]);
+}
+
+afterEach(async () => {
+  flushLogs();
+  resetLogger();
+  await delay(50);
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("log", () => {
+  it("getLogger returns silent logger before init", async () => {
+    await (async () => {
+      const module = await import("./log.js");
+      expect(module.getLogger().level).toBe("silent");
+    })();
+  });
+
+  it("initSessionLogger creates session log file in .pp/logs", async () => {
+    const ppDir = makeTempDir();
+    initSessionLogger(ppDir, "info");
+    getLogger().info({ s: "test" }, "create-session-log");
+    flushLogs();
+    await delay(30);
+
+    const logPath = sessionLogPath(ppDir);
+    expect(logPath).not.toBe("");
+    expect(existsSync(logPath)).toBe(true);
+  });
+
+  it("initSessionLogger writes JSONL to session file", async () => {
+    const ppDir = makeTempDir();
+    initSessionLogger(ppDir, "debug");
+
+    getLogger().info({ s: "test" }, "touch-session-log");
+    flushLogs();
+    await delay(60);
+
+    const logPath = sessionLogPath(ppDir);
+    expect(logPath).not.toBe("");
+    expect(existsSync(logPath)).toBe(true);
+
+    getLogger().info({ s: "test" }, "hello-session");
+    flushLogs();
+    await delay(60);
+
+    expect(readText(logPath)).toContain("hello-session");
+  });
+
+  it("addTaskDestination creates debug.jsonl under .pp/logs (re-rooted from .pp/state)", async () => {
+    const cwd = makeTempDir();
+    const ppDir = join(cwd, ".pp");
+    const stateTaskDir = join(ppDir, "state", "implement", "abc_task");
+    const logsTaskDir = join(ppDir, "logs", "implement", "abc_task");
+    initSessionLogger(ppDir, "info");
+
+    addTaskDestination(stateTaskDir);
+    getLogger().info({ s: "test" }, "touch-task-log");
+    flushLogs();
+    await delay(30);
+
+    expect(existsSync(join(logsTaskDir, "debug.jsonl"))).toBe(true);
+    expect(existsSync(join(stateTaskDir, "debug.jsonl"))).toBe(false);
+  });
+
+  it("addTaskDestination logs to both session and task files", async () => {
+    const cwd = makeTempDir();
+    const ppDir = join(cwd, ".pp");
+    const stateTaskDir = join(ppDir, "state", "implement", "abc_task");
+    const logsTaskDir = join(ppDir, "logs", "implement", "abc_task");
+    initSessionLogger(ppDir, "debug");
+    const sessionPath = sessionLogPath(ppDir);
+    addTaskDestination(stateTaskDir);
+
+    getLogger().info({ s: "test" }, "both-destinations");
+    flushLogs();
+
+    expect(await waitForContent(sessionPath, "both-destinations")).toContain("both-destinations");
+    expect(await waitForContent(join(logsTaskDir, "debug.jsonl"), "both-destinations")).toContain("both-destinations");
+  });
+
+  it("removeTaskDestination stops writing to task file", async () => {
+    const cwd = makeTempDir();
+    const ppDir = join(cwd, ".pp");
+    const stateTaskDir = join(ppDir, "state", "implement", "abc_task");
+    const logsTaskDir = join(ppDir, "logs", "implement", "abc_task");
+    initSessionLogger(ppDir, "debug");
+    addTaskDestination(stateTaskDir);
+
+    getLogger().info({ s: "test" }, "before-remove");
+    flushLogs();
+    const before = await waitForContent(join(logsTaskDir, "debug.jsonl"), "before-remove");
+
+    removeTaskDestination();
+    getLogger().info({ s: "test" }, "after-remove");
+    flushLogs();
+    await delay(30);
+    const after = readText(join(logsTaskDir, "debug.jsonl"));
+
+    expect(before).toContain("before-remove");
+    expect(after).not.toContain("after-remove");
+  });
+
+  it("setLogLevel changes effective log level", async () => {
+    const ppDir = makeTempDir();
+    initSessionLogger(ppDir, "info");
+    const path = sessionLogPath(ppDir);
+
+    getLogger().debug({ s: "test" }, "debug-before");
+    getLogger().info({ s: "test" }, "info-before");
+    flushLogs();
+    const before = await waitForContent(path, "info-before");
+
+    setLogLevel("debug");
+    getLogger().debug({ s: "test" }, "debug-after");
+    flushLogs();
+    const after = await waitForContent(path, "debug-after");
+
+    expect(before).toContain("info-before");
+    expect(before).not.toContain("debug-before");
+    expect(after).toContain("debug-after");
+  });
+
+  it("setLogLevel ignores invalid levels", () => {
+    const ppDir = makeTempDir();
+    initSessionLogger(ppDir, "info");
+
+    setLogLevel("invalid" as any);
+
+    expect(getLogger().level).toBe("info");
+  });
+
+  it("cleanOldSessionLogs deletes files older than max age", () => {
+    const ppDir = makeTempDir();
+    const logsDir = join(ppDir, "logs");
+    mkdirSync(logsDir, { recursive: true });
+    const oldFile = join(logsDir, "session-old.jsonl");
+    writeFileSync(oldFile, "{}\n", "utf-8");
+    const oldTime = new Date(Date.now() - 9 * 24 * 60 * 60 * 1000);
+    utimesSync(oldFile, oldTime, oldTime);
+
+    initSessionLogger(ppDir, "info");
+
+    expect(existsSync(oldFile)).toBe(false);
+  });
+
+  it("cleanOldSessionLogs keeps recent files", () => {
+    const ppDir = makeTempDir();
+    const logsDir = join(ppDir, "logs");
+    mkdirSync(logsDir, { recursive: true });
+    const recentFile = join(logsDir, "session-recent.jsonl");
+    writeFileSync(recentFile, "{}\n", "utf-8");
+    const recentTime = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
+    utimesSync(recentFile, recentTime, recentTime);
+
+    initSessionLogger(ppDir, "info");
+
+    expect(existsSync(recentFile)).toBe(true);
+  });
+
+  it("initSessionLogger falls back to silent on unwritable path", () => {
+    const dir = makeTempDir();
+    const filePath = join(dir, "not-a-dir");
+    writeFileSync(filePath, "x", "utf-8");
+
+    initSessionLogger(filePath, "debug");
+
+    expect(getLogger().level).toBe("silent");
+  });
+
+  it("flushLogs does not crash when no streams", () => {
+    const dir = makeTempDir();
+    const filePath = join(dir, "not-a-dir");
+    writeFileSync(filePath, "x", "utf-8");
+    initSessionLogger(filePath, "info");
+
+    expect(() => flushLogs()).not.toThrow();
+  });
+});

package/extensions/orchestrator/log.ts

@@ -0,0 +1,153 @@
+import pino from "pino";
+import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
+import { join, sep } from "path";
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+const VALID_LOG_LEVELS: readonly string[] = ["debug", "info", "warn", "error"];
+
+export function isValidLogLevel(value: unknown): value is LogLevel {
+  return typeof value === "string" && VALID_LOG_LEVELS.includes(value);
+}
+
+interface MsStream {
+  id: number;
+  stream: pino.DestinationStream;
+  level: number;
+}
+
+interface Multistream extends pino.DestinationStream {
+  add(dest: { stream: pino.DestinationStream; level: string }): void;
+  remove(id: number): void;
+  flushSync(): void;
+  lastId: number;
+  streams: MsStream[];
+}
+
+let sessionStreamId = -1;
+let taskStreamId = -1;
+let taskStreamRef: pino.DestinationStream | null = null;
+let sessionStreamRef: pino.DestinationStream | null = null;
+let ms: Multistream | null = null;
+let logger: pino.Logger = pino({ level: "silent" });
+
+function safeEndStream(stream: pino.DestinationStream | null): void {
+  if (!stream) return;
+  try { (stream as any).flushSync?.(); } catch {}
+  try { (stream as any).end?.(); } catch {}
+}
+
+export function initSessionLogger(ppDir: string, level: LogLevel = "info"): void {
+  try {
+    if (ms && sessionStreamId >= 0) {
+      ms.remove(sessionStreamId);
+      safeEndStream(sessionStreamRef);
+    }
+    if (ms && taskStreamId >= 0) {
+      ms.remove(taskStreamId);
+      safeEndStream(taskStreamRef);
+      taskStreamId = -1;
+      taskStreamRef = null;
+    }
+
+    const logsDir = join(ppDir, "logs");
+    mkdirSync(logsDir, { recursive: true });
+    cleanOldSessionLogs(logsDir, 7);
+
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const logFile = join(logsDir, `session-${ts}.jsonl`);
+    sessionStreamRef = pino.destination({ dest: logFile, sync: false });
+    ms = pino.multistream([{ stream: sessionStreamRef, level }]) as unknown as Multistream;
+    sessionStreamId = ms.lastId;
+    logger = pino({ level }, ms as unknown as pino.DestinationStream);
+  } catch {
+    sessionStreamId = -1;
+    sessionStreamRef = null;
+    ms = null;
+    logger = pino({ level: "silent" });
+  }
+}
+
+export function taskLogsDir(stateTaskDir: string): string {
+  const stateSegment = `${sep}.pp${sep}state${sep}`;
+  const idx = stateTaskDir.lastIndexOf(stateSegment);
+  if (idx < 0) return stateTaskDir;
+  return stateTaskDir.slice(0, idx) + `${sep}.pp${sep}logs${sep}` + stateTaskDir.slice(idx + stateSegment.length);
+}
+
+export function addTaskDestination(stateTaskDir: string): void {
+  if (!ms) return;
+  try {
+    const logsTaskDir = taskLogsDir(stateTaskDir);
+    mkdirSync(logsTaskDir, { recursive: true });
+    const logFile = join(logsTaskDir, "debug.jsonl");
+    taskStreamRef = pino.destination({ dest: logFile, sync: false });
+    ms.add({ stream: taskStreamRef, level: logger.level });
+    taskStreamId = ms.lastId;
+  } catch {
+    taskStreamRef = null;
+    taskStreamId = -1;
+  }
+}
+
+export function removeTaskDestination(): void {
+  if (!ms || taskStreamId < 0) return;
+  ms.remove(taskStreamId);
+  safeEndStream(taskStreamRef);
+  taskStreamId = -1;
+  taskStreamRef = null;
+}
+
+export function setLogLevel(level: LogLevel): void {
+  if (!isValidLogLevel(level)) return;
+  logger.level = level;
+  if (ms && sessionStreamId >= 0 && sessionStreamRef) {
+    ms.remove(sessionStreamId);
+    ms.add({ stream: sessionStreamRef, level });
+    sessionStreamId = ms.lastId;
+  }
+  if (ms && taskStreamId >= 0 && taskStreamRef) {
+    ms.remove(taskStreamId);
+    ms.add({ stream: taskStreamRef, level });
+    taskStreamId = ms.lastId;
+  }
+}
+
+export function flushLogs(): void {
+  if (ms) {
+    try { ms.flushSync(); } catch {}
+  }
+}
+
+function cleanOldSessionLogs(logsDir: string, maxAgeDays: number): void {
+  try {
+    if (!existsSync(logsDir)) return;
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
+    for (const file of readdirSync(logsDir)) {
+      if (!file.startsWith("session-") || !file.endsWith(".jsonl")) continue;
+      const filePath = join(logsDir, file);
+      try {
+        const stat = statSync(filePath);
+        if (stat.mtimeMs < cutoff) {
+          unlinkSync(filePath);
+        }
+      } catch {}
+    }
+  } catch {}
+}
+
+export function resetLogger(): void {
+  removeTaskDestination();
+  if (ms && sessionStreamId >= 0) {
+    ms.remove(sessionStreamId);
+    safeEndStream(sessionStreamRef);
+  }
+  sessionStreamId = -1;
+  sessionStreamRef = null;
+  ms = null;
+  logger = pino({ level: "silent" });
+}
+
+export function getLogger(): pino.Logger {
+  return logger;
+}

package/extensions/orchestrator/model-registry.test.ts

@@ -0,0 +1,238 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("./log.js", () => ({
+  getLogger: () => ({
+    debug: vi.fn(),
+  }),
+}));
+
+import {
+  getAllAliases,
+  getModelFamilies,
+  getModelInfo,
+  resolveModel,
+  updateRegistryFromAvailableModels,
+} from "./model-registry.js";
+
+describe("model-registry", () => {
+  beforeEach(() => {
+    updateRegistryFromAvailableModels([]);
+  });
+
+  it("resolveModel resolves known aliases", () => {
+    expect(resolveModel("anthropic/claude-sonnet-latest")).toBe("anthropic/claude-sonnet-4-6");
+    expect(resolveModel("openai/gpt-mini-latest")).toBe("openai/gpt-5.4-mini");
+  });
+
+  it("resolveModel passes through unknown aliases", () => {
+    expect(resolveModel("custom/provider-model")).toBe("custom/provider-model");
+  });
+
+  it("resolveModel resolves flant aliases", () => {
+    expect(resolveModel("pp-flant-anthropic/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-4-6");
+    expect(resolveModel("pp-flant-openai/gemini-pro-latest")).toBe("pp-flant-openai/gemini-3.1-pro");
+  });
+
+  it("getModelInfo detects all configured families", () => {
+    expect(getModelInfo("anthropic/claude-opus-4-6")).toMatchObject({ vendor: "anthropic", family: "opus", tier: "smart" });
+    expect(getModelInfo("anthropic/claude-sonnet-4-6")).toMatchObject({ vendor: "anthropic", family: "sonnet", tier: "regular" });
+    expect(getModelInfo("anthropic/claude-haiku-3-5")).toMatchObject({ vendor: "anthropic", family: "haiku", tier: "stupid" });
+    expect(getModelInfo("openai/gpt-5.4")).toMatchObject({ vendor: "openai", family: "gpt", tier: "regular" });
+    expect(getModelInfo("openai/gpt-5.4-mini")).toMatchObject({ vendor: "openai", family: "gpt-mini", tier: "stupid" });
+    expect(getModelInfo("google/gemini-3.1-pro")).toMatchObject({ vendor: "google", family: "gemini-pro", tier: "regular" });
+    expect(getModelInfo("google/gemini-3.1-flash")).toMatchObject({ vendor: "google", family: "gemini-flash", tier: "stupid" });
+    expect(getModelInfo("deepseek/deepseek-v3")).toMatchObject({ vendor: "deepseek", family: "deepseek", tier: "regular" });
+    expect(getModelInfo("x-ai/grok-4")).toMatchObject({ vendor: "xai", family: "grok", tier: "regular" });
+    expect(getModelInfo("qwen/qwen-coder-3")).toMatchObject({ vendor: "qwen", family: "qwen", tier: "regular" });
+  });
+
+  it("getModelInfo returns unknown for unknown models", () => {
+    expect(getModelInfo("unknown/provider-model")).toEqual({
+      vendor: "unknown",
+      family: "unknown",
+      tier: "unknown",
+      displayName: "unknown/provider-model",
+    });
+  });
+
+  it("getModelInfo resolves alias before family detection", () => {
+    expect(getModelInfo("openai/gpt-latest")).toMatchObject({
+      vendor: "openai",
+      family: "gpt",
+      tier: "regular",
+    });
+  });
+
+  it("getModelInfo recognizes flant provider models", () => {
+    expect(getModelInfo("pp-flant-anthropic/claude-sonnet-4-6")).toMatchObject({
+      vendor: "anthropic",
+      family: "sonnet",
+      tier: "regular",
+    });
+    expect(getModelInfo("pp-flant-openai/gpt-5.4-mini")).toMatchObject({
+      vendor: "openai",
+      family: "gpt-mini",
+      tier: "stupid",
+    });
+    expect(getModelInfo("pp-flant-openai/gemini-3.1-pro")).toMatchObject({
+      vendor: "google",
+      family: "gemini-pro",
+      tier: "regular",
+    });
+  });
+
+  it("getModelInfo matches alternate gpt-mini naming", () => {
+    expect(getModelInfo("openai/gpt-4.1-mini")).toMatchObject({
+      vendor: "openai",
+      family: "gpt-mini",
+      tier: "stupid",
+    });
+  });
+
+  it("getModelInfo matches alternate gemini pro and flash naming", () => {
+    expect(getModelInfo("google/gemini-2.0-pro-preview")).toMatchObject({
+      vendor: "google",
+      family: "gemini-pro",
+      tier: "regular",
+    });
+    expect(getModelInfo("google/gemini-2.0-flash-exp")).toMatchObject({
+      vendor: "google",
+      family: "gemini-flash",
+      tier: "stupid",
+    });
+  });
+
+  it("getModelInfo detects flant deepseek grok and qwen models", () => {
+    expect(getModelInfo("pp-flant-openai/deepseek-v3")).toMatchObject({ vendor: "deepseek", family: "deepseek", tier: "regular" });
+    expect(getModelInfo("pp-flant-openai/grok-4")).toMatchObject({ vendor: "xai", family: "grok", tier: "regular" });
+    expect(getModelInfo("pp-flant-openai/qwen-coder-3")).toMatchObject({ vendor: "qwen", family: "qwen", tier: "regular" });
+  });
+
+  it("updateRegistryFromAvailableModels updates aliases from available models", () => {
+    updateRegistryFromAvailableModels([
+      "openai/gpt-5.6",
+      "pp-flant-openai/gpt-5.6-mini",
+      "claude-opus-4-7",
+    ]);
+
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.6");
+    expect(resolveModel("pp-flant-openai/gpt-mini-latest")).toBe("pp-flant-openai/gpt-5.6-mini");
+    expect(resolveModel("pp-flant-anthropic/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-4-7");
+  });
+
+  it("updateRegistryFromAvailableModels picks latest version", () => {
+    updateRegistryFromAvailableModels([
+      "openai/gpt-5.9",
+      "openai/gpt-5.10",
+      "openai/gpt-5.10.2",
+      "openai/gpt-5.8",
+    ]);
+
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.10.2");
+  });
+
+  it("updateRegistryFromAvailableModels normalizes bare model ids", () => {
+    updateRegistryFromAvailableModels([
+      "claude-sonnet-4-7",
+      "gpt-5-6",
+      "gemini-3-2-pro",
+    ]);
+
+    expect(resolveModel("pp-flant-anthropic/claude-sonnet-latest")).toBe("pp-flant-anthropic/claude-sonnet-4-7");
+    expect(resolveModel("pp-flant-openai/gpt-latest")).toBe("pp-flant-openai/gpt-5-6");
+    expect(resolveModel("pp-flant-openai/gemini-pro-latest")).toBe("pp-flant-openai/gemini-3-2-pro");
+  });
+
+  it("updateRegistryFromAvailableModels deduplicates repeated models", () => {
+    updateRegistryFromAvailableModels([
+      "openai/gpt-5.6",
+      "openai/gpt-5.6",
+      "openai/gpt-5.6",
+    ]);
+
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.6");
+  });
+
+  it("updateRegistryFromAvailableModels keeps defaults for missing families", () => {
+    updateRegistryFromAvailableModels(["openai/gpt-9.1"]);
+
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-9.1");
+    expect(resolveModel("anthropic/claude-opus-latest")).toBe("anthropic/claude-opus-4-6");
+  });
+
+  it("updateRegistryFromAvailableModels ignores aliases ending with -latest", () => {
+    updateRegistryFromAvailableModels([
+      "openai/gpt-5.4",
+      "openai/gpt-latest",
+      "pp-flant-anthropic/claude-opus-latest",
+    ]);
+
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.4");
+    expect(resolveModel("pp-flant-anthropic/claude-opus-latest")).toBe("pp-flant-anthropic/claude-opus-4-6");
+  });
+
+  it("updateRegistryFromAvailableModels handles empty input", () => {
+    updateRegistryFromAvailableModels(["openai/gpt-9.9"]);
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-9.9");
+
+    updateRegistryFromAvailableModels([]);
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.4");
+  });
+
+  it("updateRegistryFromAvailableModels ignores unknown bare ids", () => {
+    updateRegistryFromAvailableModels(["custom-model-1", "another-custom-model"]);
+
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.4");
+    expect(resolveModel("anthropic/claude-opus-latest")).toBe("anthropic/claude-opus-4-6");
+  });
+
+  it("updateRegistryFromAvailableModels chooses highest among flant openai versions", () => {
+    updateRegistryFromAvailableModels([
+      "pp-flant-openai/gpt-5.4",
+      "pp-flant-openai/gpt-5.6",
+      "pp-flant-openai/gpt-5.5",
+    ]);
+
+    expect(resolveModel("pp-flant-openai/gpt-latest")).toBe("pp-flant-openai/gpt-5.6");
+  });
+
+  it("getAllAliases returns a copy", () => {
+    const aliases = getAllAliases();
+    aliases["openai/gpt-latest"] = "openai/gpt-0.0";
+
+    expect(resolveModel("openai/gpt-latest")).toBe("openai/gpt-5.4");
+  });
+
+  it("getAllAliases contains known defaults", () => {
+    const aliases = getAllAliases();
+
+    expect(aliases["anthropic/claude-opus-latest"]).toBe("anthropic/claude-opus-4-6");
+    expect(aliases["pp-flant-openai/grok-latest"]).toBe("pp-flant-openai/grok-4");
+  });
+
+  it("getModelFamilies returns all family definitions", () => {
+    const families = getModelFamilies();
+    expect(families).toHaveLength(10);
+    expect(families.map((f) => f.family).sort()).toEqual([
+      "deepseek",
+      "gemini-flash",
+      "gemini-pro",
+      "gpt",
+      "gpt-mini",
+      "grok",
+      "haiku",
+      "opus",
+      "qwen",
+      "sonnet",
+    ]);
+    expect(families.find((f) => f.family === "opus")?.aliases).toContain("pp-flant-anthropic/claude-opus-latest");
+    expect(families.find((f) => f.family === "gpt")?.aliases).toContain("pp-flant-openai/gpt-latest");
+  });
+
+  it("getModelFamilies exposes vendor and tier per family", () => {
+    const families = getModelFamilies();
+
+    expect(families.find((f) => f.family === "haiku")).toMatchObject({ vendor: "anthropic", tier: "stupid" });
+    expect(families.find((f) => f.family === "gemini-pro")).toMatchObject({ vendor: "google", tier: "regular" });
+  });
+});