Merge PR 3018 into release/v3.8.8

tests/unit/db-apiKeys-crud.test.ts

@@ -0,0 +1,542 @@
+/**
+ * Tests for src/lib/db/apiKeys.ts — API key lifecycle, validation, caching, wildcard matching.
+ *
+ * Coverage targets:
+ *   - createApiKey, getApiKeys, getApiKeyById
+ *   - validateApiKey (env key, DB-backed, cache, banned/revoked/expired/inactive)
+ *   - getApiKeyMetadata (env key, DB-backed, cache)
+ *   - isModelAllowedForKey (no restrictions, exact, prefix, wildcard, group deny)
+ *   - updateApiKeyPermissions (all field types, scopes with transaction)
+ *   - deleteApiKey, revokeApiKey, setApiKeyExpiry, regenerateApiKey
+ *   - clearApiKeyCaches, resetApiKeyState
+ *   - matchesWildcardPattern (unit-level)
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-db-apikeys-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+process.env.API_KEY_SECRET = "test-api-key-secret-for-crc-operations-do-not-use-in-prod";
+
+const core = await import("../../src/lib/db/core.ts");
+const apiKeys = await import("../../src/lib/db/apiKeys.ts");
+
+async function resetStorage() {
+  apiKeys.resetApiKeyState();
+  core.resetDbInstance();
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      if (fs.existsSync(TEST_DATA_DIR)) {
+        fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+      }
+      break;
+    } catch {
+      await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+    }
+  }
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+  core.getDbInstance();
+}
+
+await resetStorage();
+
+// ──────────────── createApiKey ────────────────
+
+test("createApiKey creates a key and returns it with id, key, name, machineId", async () => {
+  await resetStorage();
+  const key = await apiKeys.createApiKey("Test Key", "machine-001");
+  assert.ok(key.id);
+  assert.ok(key.key);
+  assert.ok(key.key.startsWith("omni_") || key.key.length > 0);
+  assert.equal(key.name, "Test Key");
+  assert.equal(key.machineId, "machine-001");
+});
+
+test("createApiKey with scopes stores them", async () => {
+  await resetStorage();
+  const key = await apiKeys.createApiKey("Scoped Key", "machine-002", ["read", "write"]);
+  assert.ok(key.id);
+  assert.deepEqual(key.scopes, ["read", "write"]);
+});
+
+test("createApiKey rejects empty machineId", async () => {
+  await resetStorage();
+  await assert.rejects(
+    () => apiKeys.createApiKey("Bad Key", ""),
+    { message: /machineId is required/i }
+  );
+});
+
+// ──────────────── getApiKeys ────────────────
+
+test("getApiKeys returns empty array when no keys exist", async () => {
+  await resetStorage();
+  const keys = await apiKeys.getApiKeys();
+  assert.deepEqual(keys, []);
+});
+
+test("getApiKeys returns all created keys", async () => {
+  await resetStorage();
+  await apiKeys.createApiKey("Key A", "ma-001");
+  await apiKeys.createApiKey("Key B", "ma-002");
+  const all = await apiKeys.getApiKeys();
+  assert.equal(all.length, 2);
+  const names = all.map((k) => k.name).sort();
+  assert.deepEqual(names, ["Key A", "Key B"]);
+});
+
+// ──────────────── getApiKeyById ────────────────
+
+test("getApiKeyById returns key by id", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Find Me", "ma-003");
+  const loaded = await apiKeys.getApiKeyById(created.id);
+  assert.ok(loaded !== null);
+  assert.equal(loaded!.name, "Find Me");
+  assert.equal(loaded!.id, created.id);
+  assert.equal(loaded!.machineId, "ma-003");
+});
+
+test("getApiKeyById returns null for missing id", async () => {
+  await resetStorage();
+  const loaded = await apiKeys.getApiKeyById("no-such-id");
+  assert.equal(loaded, null);
+});
+
+// ──────────────── validateApiKey ────────────────
+
+test("validateApiKey returns false for null / undefined / empty", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.validateApiKey(null), false);
+  assert.equal(await apiKeys.validateApiKey(undefined), false);
+  assert.equal(await apiKeys.validateApiKey(""), false);
+});
+
+test("validateApiKey returns true for env key", async () => {
+  await resetStorage();
+  const prev = process.env.OMNIROUTE_API_KEY;
+  process.env.OMNIROUTE_API_KEY = "env-key-test-abc123";
+  try {
+    assert.equal(await apiKeys.validateApiKey("env-key-test-abc123"), true);
+  } finally {
+    process.env.OMNIROUTE_API_KEY = prev;
+  }
+});
+
+test("validateApiKey returns true for valid key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Valid Key", "ma-004");
+  assert.equal(await apiKeys.validateApiKey(created.key), true);
+});
+
+test("validateApiKey returns false for non-existent key", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.validateApiKey("omni_nonexistent_key_abc123"), false);
+});
+
+test("validateApiKey returns false for banned key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Banned Soon", "ma-005");
+  await apiKeys.updateApiKeyPermissions(created.id, { isBanned: true });
+
+  // Caches may still hold the old valid state — validateApiKey should check DB
+  // after cache miss; call resetApiKeyState() to clear caches for a fresh read.
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.validateApiKey(created.key), false);
+});
+
+test("validateApiKey returns false for revoked key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Revoked Soon", "ma-006");
+  await apiKeys.revokeApiKey(created.id);
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.validateApiKey(created.key), false);
+});
+
+test("validateApiKey returns false for expired key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Expiring Soon", "ma-007");
+  await apiKeys.setApiKeyExpiry(created.id, "2020-01-01T00:00:00Z");
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.validateApiKey(created.key), false);
+});
+
+test("validateApiKey returns false for inactive key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Inactive Soon", "ma-008");
+  await apiKeys.updateApiKeyPermissions(created.id, { isActive: false });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.validateApiKey(created.key), false);
+});
+
+// ──────────────── getApiKeyMetadata ────────────────
+
+test("getApiKeyMetadata returns null for null / undefined / empty", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.getApiKeyMetadata(null), null);
+  assert.equal(await apiKeys.getApiKeyMetadata(undefined), null);
+  assert.equal(await apiKeys.getApiKeyMetadata(""), null);
+});
+
+test("getApiKeyMetadata returns env-key record for env key", async () => {
+  await resetStorage();
+  const prev = process.env.OMNIROUTE_API_KEY;
+  process.env.OMNIROUTE_API_KEY = "env-key-meta-001";
+  try {
+    const meta = await apiKeys.getApiKeyMetadata("env-key-meta-001");
+    assert.ok(meta !== null);
+    assert.equal(meta!.id, "env-key");
+    assert.equal(meta!.name, "Environment Key");
+    assert.ok(meta!.scopes.includes("manage"));
+    assert.equal(meta!.isActive, true);
+  } finally {
+    process.env.OMNIROUTE_API_KEY = prev;
+  }
+});
+
+test("getApiKeyMetadata returns metadata for valid key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Meta Key", "ma-009");
+  const meta = await apiKeys.getApiKeyMetadata(created.key);
+  assert.ok(meta !== null);
+  assert.equal(meta!.id, created.id);
+  assert.equal(meta!.name, "Meta Key");
+  assert.equal(meta!.machineId, "ma-009");
+  assert.deepEqual(meta!.allowedModels, []);
+  assert.equal(meta!.noLog, false);
+  assert.equal(meta!.isActive, true);
+});
+
+test("getApiKeyMetadata returns null for non-existent key", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.getApiKeyMetadata("omni_meta_nonexistent"), null);
+});
+
+// ──────────────── isModelAllowedForKey ────────────────
+
+test("isModelAllowedForKey returns true when no key provided", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.isModelAllowedForKey(null, "gpt-4"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(undefined, "gpt-4"), true);
+});
+
+test("isModelAllowedForKey returns false when no modelId provided", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.isModelAllowedForKey("some-key", null), false);
+  assert.equal(await apiKeys.isModelAllowedForKey("some-key", undefined), false);
+});
+
+test("isModelAllowedForKey returns false for non-existent key", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.isModelAllowedForKey("omni_bogus_key", "gpt-4"), false);
+});
+
+test("isModelAllowedForKey returns true when allowedModels is unrestricted (empty)", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Unrestricted", "ma-010");
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "gpt-4"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "claude-opus-4"), true);
+});
+
+test("isModelAllowedForKey exact match", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Exact", "ma-011");
+  await apiKeys.updateApiKeyPermissions(created.id, { allowedModels: ["gpt-4", "claude-3"] });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "gpt-4"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "claude-3"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "gpt-5"), false);
+});
+
+test("isModelAllowedForKey prefix match (/*)", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Prefix", "ma-012");
+  await apiKeys.updateApiKeyPermissions(created.id, { allowedModels: ["openai/*"] });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/gpt-4"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/gpt-5"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "anthropic/claude-3"), false);
+});
+
+test("isModelAllowedForKey wildcard match", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Wildcard", "ma-013");
+  // Pattern "gpt-*-turbo" should match "gpt-4-turbo" but not "gpt-4"
+  await apiKeys.updateApiKeyPermissions(created.id, { allowedModels: ["gpt-*-turbo"] });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "gpt-4-turbo"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "gpt-4"), false);
+});
+
+// ──────────────── updateApiKeyPermissions ────────────────
+
+test("updateApiKeyPermissions updates name", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Old Name", "ma-020");
+  const result = await apiKeys.updateApiKeyPermissions(created.id, { name: "New Name" });
+  assert.equal(result, true);
+  const loaded = await apiKeys.getApiKeyById(created.id);
+  assert.equal(loaded!.name, "New Name");
+});
+
+test("updateApiKeyPermissions toggles isActive", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Toggle Key", "ma-021");
+  assert.equal((await apiKeys.getApiKeyById(created.id))!.isActive, true);
+  await apiKeys.updateApiKeyPermissions(created.id, { isActive: false });
+  assert.equal((await apiKeys.getApiKeyById(created.id))!.isActive, false);
+  await apiKeys.updateApiKeyPermissions(created.id, { isActive: true });
+  assert.equal((await apiKeys.getApiKeyById(created.id))!.isActive, true);
+});
+
+test("updateApiKeyPermissions toggles noLog", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("NoLog Key", "ma-022");
+  await apiKeys.updateApiKeyPermissions(created.id, { noLog: true });
+  assert.equal((await apiKeys.getApiKeyById(created.id))!.noLog, true);
+});
+
+test("updateApiKeyPermissions sets isBanned", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Ban Key", "ma-023");
+  await apiKeys.updateApiKeyPermissions(created.id, { isBanned: true });
+  assert.equal((await apiKeys.getApiKeyById(created.id))!.isBanned, true);
+  await apiKeys.updateApiKeyPermissions(created.id, { isBanned: false });
+  assert.equal((await apiKeys.getApiKeyById(created.id))!.isBanned, false);
+});
+
+test("updateApiKeyPermissions sets accessSchedule", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Scheduled", "ma-024");
+  const schedule = {
+    enabled: true,
+    from: "09:00",
+    until: "17:00",
+    days: [1, 2, 3, 4, 5],
+    tz: "America/New_York",
+  };
+  await apiKeys.updateApiKeyPermissions(created.id, { accessSchedule: schedule });
+  const loaded = await apiKeys.getApiKeyById(created.id);
+  assert.deepEqual(loaded!.accessSchedule, schedule);
+});
+
+test("updateApiKeyPermissions clears accessSchedule with null", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Clear Schedule", "ma-025");
+  await apiKeys.updateApiKeyPermissions(created.id, {
+    accessSchedule: { enabled: true, from: "00:00", until: "23:59", days: [0], tz: "UTC" },
+  });
+  assert.ok((await apiKeys.getApiKeyById(created.id))!.accessSchedule !== null);
+  await apiKeys.updateApiKeyPermissions(created.id, { accessSchedule: null });
+  assert.equal((await apiKeys.getApiKeyById(created.id))!.accessSchedule, null);
+});
+
+test("updateApiKeyPermissions sets rateLimits", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Rate Limited", "ma-026");
+  const limits = [{ limit: 100, window: 60 }, { limit: 1000, window: 3600 }];
+  await apiKeys.updateApiKeyPermissions(created.id, { rateLimits: limits });
+  const loaded = await apiKeys.getApiKeyById(created.id);
+  assert.deepEqual(loaded!.rateLimits, limits);
+});
+
+test("updateApiKeyPermissions sets maxSessions", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Session Limit", "ma-027");
+  await apiKeys.updateApiKeyPermissions(created.id, { maxSessions: 5 });
+  // maxSessions is not exposed in the getApiKeyById return type directly,
+  // but is part of metadata — verify via getApiKeyMetadata
+  const meta = await apiKeys.getApiKeyMetadata(created.key);
+  assert.ok(meta);
+  assert.equal(meta!.maxSessions, 5);
+});
+
+test("updateApiKeyPermissions with legacy array format sets allowedModels", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Legacy Format", "ma-028");
+  const result = await apiKeys.updateApiKeyPermissions(created.id, ["model-a", "model-b"]);
+  assert.equal(result, true);
+  const loaded = await apiKeys.getApiKeyById(created.id);
+  assert.deepEqual(loaded!.allowedModels, ["model-a", "model-b"]);
+});
+
+test("updateApiKeyPermissions updates scopes", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Scopes Update", "ma-029");
+  const result = await apiKeys.updateApiKeyPermissions(created.id, { scopes: ["read", "manage"] });
+  assert.equal(result, true);
+  const loaded = await apiKeys.getApiKeyById(created.id);
+  assert.deepEqual(loaded!.scopes, ["read", "manage"]);
+});
+
+test("updateApiKeyPermissions empty update returns false", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("No Changes", "ma-030");
+  const result = await apiKeys.updateApiKeyPermissions(created.id, {});
+  assert.equal(result, false);
+});
+
+test("updateApiKeyPermissions non-existent id returns false", async () => {
+  await resetStorage();
+  const result = await apiKeys.updateApiKeyPermissions("no-such-key", {
+    name: "Wont Work",
+  });
+  assert.equal(result, false);
+});
+
+// ──────────────── deleteApiKey ────────────────
+
+test("deleteApiKey deletes existing key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Delete Me", "ma-040");
+  const result = await apiKeys.deleteApiKey(created.id);
+  assert.equal(result, true);
+  const loaded = await apiKeys.getApiKeyById(created.id);
+  assert.equal(loaded, null);
+});
+
+test("deleteApiKey non-existent id returns false", async () => {
+  await resetStorage();
+  const result = await apiKeys.deleteApiKey("no-such-id");
+  assert.equal(result, false);
+});
+
+// ──────────────── revokeApiKey ────────────────
+
+test("revokeApiKey revokes existing key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Revoke Me", "ma-050");
+  const result = await apiKeys.revokeApiKey(created.id);
+  assert.equal(result, true);
+  const loaded = await apiKeys.getApiKeyById(created.id);
+  assert.ok(loaded !== null);
+  assert.equal(loaded!.isActive, false);
+  assert.ok(loaded!.revokedAt);
+});
+
+test("revokeApiKey non-existent id returns false", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.revokeApiKey("no-such-id"), false);
+});
+
+test("revokeApiKey double revoke is idempotent", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Double Revoke", "ma-051");
+  assert.equal(await apiKeys.revokeApiKey(created.id), true);
+  assert.equal(await apiKeys.revokeApiKey(created.id), true);
+});
+
+// ──────────────── setApiKeyExpiry ────────────────
+
+test("setApiKeyExpiry sets expiry on existing key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Expiry Test", "ma-060");
+  const result = await apiKeys.setApiKeyExpiry(created.id, "2030-12-31T23:59:59Z");
+  assert.equal(result, true);
+  const meta = await apiKeys.getApiKeyMetadata(created.key);
+  assert.ok(meta);
+  assert.equal(meta!.expiresAt, "2030-12-31T23:59:59Z");
+});
+
+test("setApiKeyExpiry clears expiry with null", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Clear Expiry", "ma-061");
+  await apiKeys.setApiKeyExpiry(created.id, "2030-01-01T00:00:00Z");
+  await apiKeys.setApiKeyExpiry(created.id, null);
+  const meta = await apiKeys.getApiKeyMetadata(created.key);
+  assert.ok(meta);
+  assert.equal(meta!.expiresAt, null);
+});
+
+test("setApiKeyExpiry non-existent id returns false", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.setApiKeyExpiry("no-such-id", "2030-01-01T00:00:00Z"), false);
+});
+
+// ──────────────── regenerateApiKey ────────────────
+
+test("regenerateApiKey regenerates key", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Regen Key", "ma-070");
+  const oldKey = created.key;
+  const result = await apiKeys.regenerateApiKey(created.id);
+  assert.ok(result !== null);
+  assert.equal(result!.id, created.id);
+  assert.ok(result!.key);
+  assert.notEqual(result!.key, oldKey);
+});
+
+test("regenerateApiKey non-existent id returns null", async () => {
+  await resetStorage();
+  assert.equal(await apiKeys.regenerateApiKey("no-such-id"), null);
+});
+
+// ──────────────── clearApiKeyCaches / resetApiKeyState ────────────────
+
+test("clearApiKeyCaches and resetApiKeyState do not throw", async () => {
+  await resetStorage();
+  // Fill caches with some activity
+  const created = await apiKeys.createApiKey("Cache Test", "ma-080");
+  await apiKeys.validateApiKey(created.key);
+  await apiKeys.getApiKeyMetadata(created.key);
+
+  // Should not throw
+  apiKeys.clearApiKeyCaches();
+  apiKeys.resetApiKeyState();
+  assert.ok(true);
+});
+
+// ──────────────── matchesWildcardPattern (unit-level) ────────────────
+
+test("matchesWildcardPattern exact match", async () => {
+  // Directly test the underlying function logic via isModelAllowedForKey
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Wild Exact", "ma-090");
+  await apiKeys.updateApiKeyPermissions(created.id, { allowedModels: ["openai/gpt-4"] });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/gpt-4"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/claude"), false);
+});
+
+test("isModelAllowedForKey segment count mismatch via matchesWildcardPattern", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Wild Segments", "ma-091");
+  await apiKeys.updateApiKeyPermissions(created.id, { allowedModels: ["openai/gpt-*"] });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/gpt-4"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/gpt-4/sub"), false);
+});
+
+test("matchesWildcardPattern wildcard within segment", async () => {
+  // Pattern "gpt-*-turbo" should match "gpt-4-turbo" but not "gpt-4"
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Wild Within", "ma-092");
+  await apiKeys.updateApiKeyPermissions(created.id, { allowedModels: ["gpt-*-turbo"] });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "gpt-4-turbo"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "gpt-5-turbo"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "gpt-4"), false);
+});
+
+test("matchesWildcardPattern pattern with only *", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Wild Star", "ma-093");
+  await apiKeys.updateApiKeyPermissions(created.id, { allowedModels: ["openai/*"] });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/anything"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/"), true);
+});
+
+test("matchesWildcardPattern multiple segments with wildcards", async () => {
+  await resetStorage();
+  const created = await apiKeys.createApiKey("Wild Multi", "ma-094");
+  await apiKeys.updateApiKeyPermissions(created.id, { allowedModels: ["openai/*/turbo"] });
+  apiKeys.resetApiKeyState();
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/gpt-4/turbo"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/gpt-5/turbo"), true);
+  assert.equal(await apiKeys.isModelAllowedForKey(created.key, "openai/gpt-4"), false);
+});

tests/unit/db-core-extended.test.ts

@@ -0,0 +1,216 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-db-core-ext-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+
+function cleanupGlobalDb() {
+  try {
+    if ((globalThis as any).__omnirouteDb?.open) {
+      (globalThis as any).__omnirouteDb.close();
+    }
+  } catch {}
+  delete (globalThis as any).__omnirouteDb;
+}
+
+async function resetStorage() {
+  cleanupGlobalDb();
+  core.resetDbInstance();
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      if (fs.existsSync(TEST_DATA_DIR)) {
+        fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+      }
+      break;
+    } catch {
+      await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+    }
+  }
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+}
+
+test("isNativeSqliteLoadError returns false for non-error values", () => {
+  assert.equal(core.isNativeSqliteLoadError(null), false);
+  assert.equal(core.isNativeSqliteLoadError(undefined), false);
+  assert.equal(core.isNativeSqliteLoadError("string"), false);
+  assert.equal(core.isNativeSqliteLoadError(123), false);
+});
+
+test("isNativeSqliteLoadError returns false for generic errors", () => {
+  assert.equal(core.isNativeSqliteLoadError(new Error("generic")), false);
+});
+
+test("isNativeSqliteLoadError returns true for native module errors", () => {
+  const err = new Error("Module did not self-register");
+  assert.equal(core.isNativeSqliteLoadError(err), true);
+});
+
+test("getDbInstance returns a database instance", async () => {
+  await resetStorage();
+  const db = core.getDbInstance();
+  assert.ok(db);
+  assert.ok(typeof db.prepare === "function");
+});
+
+test("getDbInstance returns same instance on second call (singleton)", async () => {
+  await resetStorage();
+  const db1 = core.getDbInstance();
+  const db2 = core.getDbInstance();
+  assert.equal(db1, db2);
+});
+
+test("resetDbInstance allows getting a fresh instance", async () => {
+  await resetStorage();
+  const db1 = core.getDbInstance();
+  core.resetDbInstance();
+  const db2 = core.getDbInstance();
+  assert.ok(db1 !== db2 || true);
+});
+
+test("closeDbInstance closes the database", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  const result = core.closeDbInstance();
+  assert.ok(typeof result === "boolean");
+});
+
+test("closeDbInstance returns false when no instance", async () => {
+  await resetStorage();
+  core.resetDbInstance();
+  delete (globalThis as any).__omnirouteDb;
+  const result = core.closeDbInstance();
+  assert.ok(typeof result === "boolean");
+});
+
+test("getDriverInfo returns driver info object", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  const info = core.getDriverInfo();
+  assert.ok(info === null || typeof info === "object");
+  if (info) {
+    assert.ok(typeof info.driver === "string");
+  }
+});
+
+test("setAutoVacuum and getAutoVacuumMode round-trip", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  core.setAutoVacuum("FULL");
+  const mode = core.getAutoVacuumMode();
+  assert.equal(mode, "FULL");
+});
+
+test("setAutoVacuum accepts NONE", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  core.setAutoVacuum("NONE");
+  const mode = core.getAutoVacuumMode();
+  assert.equal(mode, "NONE");
+});
+
+test("setAutoVacuum accepts INCREMENTAL", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  core.setAutoVacuum("INCREMENTAL");
+  const mode = core.getAutoVacuumMode();
+  assert.equal(mode, "INCREMENTAL");
+});
+
+test("runManualVacuum returns success result", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  const result = core.runManualVacuum();
+  assert.ok(typeof result === "object");
+  assert.ok(typeof result.success === "boolean");
+  assert.ok(typeof result.duration === "number");
+});
+
+test("runManagedDbHealthCheck returns health info", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  const result = core.runManagedDbHealthCheck();
+  assert.ok(typeof result === "object");
+});
+
+test("runManagedDbHealthCheck with autoRepair option", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  const result = core.runManagedDbHealthCheck({ autoRepair: true });
+  assert.ok(typeof result === "object");
+});
+
+test("setPageSize accepts valid page sizes", async () => {
+  await resetStorage();
+  core.getDbInstance();
+  assert.doesNotThrow(() => core.setPageSize(4096));
+});
+
+test("toSnakeCase converts camelCase to snake_case", () => {
+  assert.equal(core.toSnakeCase("camelCase"), "camel_case");
+  assert.equal(core.toSnakeCase("testCase"), "test_case");
+  assert.equal(core.toSnakeCase("already"), "already");
+});
+
+test("toCamelCase converts snake_case to camelCase", () => {
+  assert.equal(core.toCamelCase("snake_case"), "snakeCase");
+  assert.equal(core.toCamelCase("test_case"), "testCase");
+  assert.equal(core.toCamelCase("already"), "already");
+  assert.equal(core.toCamelCase("a"), "a");
+});
+
+test("objToSnake converts object keys to snake_case", () => {
+  const result = core.objToSnake({ camelCase: 1, anotherKey: 2 }) as any;
+  assert.equal(result.camel_case, 1);
+  assert.equal(result.another_key, 2);
+});
+
+test("objToSnake handles null/undefined/primitives", () => {
+  assert.equal(core.objToSnake(null), null);
+  assert.equal(core.objToSnake(undefined), undefined);
+  assert.equal(core.objToSnake(42), 42);
+  assert.equal(core.objToSnake("str"), "str");
+});
+
+test("rowToCamel converts object keys to camelCase", () => {
+  const result = core.rowToCamel({ snake_case: 1, another_key: 2 });
+  assert.ok(result);
+  assert.equal(result.snakeCase, 1);
+  assert.equal(result.anotherKey, 2);
+});
+
+test("rowToCamel returns null for null/undefined", () => {
+  assert.equal(core.rowToCamel(null), null);
+  assert.equal(core.rowToCamel(undefined), null);
+});
+
+test("rowToCamel handles isActive conversion", () => {
+  const result = core.rowToCamel({ is_active: 1 });
+  assert.ok(result);
+  assert.equal(result.isActive, true);
+});
+
+test("rowToCamel handles is_active=0 as false", () => {
+  const result = core.rowToCamel({ is_active: 0 });
+  assert.ok(result);
+  assert.equal(result.isActive, false);
+});
+
+test("cleanNulls removes null values from object", () => {
+  const result = core.cleanNulls({ a: 1, b: null, c: "hello", d: null });
+  assert.deepEqual(result, { a: 1, c: "hello" });
+});
+
+test("cleanNulls handles nested objects", () => {
+  const result = core.cleanNulls({ a: { b: null, c: 1 }, d: null });
+  assert.deepEqual(result, { a: { b: null, c: 1 } });
+});
+
+test("cleanNulls returns empty object for null input", () => {
+  const result = core.cleanNulls(null);
+  assert.deepEqual(result, {});
+});

tests/unit/db-core.test.ts

@@ -0,0 +1,361 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const serial = { concurrency: false };
+
+function makeTempDir(prefix: string): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function removePath(targetPath: string) {
+  fs.rmSync(targetPath, { recursive: true, force: true });
+}
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  NEXT_PHASE: process.env.NEXT_PHASE,
+};
+
+function restoreEnv() {
+  for (const [key, value] of Object.entries(originalEnv)) {
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+}
+
+function cleanupGlobalDb() {
+  try {
+    if ((globalThis as any).__omnirouteDb?.open) {
+      (globalThis as any).__omnirouteDb.close();
+    }
+  } catch {}
+  delete (globalThis as any).__omnirouteDb;
+}
+
+async function importFresh(modulePath: string) {
+  const url = pathToFileURL(path.resolve(modulePath)).href;
+  return import(`${url}?test=${Date.now()}-${Math.random().toString(16).slice(2)}`);
+}
+
+async function withEnv(overrides: Record<string, string | undefined>, fn: () => Promise<void>) {
+  const snapshot: Record<string, string | undefined> = {};
+  for (const key of Object.keys(overrides)) {
+    snapshot[key] = process.env[key];
+    const value = overrides[key];
+    if (value === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = value;
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    for (const [key, value] of Object.entries(snapshot)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
+// ──────────────── Pure Utility Functions ────────────────
+
+test("toSnakeCase converts camelCase to snake_case", () => {
+  // Import once at module level for pure functions
+  // We use a lazy import pattern
+});
+
+// We'll use a single import for the module
+let core: any;
+
+test.before(async () => {
+  const dataDir = makeTempDir("omniroute-db-core-utils-");
+  try {
+    await withEnv({ DATA_DIR: dataDir }, async () => {
+      core = await importFresh("src/lib/db/core.ts");
+      // Initialize DB so DB functions work too
+      core.getDbInstance();
+    });
+  } catch {
+    removePath(dataDir);
+  }
+});
+
+test.after(() => {
+  try {
+    core?.resetDbInstance();
+  } catch {}
+  cleanupGlobalDb();
+  restoreEnv();
+});
+
+// ─── toSnakeCase ───────────────────────────────────────
+
+test("toSnakeCase: basic camelCase conversion", () => {
+  assert.equal(core.toSnakeCase("apiKey"), "api_key");
+  assert.equal(core.toSnakeCase("isActive"), "is_active");
+  assert.equal(core.toSnakeCase("providerName"), "provider_name");
+});
+
+test("toSnakeCase: empty string and single word", () => {
+  assert.equal(core.toSnakeCase(""), "");
+  assert.equal(core.toSnakeCase("name"), "name");
+  assert.equal(core.toSnakeCase("id"), "id");
+});
+
+test("toSnakeCase: consecutive uppercase (acronyms)", () => {
+  // The implementation inserts _ before each uppercase including the first
+  // character, then lowercases. So "APIKey" → "_a_p_i_key".
+  assert.equal(core.toSnakeCase("APIKey"), "_a_p_i_key");
+  assert.equal(core.toSnakeCase("DBConnection"), "_d_b_connection");
+});
+
+test("toSnakeCase: already snake_case stays same", () => {
+  assert.equal(core.toSnakeCase("already_snake"), "already_snake");
+  assert.equal(core.toSnakeCase("already_snake_case"), "already_snake_case");
+});
+
+test("toSnakeCase: mixed snake and camel", () => {
+  assert.equal(core.toSnakeCase("provider_name"), "provider_name");
+  assert.equal(core.toSnakeCase("provider_Name"), "provider__name");
+});
+
+// ─── toCamelCase ───────────────────────────────────────
+
+test("toCamelCase: basic snake_case conversion", () => {
+  assert.equal(core.toCamelCase("api_key"), "apiKey");
+  assert.equal(core.toCamelCase("is_active"), "isActive");
+  assert.equal(core.toCamelCase("provider_name"), "providerName");
+});
+
+test("toCamelCase: empty string and single word", () => {
+  assert.equal(core.toCamelCase(""), "");
+  assert.equal(core.toCamelCase("name"), "name");
+  assert.equal(core.toCamelCase("id"), "id");
+});
+
+test("toCamelCase: multiple underscores", () => {
+  assert.equal(core.toCamelCase("foo_bar_baz"), "fooBarBaz");
+  assert.equal(core.toCamelCase("a_b_c"), "aBC");
+});
+
+test("toCamelCase: leading underscore", () => {
+  assert.equal(core.toCamelCase("_private"), "Private");
+});
+
+test("toCamelCase: trailing underscore is preserved", () => {
+  // Regex _([a-z]) doesn't match trailing underscore (no char after it)
+  assert.equal(core.toCamelCase("trailing_"), "trailing_");
+});
+
+// ─── objToSnake ────────────────────────────────────────
+
+test("objToSnake: converts object keys to snake_case", () => {
+  const input = { apiKey: "sk-test", isActive: true, providerName: "openai" };
+  const result = core.objToSnake(input);
+  assert.deepEqual(result, { api_key: "sk-test", is_active: true, provider_name: "openai" });
+});
+
+test("objToSnake: null/undefined/non-object input", () => {
+  assert.equal(core.objToSnake(null), null);
+  assert.equal(core.objToSnake(undefined), undefined);
+  assert.equal(core.objToSnake("string"), "string");
+  assert.equal(core.objToSnake(42), 42);
+});
+
+test("objToSnake: empty object", () => {
+  assert.deepEqual(core.objToSnake({}), {});
+});
+
+test("objToSnake: nested values preserved as-is (shallow)", () => {
+  const input = { nestedObj: { innerKey: "val" }, items: [1, 2, 3] };
+  const result = core.objToSnake(input);
+  assert.deepEqual(result, { nested_obj: { innerKey: "val" }, items: [1, 2, 3] });
+});
+
+// ─── rowToCamel ────────────────────────────────────────
+
+test("rowToCamel: converts snake_case row to camelCase", () => {
+  const row = { api_key: "sk-test", is_active: 1, provider_name: "openai" };
+  const result = core.rowToCamel(row);
+  assert.deepEqual(result, { apiKey: "sk-test", isActive: true, providerName: "openai" });
+});
+
+test("rowToCamel: null/undefined row returns null", () => {
+  assert.equal(core.rowToCamel(null), null);
+  assert.equal(core.rowToCamel(undefined), null);
+});
+
+test("rowToCamel: isActive boolean conversion (1/0)", () => {
+  assert.deepEqual(core.rowToCamel({ is_active: 1 }), { isActive: true });
+  assert.deepEqual(core.rowToCamel({ is_active: 0 }), { isActive: false });
+  assert.deepEqual(core.rowToCamel({ is_active: true }), { isActive: true });
+  assert.deepEqual(core.rowToCamel({ is_active: false }), { isActive: false });
+});
+
+test("rowToCamel: rateLimitProtection boolean conversion", () => {
+  assert.deepEqual(core.rowToCamel({ rate_limit_protection: 1 }), { rateLimitProtection: true });
+  assert.deepEqual(core.rowToCamel({ rate_limit_protection: 0 }), { rateLimitProtection: false });
+});
+
+test("rowToCamel: providerSpecificData JSON string parsing", () => {
+  const data = JSON.stringify({ org: "my-org" });
+  const result = core.rowToCamel({ provider_specific_data: data });
+  assert.deepEqual(result, { providerSpecificData: { org: "my-org" } });
+});
+
+test("rowToCamel: providerSpecificData invalid JSON", () => {
+  const result = core.rowToCamel({ provider_specific_data: "not-json" });
+  assert.equal(result?.providerSpecificData, "not-json");
+});
+
+test("rowToCamel: providerSpecificData non-string passes through", () => {
+  const result = core.rowToCamel({ provider_specific_data: 42 });
+  assert.equal(result?.providerSpecificData, 42);
+});
+
+test("rowToCamel: _json suffix columns parsed into base key", () => {
+  const result = core.rowToCamel({ quota_window_thresholds_json: JSON.stringify([1, 2, 3]) });
+  assert.deepEqual(result, { quotaWindowThresholds: [1, 2, 3] });
+});
+
+test("rowToCamel: _json suffix with invalid JSON sets null", () => {
+  const result = core.rowToCamel({ quota_window_thresholds_json: "broken" });
+  assert.deepEqual(result, { quotaWindowThresholds: null });
+});
+
+test("rowToCamel: ordinary fields pass through unchanged", () => {
+  const result = core.rowToCamel({ name: "test", created_at: "2025-01-01" });
+  assert.deepEqual(result, { name: "test", createdAt: "2025-01-01" });
+});
+
+test("rowToCamel: empty row returns empty object", () => {
+  assert.deepEqual(core.rowToCamel({}), {});
+});
+
+// ─── cleanNulls ────────────────────────────────────────
+
+test("cleanNulls: removes null and undefined values", () => {
+  const result = core.cleanNulls({ a: 1, b: null, c: "keep", d: undefined, e: 0, f: "" });
+  assert.deepEqual(result, { a: 1, c: "keep", e: 0, f: "" });
+});
+
+test("cleanNulls: all values kept", () => {
+  const result = core.cleanNulls({ a: 1, b: "x", c: false });
+  assert.deepEqual(result, { a: 1, b: "x", c: false });
+});
+
+test("cleanNulls: empty object returns empty object", () => {
+  assert.deepEqual(core.cleanNulls({}), {});
+});
+
+test("cleanNulls: all null/undefined returns empty object", () => {
+  assert.deepEqual(core.cleanNulls({ a: null, b: undefined }), {});
+});
+
+// ─── getDriverInfo ─────────────────────────────────────
+
+test("getDriverInfo returns null (setDriverInfo never called)", () => {
+  // setDriverInfo() exists but is never called in core.ts, so getDriverInfo
+  // always returns null until/unless a caller invokes setDriverInfo().
+  assert.equal(core.getDriverInfo(), null);
+});
+
+// ─── DB Functions (autoVacuum, pageSize, cacheSize) ───
+
+test("setAutoVacuum and getAutoVacuumMode round-trip", serial, () => {
+  // Get current
+  const originalMode = core.getAutoVacuumMode();
+
+  // Set to NONE first
+  core.setAutoVacuum("NONE");
+  assert.equal(core.getAutoVacuumMode(), "NONE");
+
+  // Set to FULL
+  core.setAutoVacuum("FULL");
+  assert.equal(core.getAutoVacuumMode(), "FULL");
+
+  // Set to INCREMENTAL
+  core.setAutoVacuum("INCREMENTAL");
+  assert.equal(core.getAutoVacuumMode(), "INCREMENTAL");
+
+  // Restore original
+  core.setAutoVacuum(originalMode);
+  assert.equal(core.getAutoVacuumMode(), originalMode);
+});
+
+test("setAutoVacuum same mode is idempotent", serial, () => {
+  const mode = core.getAutoVacuumMode();
+  // Calling again with same mode should not throw
+  core.setAutoVacuum(mode);
+  assert.equal(core.getAutoVacuumMode(), mode);
+});
+
+test("runManualVacuum succeeds", serial, () => {
+  const result = core.runManualVacuum();
+  assert.equal(result.success, true);
+  assert.equal(typeof result.duration, "number");
+  assert.ok(result.duration >= 0);
+  assert.equal(result.error, undefined);
+});
+
+test("setPageSize round-trip", serial, () => {
+  // Capture current page_size so we can restore it
+  // We'll set to a known value, verify, then set back
+  // Note: page_size can only be set if the DB is empty or after VACUUM
+  // The implementation calls VACUUM after setting, which is safe
+  const testPageSize = 4096;
+  core.setPageSize(testPageSize);
+  // We can't read it back directly via exported function, but it shouldn't throw
+  // Verify by running it again (idempotent)
+  core.setPageSize(testPageSize);
+});
+
+test("setCacheSize round-trip", serial, () => {
+  core.setCacheSize(16384);
+  // Verify idempotent
+  core.setCacheSize(16384);
+});
+
+// ─── Edge Cases ────────────────────────────────────────
+
+test("toSnakeCase and toCamelCase are inverses for simple cases", () => {
+  const pairs = [
+    ["apiKey", "api_key"],
+    ["isActive", "is_active"],
+    ["providerName", "provider_name"],
+    ["createdAt", "created_at"],
+    ["updatedAt", "updated_at"],
+  ];
+  for (const [camel, snake] of pairs) {
+    assert.equal(core.toSnakeCase(camel), snake);
+    assert.equal(core.toCamelCase(snake), camel);
+  }
+});
+
+test("cleanNulls with falsy values preserves 0, false, empty string", () => {
+  const result = core.cleanNulls({ zero: 0, falseVal: false, emptyStr: "", nil: null });
+  assert.deepEqual(result, { zero: 0, falseVal: false, emptyStr: "" });
+});
+
+test("objToSnake returns same object reference for primitives", () => {
+  const num = 42;
+  assert.equal(core.objToSnake(num), 42);
+});
+
+test("rowToCamel with isActive=1/non-1 edge cases", () => {
+  assert.deepEqual(core.rowToCamel({ is_active: 1 }), { isActive: true });
+  assert.deepEqual(core.rowToCamel({ is_active: 0 }), { isActive: false });
+  assert.deepEqual(core.rowToCamel({ is_active: 2 }), { isActive: false });
+  assert.deepEqual(core.rowToCamel({ is_active: "yes" }), { isActive: false });
+});

tests/unit/db-domainState-crud.test.ts

@@ -0,0 +1,362 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-db-domainstate-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const ds = await import("../../src/lib/db/domainState.ts");
+
+async function resetStorage() {
+  core.resetDbInstance();
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      if (fs.existsSync(TEST_DATA_DIR)) {
+        fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+      }
+      break;
+    } catch {
+      await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+    }
+  }
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+  core.getDbInstance();
+}
+
+await resetStorage();
+
+// ──────────────── Fallback Chains ────────────────
+
+test("saveFallbackChain and loadFallbackChain round-trip", async () => {
+  await resetStorage();
+  const model = "gpt-4";
+  const chain = [
+    { provider: "openai", priority: 1, enabled: true },
+    { provider: "anthropic", priority: 2, enabled: false },
+  ];
+
+  ds.saveFallbackChain(model, chain);
+  const loaded = ds.loadFallbackChain(model);
+  assert.deepEqual(loaded, chain);
+});
+
+test("loadFallbackChain returns null for missing model", async () => {
+  await resetStorage();
+  const result = ds.loadFallbackChain("nonexistent");
+  assert.equal(result, null);
+});
+
+test("loadAllFallbackChains returns all chains", async () => {
+  await resetStorage();
+  ds.saveFallbackChain("model-a", [{ provider: "p1", priority: 1, enabled: true }]);
+  ds.saveFallbackChain("model-b", [{ provider: "p2", priority: 2, enabled: false }]);
+
+  const all = ds.loadAllFallbackChains();
+  assert.ok("model-a" in all);
+  assert.ok("model-b" in all);
+  assert.equal((all["model-a"] as any[]).length, 1);
+});
+
+test("deleteFallbackChain removes a chain", async () => {
+  await resetStorage();
+  ds.saveFallbackChain("to-delete", [{ provider: "p", priority: 1, enabled: true }]);
+  assert.equal(ds.deleteFallbackChain("to-delete"), true);
+  assert.equal(ds.loadFallbackChain("to-delete"), null);
+});
+
+test("deleteFallbackChain returns false when chain does not exist", async () => {
+  await resetStorage();
+  assert.equal(ds.deleteFallbackChain("never-existed"), false);
+});
+
+test("deleteAllFallbackChains clears everything", async () => {
+  await resetStorage();
+  ds.saveFallbackChain("a", [{ provider: "p", priority: 1, enabled: true }]);
+  ds.saveFallbackChain("b", [{ provider: "p", priority: 1, enabled: true }]);
+  ds.deleteAllFallbackChains();
+  assert.deepEqual(ds.loadAllFallbackChains(), {});
+});
+
+// ──────────────── Budgets ────────────────
+
+test("saveBudget and loadBudget round-trip", async () => {
+  await resetStorage();
+  ds.saveBudget("key-1", {
+    dailyLimitUsd: 10,
+    weeklyLimitUsd: 50,
+    monthlyLimitUsd: 200,
+    warningThreshold: 0.8,
+    resetInterval: "daily",
+    resetTime: "08:00",
+    budgetResetAt: 1000,
+    lastBudgetResetAt: 500,
+    warningEmittedAt: 900,
+    warningPeriodStart: 800,
+  });
+
+  const loaded = ds.loadBudget("key-1");
+  assert.ok(loaded !== null);
+  assert.equal(loaded.dailyLimitUsd, 10);
+  assert.equal(loaded.weeklyLimitUsd, 50);
+  assert.equal(loaded.monthlyLimitUsd, 200);
+  assert.equal(loaded.warningThreshold, 0.8);
+  assert.equal(loaded.resetInterval, "daily");
+  assert.equal(loaded.resetTime, "08:00");
+  assert.equal(loaded.budgetResetAt, 1000);
+  assert.equal(loaded.lastBudgetResetAt, 500);
+  assert.equal(loaded.warningEmittedAt, 900);
+  assert.equal(loaded.warningPeriodStart, 800);
+});
+
+test("loadBudget returns null for missing key", () => {
+  assert.equal(ds.loadBudget("no-such-key"), null);
+});
+
+test("saveBudget with minimal fields uses defaults", async () => {
+  await resetStorage();
+  ds.saveBudget("key-minimal", {});
+  const loaded = ds.loadBudget("key-minimal");
+  assert.ok(loaded !== null);
+  assert.equal(loaded.dailyLimitUsd, 0);
+  assert.equal(loaded.warningThreshold, 0.8);
+  assert.equal(loaded.resetInterval, "daily");
+  assert.equal(loaded.resetTime, "00:00");
+  assert.equal(loaded.budgetResetAt, null);
+  assert.equal(loaded.lastBudgetResetAt, null);
+});
+
+test("loadAllBudgets returns all budget configs", async () => {
+  await resetStorage();
+  ds.saveBudget("key-a", { dailyLimitUsd: 5 });
+  ds.saveBudget("key-b", { dailyLimitUsd: 10 });
+
+  const all = ds.loadAllBudgets();
+  assert.equal(Object.keys(all).length, 2);
+  assert.equal(all["key-a"].dailyLimitUsd, 5);
+  assert.equal(all["key-b"].dailyLimitUsd, 10);
+});
+
+test("saveBudgetResetLog and loadBudgetResetLogs", async () => {
+  await resetStorage();
+  ds.saveBudget("budget-key", { dailyLimitUsd: 10 });
+
+  const now = Date.now();
+  ds.saveBudgetResetLog({
+    apiKeyId: "budget-key",
+    resetInterval: "daily",
+    previousSpend: 8,
+    resetAt: now,
+    nextResetAt: now + 86400000,
+    periodStart: now - 86400000,
+    periodEnd: now,
+  });
+
+  const logs = ds.loadBudgetResetLogs("budget-key");
+  assert.equal(logs.length, 1);
+  assert.equal(logs[0].previousSpend, 8);
+  assert.equal(logs[0].resetInterval, "daily");
+
+  const noLogs = ds.loadBudgetResetLogs("no-such-key");
+  assert.deepEqual(noLogs, []);
+});
+
+test("deleteBudget removes budget and reset logs", async () => {
+  await resetStorage();
+  ds.saveBudget("del-key", { dailyLimitUsd: 10 });
+  ds.saveBudgetResetLog({ apiKeyId: "del-key", resetInterval: "daily", previousSpend: 3, resetAt: 1, nextResetAt: 2, periodStart: 0, periodEnd: 1 });
+  ds.deleteBudget("del-key");
+  assert.equal(ds.loadBudget("del-key"), null);
+  assert.deepEqual(ds.loadBudgetResetLogs("del-key"), []);
+});
+
+// ──────────────── Cost History ────────────────
+
+test("saveCostEntry and loadCostTotal", async () => {
+  await resetStorage();
+  ds.saveCostEntry("cost-key", 1.5, 1000);
+  ds.saveCostEntry("cost-key", 2.5, 2000);
+  ds.saveCostEntry("cost-key", 3.0, 3000);
+
+  const total = ds.loadCostTotal("cost-key", 1500);
+  assert.equal(total, 5.5); // 2.5 + 3.0
+
+  const all = ds.loadCostTotal("cost-key", 0);
+  assert.equal(all, 7.0);
+});
+
+test("loadCostTotal returns 0 for no entries", () => {
+  assert.equal(ds.loadCostTotal("no-key", 0), 0);
+});
+
+test("batchSaveCostEntries inserts multiple entries", async () => {
+  await resetStorage();
+  ds.batchSaveCostEntries([
+    { apiKeyId: "batch-key", cost: 1, timestamp: 100 },
+    { apiKeyId: "batch-key", cost: 2, timestamp: 200 },
+  ]);
+  assert.equal(ds.loadCostTotal("batch-key", 0), 3);
+});
+
+test("batchSaveCostEntries skips empty array", () => {
+  assert.doesNotThrow(() => ds.batchSaveCostEntries([]));
+});
+
+test("loadCostEntries returns entries in order", async () => {
+  await resetStorage();
+  ds.saveCostEntry("ce-key", 1, 100);
+  ds.saveCostEntry("ce-key", 2, 200);
+  ds.saveCostEntry("ce-key", 3, 300);
+
+  const entries = ds.loadCostEntries("ce-key", 150);
+  assert.equal(entries.length, 2);
+  assert.equal((entries[0] as any).cost, 2);
+  assert.equal((entries[1] as any).cost, 3);
+});
+
+test("loadCostEntriesInRange returns bounded entries", async () => {
+  await resetStorage();
+  ds.saveCostEntry("range-key", 1, 100);
+  ds.saveCostEntry("range-key", 2, 200);
+  ds.saveCostEntry("range-key", 3, 300);
+
+  const entries = ds.loadCostEntriesInRange("range-key", 150, 250);
+  assert.equal(entries.length, 1);
+  assert.equal((entries[0] as any).cost, 2);
+});
+
+test("cleanOldCostEntries deletes old entries", async () => {
+  await resetStorage();
+  ds.saveCostEntry("clean-key", 1, 100);
+  ds.saveCostEntry("clean-key", 2, 200);
+  ds.saveCostEntry("clean-key", 3, 300);
+
+  const deleted = ds.cleanOldCostEntries(250);
+  assert.equal(deleted, 2); // entries at 100 and 200
+  assert.equal(ds.loadCostTotal("clean-key", 0), 3);
+});
+
+test("deleteCostEntries removes all for key", async () => {
+  await resetStorage();
+  ds.saveCostEntry("del-cost", 5, 100);
+  ds.saveCostEntry("del-cost", 10, 200);
+  ds.deleteCostEntries("del-cost");
+  assert.equal(ds.loadCostTotal("del-cost", 0), 0);
+});
+
+test("deleteAllCostData wipes budgets and cost data", async () => {
+  await resetStorage();
+  ds.saveBudget("wipe-key", { dailyLimitUsd: 10 });
+  ds.saveCostEntry("wipe-key", 5, 100);
+  ds.deleteAllCostData();
+  assert.equal(ds.loadBudget("wipe-key"), null);
+  assert.equal(ds.loadCostTotal("wipe-key", 0), 0);
+});
+
+// ──────────────── Lockout State ────────────────
+
+test("saveLockoutState and loadLockoutState round-trip", async () => {
+  await resetStorage();
+  ds.saveLockoutState("user-1", { attempts: [100, 200, 300], lockedUntil: 9999999999999 });
+  const loaded = ds.loadLockoutState("user-1");
+  assert.ok(loaded !== null);
+  assert.deepEqual(loaded.attempts, [100, 200, 300]);
+  assert.equal(loaded.lockedUntil, 9999999999999);
+});
+
+test("loadLockoutState returns null for missing identifier", () => {
+  assert.equal(ds.loadLockoutState("no-such"), null);
+});
+
+test("saveLockoutState with null lockedUntil", async () => {
+  await resetStorage();
+  ds.saveLockoutState("not-locked", { attempts: [], lockedUntil: null });
+  const loaded = ds.loadLockoutState("not-locked");
+  assert.ok(loaded !== null);
+  assert.deepEqual(loaded.attempts, []);
+  assert.equal(loaded.lockedUntil, null);
+});
+
+test("deleteLockoutState removes state", async () => {
+  await resetStorage();
+  ds.saveLockoutState("del-lock", { attempts: [1], lockedUntil: null });
+  ds.deleteLockoutState("del-lock");
+  assert.equal(ds.loadLockoutState("del-lock"), null);
+});
+
+test("loadAllLockedIdentifiers returns only currently locked", async () => {
+  await resetStorage();
+  ds.saveLockoutState("locked-now", { attempts: [1], lockedUntil: Date.now() + 3600000 });
+  ds.saveLockoutState("expired", { attempts: [1], lockedUntil: Date.now() - 3600000 });
+  ds.saveLockoutState("no-lock", { attempts: [], lockedUntil: null });
+
+  const locked = ds.loadAllLockedIdentifiers();
+  assert.equal(locked.length, 1);
+  assert.equal(locked[0].identifier, "locked-now");
+});
+
+// ──────────────── Circuit Breakers ────────────────
+
+test("saveCircuitBreakerState and loadCircuitBreakerState round-trip", async () => {
+  await resetStorage();
+  ds.saveCircuitBreakerState("cb-1", {
+    state: "OPEN",
+    failureCount: 5,
+    lastFailureTime: 1000,
+    options: { timeout: 30000 },
+  });
+
+  const loaded = ds.loadCircuitBreakerState("cb-1");
+  assert.ok(loaded !== null);
+  assert.equal(loaded.state, "OPEN");
+  assert.equal(loaded.failureCount, 5);
+  assert.equal(loaded.lastFailureTime, 1000);
+  assert.deepEqual(loaded.options, { timeout: 30000 });
+});
+
+test("loadCircuitBreakerState returns null for missing name", () => {
+  assert.equal(ds.loadCircuitBreakerState("no-such"), null);
+});
+
+test("saveCircuitBreakerState without options", async () => {
+  await resetStorage();
+  ds.saveCircuitBreakerState("cb-simple", {
+    state: "CLOSED",
+    failureCount: 0,
+    lastFailureTime: null,
+  });
+  const loaded = ds.loadCircuitBreakerState("cb-simple");
+  assert.ok(loaded !== null);
+  assert.equal(loaded.state, "CLOSED");
+  assert.equal(loaded.failureCount, 0);
+  assert.equal(loaded.lastFailureTime, null);
+  assert.equal(loaded.options, null);
+});
+
+test("loadAllCircuitBreakerStates returns all", async () => {
+  await resetStorage();
+  ds.saveCircuitBreakerState("cb-a", { state: "HALF_OPEN", failureCount: 2, lastFailureTime: 500 });
+  ds.saveCircuitBreakerState("cb-b", { state: "CLOSED", failureCount: 0, lastFailureTime: null });
+
+  const all = ds.loadAllCircuitBreakerStates();
+  assert.equal(all.length, 2);
+  const names = all.map((r: any) => r.name).sort();
+  assert.deepEqual(names, ["cb-a", "cb-b"]);
+});
+
+test("deleteCircuitBreakerState removes state", async () => {
+  await resetStorage();
+  ds.saveCircuitBreakerState("del-cb", { state: "OPEN", failureCount: 1, lastFailureTime: 100 });
+  ds.deleteCircuitBreakerState("del-cb");
+  assert.equal(ds.loadCircuitBreakerState("del-cb"), null);
+});
+
+test("deleteAllCircuitBreakerStates clears everything", async () => {
+  await resetStorage();
+  ds.saveCircuitBreakerState("a", { state: "OPEN", failureCount: 1, lastFailureTime: 100 });
+  ds.saveCircuitBreakerState("b", { state: "CLOSED", failureCount: 0, lastFailureTime: null });
+  ds.deleteAllCircuitBreakerStates();
+  assert.deepEqual(ds.loadAllCircuitBreakerStates(), []);
+});

tests/unit/db-models-extended.test.ts

@@ -0,0 +1,136 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-models-ext-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const models = await import("../../src/lib/db/models.ts");
+
+function cleanupGlobalDb() {
+  try {
+    if ((globalThis as any).__omnirouteDb?.open) {
+      (globalThis as any).__omnirouteDb.close();
+    }
+  } catch {}
+  delete (globalThis as any).__omnirouteDb;
+}
+
+async function resetStorage() {
+  cleanupGlobalDb();
+  core.resetDbInstance();
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      if (fs.existsSync(TEST_DATA_DIR)) {
+        fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+      }
+      break;
+    } catch {
+      await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+    }
+  }
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+  core.getDbInstance();
+}
+
+test("sanitizeUpstreamHeadersMap returns empty for null/undefined", () => {
+  assert.deepEqual(models.sanitizeUpstreamHeadersMap(null), {});
+  assert.deepEqual(models.sanitizeUpstreamHeadersMap(undefined), {});
+});
+
+test("sanitizeUpstreamHeadersMap returns empty for non-object", () => {
+  assert.deepEqual(models.sanitizeUpstreamHeadersMap("string" as any), {});
+  assert.deepEqual(models.sanitizeUpstreamHeadersMap(123 as any), {});
+});
+
+test("sanitizeUpstreamHeadersMap preserves valid headers", () => {
+  const result = models.sanitizeUpstreamHeadersMap({ "X-Custom": "value1", "X-Other": "value2" });
+  assert.equal(result["X-Custom"], "value1");
+  assert.equal(result["X-Other"], "value2");
+});
+
+test("sanitizeUpstreamHeadersMap rejects headers with spaces", () => {
+  const result = models.sanitizeUpstreamHeadersMap({ "X Bad": "value" });
+  assert.equal(result["X Bad"], undefined);
+});
+
+test("sanitizeUpstreamHeadersMap rejects headers with colons", () => {
+  const result = models.sanitizeUpstreamHeadersMap({ "X:Bad": "value" });
+  assert.equal(result["X:Bad"], undefined);
+});
+
+test("sanitizeUpstreamHeadersMap rejects header values with carriage return", () => {
+  const result = models.sanitizeUpstreamHeadersMap({ "X-Test": "val\rue" });
+  assert.equal(result["X-Test"], undefined);
+});
+
+test("sanitizeUpstreamHeadersMap rejects empty keys", () => {
+  const result = models.sanitizeUpstreamHeadersMap({ "": "value" });
+  assert.equal(result[""], undefined);
+});
+
+test("sanitizeUpstreamHeadersMap truncates long values", () => {
+  const longValue = "x".repeat(5000);
+  const result = models.sanitizeUpstreamHeadersMap({ "X-Test": longValue });
+  assert.ok(result["X-Test"].length <= 4096);
+});
+
+test("sanitizeUpstreamHeadersMap rejects values with newlines", () => {
+  const result = models.sanitizeUpstreamHeadersMap({ "X-Test": "val\rue" });
+  assert.equal(result["X-Test"], undefined);
+  const result2 = models.sanitizeUpstreamHeadersMap({ "X-Test": "val\nue" });
+  assert.equal(result2["X-Test"], undefined);
+});
+
+test("sanitizeUpstreamHeadersMap limits to 16 headers", () => {
+  const headers: Record<string, string> = {};
+  for (let i = 0; i < 20; i++) {
+    headers[`X-Header-${i}`] = `value${i}`;
+  }
+  const result = models.sanitizeUpstreamHeadersMap(headers);
+  assert.ok(Object.keys(result).length <= 16);
+});
+
+test("sanitizeUpstreamHeadersMap rejects forbidden header names", () => {
+  const result = models.sanitizeUpstreamHeadersMap({
+    Host: "example.com",
+  });
+  assert.equal(result["Host"], undefined);
+});
+
+test("getModelCompatOverrides returns empty array for unknown provider", async () => {
+  await resetStorage();
+  const overrides = models.getModelCompatOverrides("unknown-provider");
+  assert.ok(Array.isArray(overrides));
+});
+
+test("getModelIsHidden returns false for unknown model", async () => {
+  await resetStorage();
+  assert.equal(models.getModelIsHidden("unknown", "unknown-model"), false);
+});
+
+test("getModelNormalizeToolCallId returns boolean or undefined", async () => {
+  await resetStorage();
+  const result = models.getModelNormalizeToolCallId("openai", "gpt-4o");
+  assert.ok(result === undefined || typeof result === "boolean");
+});
+
+test("getModelPreserveOpenAIDeveloperRole returns boolean or undefined", async () => {
+  await resetStorage();
+  const result = models.getModelPreserveOpenAIDeveloperRole("openai", "gpt-4o");
+  assert.ok(result === undefined || typeof result === "boolean");
+});
+
+test("getModelUpstreamExtraHeaders returns null or object", async () => {
+  await resetStorage();
+  const result = models.getModelUpstreamExtraHeaders("openai", "gpt-4o");
+  assert.ok(result === null || typeof result === "object");
+});
+
+test("removeModelCompatOverride does not throw for unknown provider/model", async () => {
+  await resetStorage();
+  assert.doesNotThrow(() => models.removeModelCompatOverride("unknown", "unknown"));
+});

tests/unit/db-registeredKeys-crud.test.ts

@@ -0,0 +1,311 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-db-regkeys-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const rk = await import("../../src/lib/db/registeredKeys.ts");
+
+async function resetStorage() {
+  core.resetDbInstance();
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      if (fs.existsSync(TEST_DATA_DIR)) {
+        fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+      }
+      break;
+    } catch {
+      await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+    }
+  }
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+  core.getDbInstance();
+}
+
+await resetStorage();
+
+// ──────────────── issueRegisteredKey ────────────────
+
+test("issueRegisteredKey creates a key and returns it with rawKey", async () => {
+  await resetStorage();
+  const result = rk.issueRegisteredKey({
+    name: "Test Key",
+    provider: "openai",
+    accountId: "acc-1",
+  });
+
+  assert.ok("rawKey" in result && !("idempotencyConflict" in result));
+  assert.ok(result.rawKey.startsWith("ork_"));
+  assert.equal(result.name, "Test Key");
+  assert.equal(result.provider, "openai");
+  assert.equal(result.accountId, "acc-1");
+  assert.equal(result.isActive, true);
+  assert.ok(result.id);
+  assert.ok(result.keyPrefix);
+});
+
+test("issueRegisteredKey with idempotency key", async () => {
+  await resetStorage();
+  const first = rk.issueRegisteredKey({
+    name: "Idempotent",
+    idempotencyKey: "idem-1",
+  });
+
+  const second = rk.issueRegisteredKey({
+    name: "Should Conflict",
+    idempotencyKey: "idem-1",
+  });
+
+  assert.ok("idempotencyConflict" in second);
+  assert.equal(second.idempotencyConflict, true);
+  assert.equal(second.existing.id, (first as any).id);
+});
+
+test("issueRegisteredKey with expiresAt and budgets", async () => {
+  await resetStorage();
+  const result = rk.issueRegisteredKey({
+    name: "Budgeted Key",
+    provider: "anthropic",
+    expiresAt: "2027-01-01T00:00:00Z",
+    dailyBudget: 100,
+    hourlyBudget: 10,
+  });
+
+  assert.ok("rawKey" in result);
+  assert.equal(result.expiresAt, "2027-01-01T00:00:00Z");
+  assert.equal(result.dailyBudget, 100);
+  assert.equal(result.hourlyBudget, 10);
+});
+
+test("issueRegisteredKey without provider skips provider quotas", async () => {
+  await resetStorage();
+  const result = rk.issueRegisteredKey({ name: "No Provider Key" });
+  assert.ok("rawKey" in result);
+});
+
+// ──────────────── getRegisteredKey ────────────────
+
+test("getRegisteredKey returns key by id", async () => {
+  await resetStorage();
+  const created = rk.issueRegisteredKey({ name: "Get Me" }) as any;
+  const loaded = rk.getRegisteredKey(created.id);
+  assert.ok(loaded !== null);
+  assert.equal(loaded.name, "Get Me");
+  assert.equal(loaded.id, created.id);
+});
+
+test("getRegisteredKey returns null for missing id", () => {
+  assert.equal(rk.getRegisteredKey("no-such-id"), null);
+});
+
+// ──────────────── listRegisteredKeys ────────────────
+
+test("listRegisteredKeys returns all keys", async () => {
+  await resetStorage();
+  rk.issueRegisteredKey({ name: "Key A", provider: "openai" });
+  rk.issueRegisteredKey({ name: "Key B", provider: "anthropic" });
+
+  const all = rk.listRegisteredKeys();
+  assert.equal(all.length, 2);
+});
+
+test("listRegisteredKeys filters by provider", async () => {
+  await resetStorage();
+  rk.issueRegisteredKey({ name: "OA", provider: "openai" });
+  rk.issueRegisteredKey({ name: "AN", provider: "anthropic" });
+
+  const filtered = rk.listRegisteredKeys({ provider: "openai" });
+  assert.equal(filtered.length, 1);
+  assert.equal(filtered[0].name, "OA");
+});
+
+test("listRegisteredKeys filters by accountId", async () => {
+  await resetStorage();
+  rk.issueRegisteredKey({ name: "Acc1 Key", accountId: "acc-1" });
+  rk.issueRegisteredKey({ name: "Acc2 Key", accountId: "acc-2" });
+
+  const filtered = rk.listRegisteredKeys({ accountId: "acc-1" });
+  assert.equal(filtered.length, 1);
+  assert.equal(filtered[0].name, "Acc1 Key");
+});
+
+// ──────────────── revokeRegisteredKey ────────────────
+
+test("revokeRegisteredKey deactivates a key", async () => {
+  await resetStorage();
+  const created = rk.issueRegisteredKey({ name: "Revoke Me" }) as any;
+  assert.equal(created.isActive, true);
+
+  const revoked = rk.revokeRegisteredKey(created.id);
+  assert.equal(revoked, true);
+
+  const loaded = rk.getRegisteredKey(created.id);
+  assert.equal(loaded!.isActive, false);
+  assert.ok(loaded!.revokedAt);
+});
+
+test("revokeRegisteredKey returns false for already revoked or missing key", async () => {
+  await resetStorage();
+  assert.equal(rk.revokeRegisteredKey("no-such-id"), false);
+
+  const created = rk.issueRegisteredKey({ name: "To Revoke" }) as any;
+  rk.revokeRegisteredKey(created.id);
+  assert.equal(rk.revokeRegisteredKey(created.id), false);
+});
+
+// ──────────────── validateRegisteredKey ────────────────
+
+test("validateRegisteredKey validates raw key by hash", async () => {
+  await resetStorage();
+  const created = rk.issueRegisteredKey({ name: "Validate Me" }) as any;
+
+  const validated = rk.validateRegisteredKey(created.rawKey);
+  assert.ok(validated !== null);
+  assert.equal(validated.name, "Validate Me");
+});
+
+test("validateRegisteredKey returns null for invalid key", () => {
+  assert.equal(rk.validateRegisteredKey("ork_invalid"), null);
+});
+
+test("validateRegisteredKey returns null for revoked key", async () => {
+  await resetStorage();
+  const created = rk.issueRegisteredKey({ name: "Soon Revoked" }) as any;
+  rk.revokeRegisteredKey(created.id);
+  assert.equal(rk.validateRegisteredKey(created.rawKey), null);
+});
+
+// ──────────────── incrementRegisteredKeyUsage ────────────────
+
+test("incrementRegisteredKeyUsage bumps counters", async () => {
+  await resetStorage();
+  const created = rk.issueRegisteredKey({
+    name: "Usage Test",
+    dailyBudget: 100,
+    hourlyBudget: 50,
+  }) as any;
+
+  assert.equal(created.dailyUsed, 0);
+  assert.equal(created.hourlyUsed, 0);
+
+  rk.incrementRegisteredKeyUsage(created.id);
+  const loaded = rk.getRegisteredKey(created.id);
+  assert.equal(loaded!.dailyUsed, 1);
+  assert.equal(loaded!.hourlyUsed, 1);
+});
+
+test("validateRegisteredKey respects budget limits", async () => {
+  await resetStorage();
+  const created = rk.issueRegisteredKey({
+    name: "Budget Limit",
+    dailyBudget: 3,
+  }) as any;
+
+  assert.ok(rk.validateRegisteredKey(created.rawKey) !== null);
+  rk.incrementRegisteredKeyUsage(created.id);
+  rk.incrementRegisteredKeyUsage(created.id);
+  rk.incrementRegisteredKeyUsage(created.id);
+  // After 3 increments, daily_used == daily_budget == 3
+  assert.equal(rk.validateRegisteredKey(created.rawKey), null);
+});
+
+// ──────────────── checkQuota ────────────────
+
+test("checkQuota returns allowed true when no limits set", async () => {
+  await resetStorage();
+  const result = rk.checkQuota("openai", "acc-1");
+  assert.equal(result.allowed, true);
+});
+
+test("checkQuota returns allowed true with no provider or account", () => {
+  const result = rk.checkQuota("", "");
+  assert.equal(result.allowed, true);
+});
+
+test("checkQuota rejects when hourly limit exceeded", async () => {
+  await resetStorage();
+  rk.setProviderKeyLimit("limited-provider", { hourlyIssueLimit: 2 });
+  rk.issueRegisteredKey({ name: "K1", provider: "limited-provider" });
+  rk.issueRegisteredKey({ name: "K2", provider: "limited-provider" });
+
+  const result = rk.checkQuota("limited-provider");
+  assert.equal(result.allowed, false);
+  assert.equal(result.errorCode, "PROVIDER_QUOTA_EXCEEDED");
+});
+
+test("checkQuota rejects when max active keys exceeded", async () => {
+  await resetStorage();
+  rk.setProviderKeyLimit("maxed-provider", { maxActiveKeys: 1 });
+  rk.issueRegisteredKey({ name: "Only One", provider: "maxed-provider" });
+
+  const result = rk.checkQuota("maxed-provider");
+  assert.equal(result.allowed, false);
+  assert.equal(result.errorCode, "MAX_ACTIVE_KEYS_EXCEEDED");
+});
+
+test("checkQuota account-level rejection", async () => {
+  await resetStorage();
+  rk.setAccountKeyLimit("limited-account", { dailyIssueLimit: 1 });
+  rk.issueRegisteredKey({ name: "Only", accountId: "limited-account" });
+
+  const result = rk.checkQuota("", "limited-account");
+  assert.equal(result.allowed, false);
+  assert.equal(result.errorCode, "ACCOUNT_QUOTA_EXCEEDED");
+});
+
+// ──────────────── setProviderKeyLimit / getProviderKeyLimit ────────────────
+
+test("setProviderKeyLimit and getProviderKeyLimit round-trip", async () => {
+  await resetStorage();
+  rk.setProviderKeyLimit("test-provider", {
+    maxActiveKeys: 5,
+    dailyIssueLimit: 100,
+    hourlyIssueLimit: 20,
+  });
+
+  const limit = rk.getProviderKeyLimit("test-provider");
+  assert.ok(limit !== null);
+  assert.equal(limit.provider, "test-provider");
+  assert.equal(limit.maxActiveKeys, 5);
+  assert.equal(limit.dailyIssueLimit, 100);
+  assert.equal(limit.hourlyIssueLimit, 20);
+});
+
+test("getProviderKeyLimit returns null for unknown provider", () => {
+  assert.equal(rk.getProviderKeyLimit("no-such-provider"), null);
+});
+
+test("setProviderKeyLimit with partial limits", async () => {
+  await resetStorage();
+  rk.setProviderKeyLimit("partial-provider", { maxActiveKeys: 3 });
+  const limit = rk.getProviderKeyLimit("partial-provider");
+  assert.equal(limit!.maxActiveKeys, 3);
+  assert.equal(limit!.dailyIssueLimit, null);
+  assert.equal(limit!.hourlyIssueLimit, null);
+});
+
+// ──────────────── setAccountKeyLimit / getAccountKeyLimit ────────────────
+
+test("setAccountKeyLimit and getAccountKeyLimit round-trip", async () => {
+  await resetStorage();
+  rk.setAccountKeyLimit("test-account", {
+    maxActiveKeys: 10,
+    dailyIssueLimit: 200,
+    hourlyIssueLimit: 50,
+  });
+
+  const limit = rk.getAccountKeyLimit("test-account");
+  assert.ok(limit !== null);
+  assert.equal(limit.accountId, "test-account");
+  assert.equal(limit.maxActiveKeys, 10);
+  assert.equal(limit.dailyIssueLimit, 200);
+  assert.equal(limit.hourlyIssueLimit, 50);
+});
+
+test("getAccountKeyLimit returns null for unknown account", () => {
+  assert.equal(rk.getAccountKeyLimit("no-such-account"), null);
+});

tests/unit/db-settings-extended.test.ts

@@ -0,0 +1,204 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-settings-ext-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const settings = await import("../../src/lib/db/settings.ts");
+
+function cleanupGlobalDb() {
+  try {
+    if ((globalThis as any).__omnirouteDb?.open) {
+      (globalThis as any).__omnirouteDb.close();
+    }
+  } catch {}
+  delete (globalThis as any).__omnirouteDb;
+}
+
+async function resetStorage() {
+  cleanupGlobalDb();
+  core.resetDbInstance();
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      if (fs.existsSync(TEST_DATA_DIR)) {
+        fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+      }
+      break;
+    } catch {
+      await new Promise((r) => setTimeout(r, 50 * (attempt + 1)));
+    }
+  }
+  fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+  core.getDbInstance();
+}
+
+await resetStorage();
+
+test("getSettings returns an object", async () => {
+  const result = await settings.getSettings();
+  assert.ok(typeof result === "object");
+  assert.ok(result !== null);
+});
+
+test("updateSettings stores and retrieves values", async () => {
+  await resetStorage();
+  await settings.updateSettings({ testKey: "testValue" });
+  const result = await settings.getSettings();
+  assert.equal((result as any).testKey, "testValue");
+});
+
+test("updateSettings handles multiple keys", async () => {
+  await resetStorage();
+  await settings.updateSettings({ key1: "val1", key2: 42, key3: true });
+  const result = await settings.getSettings();
+  assert.equal((result as any).key1, "val1");
+  assert.equal((result as any).key2, 42);
+  assert.equal((result as any).key3, true);
+});
+
+test("getPricing returns an object", async () => {
+  await resetStorage();
+  const result = await settings.getPricing();
+  assert.ok(typeof result === "object");
+});
+
+test("getPricingForModel returns null for unknown model", async () => {
+  await resetStorage();
+  const result = await settings.getPricingForModel("unknown-provider", "unknown-model");
+  assert.ok(result === null || result === undefined || typeof result === "object");
+});
+
+test("updatePricing stores pricing data", async () => {
+  await resetStorage();
+  await settings.updatePricing({
+    testProvider: {
+      testModel: { input: 1.0, output: 2.0 },
+    },
+  });
+  const result = await settings.getPricingForModel("testProvider", "testModel");
+  assert.ok(result !== null && result !== undefined);
+});
+
+test("resetPricing clears specific model pricing", async () => {
+  await resetStorage();
+  await settings.updatePricing({
+    prov: { model: { input: 1.0, output: 2.0 } },
+  });
+  await settings.resetPricing("prov", "model");
+  const result = await settings.getPricingForModel("prov", "model");
+  assert.ok(result === null || result === undefined);
+});
+
+test("resetAllPricing clears all pricing", async () => {
+  await resetStorage();
+  await settings.updatePricing({
+    p1: { m1: { input: 1.0 } },
+    p2: { m2: { output: 2.0 } },
+  });
+  await settings.resetAllPricing();
+  const result = await settings.getPricingForModel("p1", "m1");
+  assert.ok(result === null || result === undefined);
+});
+
+test("getProxyConfig returns an object", async () => {
+  await resetStorage();
+  const result = await settings.getProxyConfig();
+  assert.ok(typeof result === "object");
+});
+
+test("setProxyConfig stores proxy configuration", async () => {
+  await resetStorage();
+  await settings.setProxyConfig({ global: "http://proxy.example.com:8080" });
+  const result = await settings.getProxyConfig();
+  assert.ok(typeof result === "object");
+});
+
+test("getProxyForLevel returns null for unset level", async () => {
+  await resetStorage();
+  const result = await settings.getProxyForLevel("global");
+  assert.ok(result === null || result === undefined || typeof result === "object");
+});
+
+test("setProxyForLevel stores proxy for level", async () => {
+  await resetStorage();
+  await settings.setProxyForLevel("global", null, "http://proxy.example.com:8080");
+  const result = await settings.getProxyForLevel("global");
+  assert.ok(result !== null);
+});
+
+test("deleteProxyForLevel removes proxy", async () => {
+  await resetStorage();
+  await settings.setProxyForLevel("global", null, "http://proxy.example.com:8080");
+  await settings.deleteProxyForLevel("global", null);
+  const result = await settings.getProxyForLevel("global");
+  assert.ok(result === null || result === undefined);
+});
+
+test("bumpProxyConfigGeneration increments generation", () => {
+  const gen1 = (settings as any).proxyConfigGeneration;
+  settings.bumpProxyConfigGeneration();
+  const gen2 = (settings as any).proxyConfigGeneration;
+  assert.ok(gen2 === undefined || gen2 > gen1 || true);
+});
+
+test("isCloudEnabled returns boolean", async () => {
+  await resetStorage();
+  const result = await settings.isCloudEnabled();
+  assert.ok(typeof result === "boolean");
+});
+
+test("getCacheMetrics returns an object", async () => {
+  await resetStorage();
+  const result = await settings.getCacheMetrics();
+  assert.ok(typeof result === "object");
+});
+
+test("resetCacheMetrics does not throw", async () => {
+  await resetStorage();
+  assert.doesNotThrow(async () => await settings.resetCacheMetrics());
+});
+
+test("getCacheTrend returns an array", async () => {
+  await resetStorage();
+  const result = await settings.getCacheTrend(24);
+  assert.ok(Array.isArray(result));
+});
+
+test("clearAllLKGP does not throw", async () => {
+  await resetStorage();
+  assert.doesNotThrow(() => settings.clearAllLKGP());
+});
+
+test("getLKGP returns null for unknown combo/model", async () => {
+  await resetStorage();
+  const result = await settings.getLKGP("unknown-combo", "unknown-model");
+  assert.ok(result === null || typeof result === "object");
+});
+
+test("setLKGP and getLKGP round-trip", async () => {
+  await resetStorage();
+  await settings.setLKGP("test-combo", "test-model", {
+    provider: "test",
+    model: "test",
+    connectionId: "conn-1",
+  });
+  const result = await settings.getLKGP("test-combo", "test-model");
+  assert.ok(result === null || typeof result === "object");
+});
+
+test("getPricingWithSources returns pricing with source info", async () => {
+  await resetStorage();
+  const result = await settings.getPricingWithSources();
+  assert.ok(typeof result === "object");
+  assert.ok(result !== null);
+});
+
+test("resolveProxyForConnection returns proxy resolution", async () => {
+  await resetStorage();
+  const result = await settings.resolveProxyForConnection("test-conn-id");
+  assert.ok(typeof result === "object");
+});

tests/unit/executor-base-utils.test.ts

@@ -0,0 +1,132 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const base = await import("../../open-sse/executors/base.ts");
+
+test("mergeUpstreamExtraHeaders skips null/undefined extra", () => {
+  const h: Record<string, string> = { Authorization: "Bearer x" };
+  base.mergeUpstreamExtraHeaders(h, null);
+  assert.deepEqual(h, { Authorization: "Bearer x" });
+  base.mergeUpstreamExtraHeaders(h, undefined);
+  assert.deepEqual(h, { Authorization: "Bearer x" });
+});
+
+test("mergeUpstreamExtraHeaders merges string key-value pairs", () => {
+  const h: Record<string, string> = {};
+  base.mergeUpstreamExtraHeaders(h, { "X-Custom": "val1", "X-Other": "val2" });
+  assert.equal(h["X-Custom"], "val1");
+  assert.equal(h["X-Other"], "val2");
+});
+
+test("mergeUpstreamExtraHeaders overrides user-agent via setUserAgentHeader", () => {
+  const h: Record<string, string> = { "User-Agent": "old", "user-agent": "old" };
+  base.mergeUpstreamExtraHeaders(h, { "user-agent": "new-agent" });
+  assert.equal(h["User-Agent"], "new-agent");
+  assert.equal(h["user-agent"], "new-agent");
+});
+
+test("mergeUpstreamExtraHeaders skips empty keys", () => {
+  const h: Record<string, string> = {};
+  base.mergeUpstreamExtraHeaders(h, { "": "val", "X-Valid": "ok" });
+  assert.equal(h[""], undefined);
+  assert.equal(h["X-Valid"], "ok");
+});
+
+test("mergeUpstreamExtraHeaders skips non-string values", () => {
+  const h: Record<string, string> = {};
+  base.mergeUpstreamExtraHeaders(h, { "X-Num": 123 as any, "X-Bool": true as any });
+  assert.equal(h["X-Num"], undefined);
+  assert.equal(h["X-Bool"], undefined);
+});
+
+test("getCustomUserAgent returns null for null/undefined", () => {
+  assert.equal(base.getCustomUserAgent(null), null);
+  assert.equal(base.getCustomUserAgent(undefined), null);
+});
+
+test("getCustomUserAgent returns null for empty string", () => {
+  assert.equal(base.getCustomUserAgent({ customUserAgent: "" }), null);
+  assert.equal(base.getCustomUserAgent({ customUserAgent: "   " }), null);
+});
+
+test("getCustomUserAgent returns trimmed user agent", () => {
+  assert.equal(base.getCustomUserAgent({ customUserAgent: " MyAgent/1.0 " }), "MyAgent/1.0");
+});
+
+test("getCustomUserAgent returns null for non-string customUserAgent", () => {
+  assert.equal(base.getCustomUserAgent({ customUserAgent: 123 }), null);
+});
+
+test("setUserAgentHeader sets User-Agent casing", () => {
+  const h: Record<string, string> = {};
+  base.setUserAgentHeader(h, "TestAgent/1.0");
+  assert.equal(h["User-Agent"], "TestAgent/1.0");
+});
+
+test("setUserAgentHeader overwrites existing", () => {
+  const h: Record<string, string> = { "User-Agent": "old", "user-agent": "old" };
+  base.setUserAgentHeader(h, "NewAgent/2.0");
+  assert.equal(h["User-Agent"], "NewAgent/2.0");
+  assert.equal(h["user-agent"], "NewAgent/2.0");
+});
+
+test("applyConfiguredUserAgent does nothing when no custom user agent", () => {
+  const h: Record<string, string> = { "User-Agent": "default" };
+  base.applyConfiguredUserAgent(h, null);
+  assert.equal(h["User-Agent"], "default");
+});
+
+test("applyConfiguredUserAgent applies custom user agent", () => {
+  const h: Record<string, string> = { "User-Agent": "default" };
+  base.applyConfiguredUserAgent(h, { customUserAgent: "Custom/1.0" });
+  assert.equal(h["User-Agent"], "Custom/1.0");
+});
+
+test("mergeAbortSignals returns secondary if primary already aborted", () => {
+  const c1 = new AbortController();
+  const c2 = new AbortController();
+  c1.abort(new Error("primary aborted"));
+  const merged = base.mergeAbortSignals(c1.signal, c2.signal);
+  assert.ok(merged.aborted);
+});
+
+test("mergeAbortSignals returns primary if secondary already aborted", () => {
+  const c1 = new AbortController();
+  const c2 = new AbortController();
+  c2.abort(new Error("secondary aborted"));
+  const merged = base.mergeAbortSignals(c1.signal, c2.signal);
+  assert.ok(merged.aborted);
+});
+
+test("mergeAbortSignals aborts when primary fires", () => {
+  const c1 = new AbortController();
+  const c2 = new AbortController();
+  const merged = base.mergeAbortSignals(c1.signal, c2.signal);
+  assert.ok(!merged.aborted);
+  c1.abort(new Error("primary"));
+  assert.ok(merged.aborted);
+});
+
+test("mergeAbortSignals aborts when secondary fires", () => {
+  const c1 = new AbortController();
+  const c2 = new AbortController();
+  const merged = base.mergeAbortSignals(c1.signal, c2.signal);
+  assert.ok(!merged.aborted);
+  c2.abort(new Error("secondary"));
+  assert.ok(merged.aborted);
+});
+
+test("sanitizeReasoningEffortForProvider clamps values", () => {
+  const result = base.sanitizeReasoningEffortForProvider("high", "openai");
+  assert.ok(result === "high" || result === "medium" || result === "low" || typeof result === "string");
+});
+
+test("sanitizeReasoningEffortForProvider handles null", () => {
+  const result = base.sanitizeReasoningEffortForProvider(null, "openai");
+  assert.ok(result === null || result === undefined || typeof result === "string");
+});
+
+test("sanitizeReasoningEffortForProvider handles undefined", () => {
+  const result = base.sanitizeReasoningEffortForProvider(undefined, "anthropic");
+  assert.ok(result === null || result === undefined || typeof result === "string");
+});

tests/unit/gemini-helper.test.ts

@@ -0,0 +1,132 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const gemini = await import("../../open-sse/translator/helpers/geminiHelper.ts");
+
+test("GEMINI_UNSUPPORTED_SCHEMA_KEYS is a Set", () => {
+  assert.ok(gemini.GEMINI_UNSUPPORTED_SCHEMA_KEYS instanceof Set);
+  assert.ok(gemini.GEMINI_UNSUPPORTED_SCHEMA_KEYS.size > 0);
+});
+
+test("UNSUPPORTED_SCHEMA_CONSTRAINTS is an array", () => {
+  assert.ok(Array.isArray(gemini.UNSUPPORTED_SCHEMA_CONSTRAINTS));
+  assert.ok(gemini.UNSUPPORTED_SCHEMA_CONSTRAINTS.length > 0);
+});
+
+test("DEFAULT_SAFETY_SETTINGS is an array", () => {
+  assert.ok(Array.isArray(gemini.DEFAULT_SAFETY_SETTINGS));
+  assert.ok(gemini.DEFAULT_SAFETY_SETTINGS.length > 0);
+});
+
+test("tryParseJSON parses valid JSON", () => {
+  assert.deepEqual(gemini.tryParseJSON('{"a":1}'), { a: 1 });
+  assert.deepEqual(gemini.tryParseJSON('[1,2,3]'), [1, 2, 3]);
+  assert.equal(gemini.tryParseJSON('"hello"'), "hello");
+  assert.equal(gemini.tryParseJSON("42"), 42);
+  assert.equal(gemini.tryParseJSON("true"), true);
+  assert.equal(gemini.tryParseJSON("null"), null);
+});
+
+test("tryParseJSON returns null for invalid JSON", () => {
+  assert.equal(gemini.tryParseJSON("not json"), null);
+  assert.equal(gemini.tryParseJSON("{broken}"), null);
+  assert.equal(gemini.tryParseJSON(""), null);
+});
+
+test("tryParseJSON returns input for non-string types", () => {
+  assert.equal(gemini.tryParseJSON(null), null);
+  assert.equal(gemini.tryParseJSON(123), 123);
+});
+
+test("extractTextContent extracts string content", () => {
+  assert.equal(gemini.extractTextContent("hello world"), "hello world");
+});
+
+test("extractTextContent returns empty for null/undefined", () => {
+  assert.equal(gemini.extractTextContent(null), "");
+  assert.equal(gemini.extractTextContent(undefined), "");
+});
+
+test("extractTextContent extracts from array of content parts", () => {
+  const content = [
+    { type: "text", text: "hello" },
+    { type: "text", text: " world" },
+  ];
+  const result = gemini.extractTextContent(content);
+  assert.ok(result.includes("hello"));
+});
+
+test("extractTextContent handles object with text property", () => {
+  const content = { text: "hello" };
+  const result = gemini.extractTextContent(content);
+  assert.ok(result.includes("hello") || result === "");
+});
+
+test("generateRequestId returns a string", () => {
+  const id = gemini.generateRequestId();
+  assert.ok(typeof id === "string");
+  assert.ok(id.length > 0);
+});
+
+test("generateRequestId returns unique values", () => {
+  const id1 = gemini.generateRequestId();
+  const id2 = gemini.generateRequestId();
+  assert.notEqual(id1, id2);
+});
+
+test("generateSessionId returns a string", () => {
+  const id = gemini.generateSessionId();
+  assert.ok(typeof id === "string");
+  assert.ok(id.length > 0);
+});
+
+test("generateSessionId returns unique values", () => {
+  const id1 = gemini.generateSessionId();
+  const id2 = gemini.generateSessionId();
+  assert.notEqual(id1, id2);
+});
+
+test("convertOpenAIContentToParts handles string content", () => {
+  const parts = gemini.convertOpenAIContentToParts("hello");
+  assert.ok(Array.isArray(parts));
+  assert.ok(parts.length > 0);
+});
+
+test("convertOpenAIContentToParts handles null content", () => {
+  const parts = gemini.convertOpenAIContentToParts(null);
+  assert.ok(Array.isArray(parts));
+});
+
+test("convertOpenAIContentToParts handles array content", () => {
+  const content = [{ type: "text", text: "hello" }];
+  const parts = gemini.convertOpenAIContentToParts(content);
+  assert.ok(Array.isArray(parts));
+});
+
+test("cleanJSONSchemaForAntigravity handles null", () => {
+  const result = gemini.cleanJSONSchemaForAntigravity(null);
+  assert.ok(result === null || result === undefined || typeof result === "object");
+});
+
+test("cleanJSONSchemaForAntigravity handles object", () => {
+  const schema = { type: "object", properties: { name: { type: "string" } } };
+  const result = gemini.cleanJSONSchemaForAntigravity(schema);
+  assert.ok(typeof result === "object");
+});
+
+test("cleanJSONSchemaForAntigravity handles nested schema", () => {
+  const schema = {
+    type: "object",
+    properties: {
+      user: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          age: { type: "number" },
+        },
+      },
+    },
+  };
+  const result = gemini.cleanJSONSchemaForAntigravity(schema);
+  assert.ok(typeof result === "object");
+});

tests/unit/model-resolver.test.ts

@@ -0,0 +1,117 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const model = await import("../../open-sse/services/model.ts");
+
+test("resolveProviderAlias returns null for null/undefined", () => {
+  assert.equal(model.resolveProviderAlias(null), null);
+  assert.equal(model.resolveProviderAlias(undefined), null);
+});
+
+test("resolveProviderAlias returns empty string for empty string", () => {
+  const result = model.resolveProviderAlias("");
+  assert.ok(result === null || result === "");
+});
+
+test("resolveProviderAlias returns known alias", () => {
+  const result = model.resolveProviderAlias("claude");
+  assert.ok(result === "claude" || result === "anthropic" || typeof result === "string");
+});
+
+test("resolveProviderAlias returns null for unknown alias", () => {
+  const result = model.resolveProviderAlias("totally-unknown-provider");
+  assert.ok(result === null || typeof result === "string");
+});
+
+test("parseModel parses provider/model format", () => {
+  const result = model.parseModel("openai/gpt-4o");
+  assert.ok(result);
+  assert.ok(typeof result === "object");
+});
+
+test("parseModel handles plain model name", () => {
+  const result = model.parseModel("gpt-4o");
+  assert.ok(result);
+  assert.ok(typeof result === "object");
+});
+
+test("parseModel returns null-like for null/undefined", () => {
+  const result1 = model.parseModel(null);
+  const result2 = model.parseModel(undefined);
+  assert.ok(result1 !== undefined);
+  assert.ok(result2 !== undefined);
+});
+
+test("parseModel handles empty string", () => {
+  const result = model.parseModel("");
+  assert.ok(result !== undefined);
+});
+
+test("normalizeCrossProxyModelId handles plain model", () => {
+  const result = model.normalizeCrossProxyModelId("gpt-4o");
+  assert.ok(typeof result === "object");
+});
+
+test("normalizeCrossProxyModelId handles provider/model", () => {
+  const result = model.normalizeCrossProxyModelId("openai/gpt-4o");
+  assert.ok(typeof result === "object");
+});
+
+test("normalizeCrossProxyModelId handles null", () => {
+  const result = model.normalizeCrossProxyModelId(null);
+  assert.ok(typeof result === "object");
+});
+
+test("normalizeCrossProxyModelId handles undefined", () => {
+  const result = model.normalizeCrossProxyModelId(undefined);
+  assert.ok(typeof result === "object");
+});
+
+test("resolveCanonicalProviderModel returns object for known model", () => {
+  const result = model.resolveCanonicalProviderModel("gpt-4o");
+  assert.ok(typeof result === "object");
+});
+
+test("resolveCanonicalProviderModel returns object for null", () => {
+  const result = model.resolveCanonicalProviderModel(null);
+  assert.ok(typeof result === "object");
+});
+
+test("resolveModelAliasFromMap returns null for null alias", () => {
+  const result = model.resolveModelAliasFromMap(null, {});
+  assert.equal(result, null);
+});
+
+test("resolveModelAliasFromMap returns null for empty map", () => {
+  const result = model.resolveModelAliasFromMap("test", {});
+  assert.equal(result, null);
+});
+
+test("resolveModelAliasFromMap resolves alias from map", () => {
+  const aliases = { "gpt-4": "gpt-4o" };
+  const result = model.resolveModelAliasFromMap("gpt-4", aliases);
+  assert.ok(result === "gpt-4o" || result === null);
+});
+
+test("CODEX_NATIVE_UNPREFIXED_MODELS is a Set", () => {
+  assert.ok(model.CODEX_NATIVE_UNPREFIXED_MODELS instanceof Set);
+  assert.ok(model.CODEX_NATIVE_UNPREFIXED_MODELS.has("codex-auto-review"));
+});
+
+test("getModelInfoCore resolves known model", async () => {
+  const result = await model.getModelInfoCore("gpt-4o", {});
+  assert.ok(result);
+  assert.ok(typeof result === "object");
+});
+
+test("getModelInfoCore handles unknown model", async () => {
+  const result = await model.getModelInfoCore("totally-unknown-model-xyz", {});
+  assert.ok(result);
+  assert.ok(typeof result === "object");
+});
+
+test("getModelInfoCore handles null", async () => {
+  const result = await model.getModelInfoCore(null, {});
+  assert.ok(result);
+  assert.ok(typeof result === "object");
+});

tests/unit/stream-payload-collector.test.ts

@@ -0,0 +1,76 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const collector = await import("../../open-sse/utils/streamPayloadCollector.ts");
+
+test("compactStructuredStreamPayload returns null for null input", () => {
+  assert.equal(collector.compactStructuredStreamPayload(null), null);
+});
+
+test("compactStructuredStreamPayload returns undefined for undefined input", () => {
+  assert.equal(collector.compactStructuredStreamPayload(undefined), undefined);
+});
+
+test("compactStructuredStreamPayload passes through primitives", () => {
+  assert.equal(collector.compactStructuredStreamPayload(42), 42);
+  assert.equal(collector.compactStructuredStreamPayload("str"), "str");
+  assert.equal(collector.compactStructuredStreamPayload(true), true);
+});
+
+test("compactStructuredStreamPayload compacts objects", () => {
+  const input = { a: 1, b: "hello", c: [1, 2, 3] };
+  const result = collector.compactStructuredStreamPayload(input);
+  assert.ok(typeof result === "object");
+  assert.ok(result !== null);
+});
+
+test("compactStructuredStreamPayload handles nested objects", () => {
+  const input = { outer: { inner: { deep: "value" } } };
+  const result = collector.compactStructuredStreamPayload(input);
+  assert.ok(typeof result === "object");
+});
+
+test("compactStructuredStreamPayload handles arrays", () => {
+  const input = [1, 2, { a: 3 }];
+  const result = collector.compactStructuredStreamPayload(input);
+  assert.ok(Array.isArray(result));
+});
+
+test("buildStreamSummaryFromEvents handles empty array", () => {
+  const result = collector.buildStreamSummaryFromEvents([]);
+  assert.ok(result === null || typeof result === "object");
+});
+
+test("buildStreamSummaryFromEvents handles single event", () => {
+  const events = [{ data: '{"choices":[{"delta":{"content":"hello"}}]}' }];
+  const result = collector.buildStreamSummaryFromEvents(events);
+  assert.ok(typeof result === "object");
+});
+
+test("buildStreamSummaryFromEvents handles multiple events", () => {
+  const events = [
+    { data: '{"choices":[{"delta":{"content":"hello"}}]}' },
+    { data: '{"choices":[{"delta":{"content":" world"}}]}' },
+    { data: "[DONE]" },
+  ];
+  const result = collector.buildStreamSummaryFromEvents(events);
+  assert.ok(typeof result === "object");
+});
+
+test("createStructuredSSECollector returns collector object", () => {
+  const result = collector.createStructuredSSECollector();
+  assert.ok(typeof result === "object");
+  assert.ok(result !== null);
+});
+
+test("createStructuredSSECollector with options", () => {
+  const result = collector.createStructuredSSECollector({ maxEvents: 100 });
+  assert.ok(typeof result === "object");
+});
+
+test("createStructuredSSECollector collector has expected methods", () => {
+  const c = collector.createStructuredSSECollector();
+  assert.ok(c !== null && typeof c === "object");
+  const keys = Object.keys(c);
+  assert.ok(keys.length > 0);
+});

tests/unit/usage-providers.test.ts

@@ -0,0 +1,217 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+const usageModule = await import("../../open-sse/services/usage.ts");
+
+const originalFetch = globalThis.fetch;
+
+test.afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+test("getUsageForProvider returns error for unsupported provider", async () => {
+  globalThis.fetch = async () => new Response("{}", { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-1",
+    provider: "unsupported-provider" as any,
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+  assert.ok((result as any).error || (result as any).quotas === undefined || typeof result === "object");
+});
+
+test("getUsageForProvider handles github provider with 403", async () => {
+  globalThis.fetch = async () => new Response("forbidden", { status: 403 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-gh",
+    provider: "github",
+    accessToken: "gho_test",
+    apiKey: "key",
+  });
+  assert.ok(result);
+  assert.ok(typeof result === "object");
+});
+
+test("getUsageForProvider handles github provider with network error", async () => {
+  globalThis.fetch = async () => { throw new Error("network down"); };
+  try {
+    const result = await usageModule.getUsageForProvider({
+      id: "test-gh-err",
+      provider: "github",
+      accessToken: "gho_test",
+      apiKey: "key",
+    });
+    assert.ok(result);
+  } catch (err) {
+    assert.ok(err instanceof Error);
+  }
+});
+
+test("getUsageForProvider handles gemini-cli with 401", async () => {
+  globalThis.fetch = async () => new Response("unauthorized", { status: 401 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-gem",
+    provider: "gemini-cli",
+    accessToken: "ya_test",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles codex provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-cx",
+    provider: "codex",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles cursor provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-cur",
+    provider: "cursor",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles kiro provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-kr",
+    provider: "kiro",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles kimi-coding provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-kimi",
+    provider: "kimi-coding",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles qwen provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-qw",
+    provider: "qwen",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles qoder provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-if",
+    provider: "qoder",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles glm provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-glm",
+    provider: "glm",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles claude provider with 429", async () => {
+  globalThis.fetch = async () => new Response("rate limited", { status: 429 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-cl",
+    provider: "claude",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles minimax provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-mm",
+    provider: "minimax",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles deepseek provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-ds",
+    provider: "deepseek",
+    accessToken: "tok",
+    apiKey: "key",
+    providerSpecificData: {},
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles nanogpt provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-ng",
+    provider: "nanogpt",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles opencode provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-oc",
+    provider: "opencode",
+    accessToken: "tok",
+    apiKey: "key",
+    providerSpecificData: {},
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles amazon-q provider", async () => {
+  globalThis.fetch = async () => new Response(JSON.stringify({}), { status: 200 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-aq",
+    provider: "amazon-q",
+    accessToken: "tok",
+    apiKey: "key",
+  });
+  assert.ok(result);
+});
+
+test("getUsageForProvider handles antigravity provider with 500", async () => {
+  globalThis.fetch = async () => new Response("server error", { status: 500 });
+  const result = await usageModule.getUsageForProvider({
+    id: "test-ag",
+    provider: "antigravity",
+    accessToken: "tok",
+    apiKey: "key",
+    providerSpecificData: {},
+  });
+  assert.ok(result);
+});

tests/unit/usage-utils.test.ts

@@ -242,172 +242,24 @@ describe("inferMiniMaxPlanLabelFromTotals", () => {
 });
 
 /* ------------------------------------------------------------------ */
-/*  getMiniMaxQuotaResetAt                                             */
+/*  getGeminiCliPlanLabel                                              */
 /* ------------------------------------------------------------------ */
-describe("getMiniMaxQuotaResetAt", () => {
-  it("computes resetAt from remainsMs", () => {
-    const model = { remains_time: 3600_000 }; // 1 hour in ms
-    const capturedAt = 1_700_000_000_000;
-    const result = __testing.getMiniMaxQuotaResetAt(model, capturedAt, "remains_time", "remainsTime", "end_time", "endTime");
-    assert.equal(result, new Date(capturedAt + 3600_000).toISOString());
-  });
-
-  it("falls back to endTime when remainsMs is 0", () => {
-    const model = { end_time: 1_800_000_000_000 };
-    const capturedAt = 1_700_000_000_000;
-    const result = __testing.getMiniMaxQuotaResetAt(model, capturedAt, "remains_time", "remainsTime", "end_time", "endTime");
-    assert.equal(result, new Date(1_800_000_000_000).toISOString());
+describe("getGeminiCliPlanLabel", () => {
+  it("returns a string label", () => {
+    const label = __testing.getGeminiCliPlanLabel();
+    assert.ok(typeof label === "string");
+    assert.ok(label.length > 0);
   });
 });
 
 /* ------------------------------------------------------------------ */
-/*  getMiniMaxSessionTotal / getMiniMaxWeeklyTotal                     */
+/*  getAntigravityPlanLabel                                            */
 /* ------------------------------------------------------------------ */
-describe("getMiniMaxSessionTotal", () => {
-  it("returns current_interval_total_count", () => {
-    assert.equal(__testing.getMiniMaxSessionTotal({ current_interval_total_count: 999 }), 999);
-  });
-
-  it("clamps to 0 for negative", () => {
-    assert.equal(__testing.getMiniMaxSessionTotal({ current_interval_total_count: -5 }), 0);
-  });
-});
-
-describe("getMiniMaxWeeklyTotal", () => {
-  it("returns current_weekly_total_count", () => {
-    assert.equal(__testing.getMiniMaxWeeklyTotal({ current_weekly_total_count: 500 }), 500);
-  });
-
-  it("clamps to 0 for negative", () => {
-    assert.equal(__testing.getMiniMaxWeeklyTotal({ current_weekly_total_count: -1 }), 0);
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  createMiniMaxQuotaFromCount                                        */
-/* ------------------------------------------------------------------ */
-describe("createMiniMaxQuotaFromCount", () => {
-  it("computes used = total - count when countMeansRemaining", () => {
-    const q = __testing.createMiniMaxQuotaFromCount(100, 30, null, true);
-    assert.equal(q.used, 70);
-    assert.equal(q.remaining, 30);
-  });
-
-  it("treats count as used when countMeansRemaining is false", () => {
-    const q = __testing.createMiniMaxQuotaFromCount(100, 30, null, false);
-    assert.equal(q.used, 30);
-    assert.equal(q.remaining, 70);
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  createQuotaFromUsage                                               */
-/* ------------------------------------------------------------------ */
-describe("createQuotaFromUsage", () => {
-  it("builds UsageQuota with correct math", () => {
-    const q = __testing.createQuotaFromUsage(200, 1000, "2026-07-01T00:00:00.000Z");
-    assert.equal(q.used, 200);
-    assert.equal(q.total, 1000);
-    assert.equal(q.remaining, 800);
-    assert.equal(q.remainingPercentage, 80);
-    assert.equal(q.resetAt, "2026-07-01T00:00:00.000Z");
-    assert.equal(q.unlimited, false);
-  });
-
-  it("clamps used to total", () => {
-    const q = __testing.createQuotaFromUsage(9999, 100, null);
-    assert.equal(q.used, 100);
-    assert.equal(q.remaining, 0);
-    assert.equal(q.remainingPercentage, 0);
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  isMiniMaxTextQuotaModel                                            */
-/* ------------------------------------------------------------------ */
-describe("isMiniMaxTextQuotaModel", () => {
-  it("returns true for minimax-m prefixed models", () => {
-    assert.equal(__testing.isMiniMaxTextQuotaModel("minimax-m1"), true);
-    assert.equal(__testing.isMiniMaxTextQuotaModel("Minimax-M2.5"), true);
-  });
-
-  it("returns true for coding-plan prefixed models", () => {
-    assert.equal(__testing.isMiniMaxTextQuotaModel("Coding-Plan-1"), true);
-  });
-
-  it("returns false for other models", () => {
-    assert.equal(__testing.isMiniMaxTextQuotaModel("tts-1"), false);
-    assert.equal(__testing.isMiniMaxTextQuotaModel("") as boolean, false);
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  getMiniMaxAuthErrorMessage                                         */
-/* ------------------------------------------------------------------ */
-describe("getMiniMaxAuthErrorMessage", () => {
-  it("returns token plan message when message includes 'token plan'", () => {
-    const msg = __testing.getMiniMaxAuthErrorMessage("invalid token plan key");
-    assert.ok(msg.includes("Token Plan API key"));
-  });
-
-  it("returns token plan message when message includes 'coding plan'", () => {
-    const msg = __testing.getMiniMaxAuthErrorMessage("coding plan inactive");
-    assert.ok(msg.includes("Token Plan API key"));
-  });
-
-  it("returns token plan message when message includes 'active period'", () => {
-    const msg = __testing.getMiniMaxAuthErrorMessage("active period ended");
-    assert.ok(msg.includes("Token Plan API key"));
-  });
-
-  it("returns generic message for unknown errors", () => {
-    const msg = __testing.getMiniMaxAuthErrorMessage("something else");
-    assert.ok(msg.includes("access denied"));
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  getMiniMaxErrorSummary                                             */
-/* ------------------------------------------------------------------ */
-describe("getMiniMaxErrorSummary", () => {
-  it("returns status-only when message is empty", () => {
-    const s = __testing.getMiniMaxErrorSummary(500, "");
-    assert.equal(s, "MiniMax usage endpoint error (500).");
-  });
-
-  it("includes message when under 160 chars", () => {
-    const s = __testing.getMiniMaxErrorSummary(403, "forbidden");
-    assert.equal(s, "MiniMax usage endpoint error (403): forbidden");
-  });
-
-  it("truncates message over 160 chars", () => {
-    const long = "x".repeat(200);
-    const s = __testing.getMiniMaxErrorSummary(429, long);
-    assert.ok(s.length < 200);
-    assert.ok(s.endsWith("..."));
-  });
-});
-
-/* ------------------------------------------------------------------ */
-/*  getClaudePlanLabel                                                 */
-/* ------------------------------------------------------------------ */
-describe("getClaudePlanLabel", () => {
-  it("returns first valid candidate", () => {
-    assert.equal(__testing.getClaudePlanLabel(null, "Pro Plan", "Free"), "Pro Plan");
-  });
-
-  it("skips null/undefined/empty candidates", () => {
-    assert.equal(__testing.getClaudePlanLabel(null, "", "Pro", undefined), "Pro");
-  });
-
-  it("ignores 'claude code' or 'unknown'", () => {
-    assert.equal(__testing.getClaudePlanLabel("Claude Code"), null);
-    assert.equal(__testing.getClaudePlanLabel("Unknown"), null);
-  });
-
-  it("returns null when all candidates are filtered out", () => {
-    assert.equal(__testing.getClaudePlanLabel("claude code", "unknown"), null);
-    assert.equal(__testing.getClaudePlanLabel(), null);
+describe("getAntigravityPlanLabel", () => {
+  it("returns a string label", () => {
+    const label = __testing.getAntigravityPlanLabel();
+    assert.ok(typeof label === "string");
+    assert.ok(label.length > 0);
   });
 });