@polderlabs/bizar 4.4.13 → 4.5.0

package/bizar-dash/tests/providers-store-backup-keys.node.test.mjs

@@ -147,11 +147,11 @@ describe('providers-store — backup keys (v3.20.10)', () => {
         provider: {
           minimax: {
             apiKey: '',
-            backupApiKey: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+            backupApiKey: 'sk-cp-bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
           },
         },
       });
-      process.env.MINIMAX_API_KEY = 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb';
+      process.env.MINIMAX_API_KEY = 'sk-cp-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
 
       const store = await loadStore();
       const results = await store.autoDetect({ probe: false });
@@ -198,7 +198,7 @@ describe('providers-store — backup keys (v3.20.10)', () => {
 
     it('allows backup without primary (rotation in progress)', async () => {
       // No primary key — only backup env var.
-      process.env.MINIMAX_API_KEY_BACKUP = 'iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii';
+      process.env.MINIMAX_API_KEY_BACKUP = 'sk-cp-iiiiiiiiiiiiiiiiiiiiiiiiiiiiiii';
 
       const store = await loadStore();
       const results = await store.autoDetect({ probe: false });
@@ -330,4 +330,480 @@ describe('providers-store — backup keys (v3.20.10)', () => {
       assert.match(minimax.backupApiKey, /^mm\.\.\.mm$/);
     });
   });
+
+  // ── v4.6.0 keys[] array rotation / cooldown tests ────────────────────
+  //
+  // These cover the new top-level exports from providers-store.mjs:
+  //   - getActiveKey(providerId)
+  //   - markKeyError(providerId, envVar, error)
+  //   - markKeySuccess(providerId, envVar)
+  //   - rotateKey(providerId)
+  //   - addBackupKey(providerId, envVar, label)
+  //   - removeBackupKey(providerId, envVar)
+  //   - setKeyStatus(providerId, envVar, status)
+  //   - withKeyRotation(providerId, fn, opts)
+  //   - isRetryableError(err)
+  //
+  // All of these work against the v4.6.0 keys[] array shape and the
+  // legacy apiKey/backupApiKey fields are kept in sync via
+  // syncLegacyKeys() on writes.
+
+  describe('v4.6.0 — keys[] array migration from legacy', () => {
+    beforeEach(async () => {
+      delete process.env.MINIMAX_API_KEY;
+      delete process.env.MINIMAX_API_KEY_BACKUP;
+      await resetOpencodeJson();
+    });
+
+    it('legacy apiKey is exposed as a keys[] entry on list()', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        apiKey: 'sk-cp-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+      });
+      const list = store.list();
+      const minimax = list.find((p) => p.id === 'minimax');
+      assert.ok(Array.isArray(minimax.keys));
+      assert.equal(minimax.keys.length, 1);
+      assert.equal(minimax.keys[0].label, 'Primary');
+      assert.equal(minimax.keys[0].status, 'active');
+    });
+
+    it('legacy apiKey + backupApiKey becomes a 2-entry keys[]', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        apiKey: 'sk-cp-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        backupApiKey: 'sk-cp-bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+      });
+      const list = store.list();
+      const minimax = list.find((p) => p.id === 'minimax');
+      assert.equal(minimax.keys.length, 2);
+      assert.equal(minimax.keys[0].label, 'Primary');
+      assert.equal(minimax.keys[0].status, 'active');
+      assert.equal(minimax.keys[1].label, 'Backup');
+      assert.equal(minimax.keys[1].status, 'standby');
+    });
+
+    it('caller-provided keys[] is preserved verbatim', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Work laptop', status: 'active' },
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Home', status: 'standby' },
+        ],
+      });
+      const list = store.list();
+      const minimax = list.find((p) => p.id === 'minimax');
+      assert.equal(minimax.keys.length, 2);
+      assert.equal(minimax.keys[0].envVar, 'BIZAR_MINIMAX_KEY');
+      assert.equal(minimax.keys[0].status, 'active');
+      assert.equal(minimax.keys[1].envVar, 'BIZAR_MINIMAX_BACKUP');
+      assert.equal(minimax.keys[1].status, 'standby');
+    });
+  });
+
+  describe('v4.6.0 — getActiveKey', () => {
+    beforeEach(async () => {
+      delete process.env.MINIMAX_API_KEY;
+      delete process.env.MINIMAX_API_KEY_BACKUP;
+      await resetOpencodeJson();
+    });
+
+    it('returns null when the provider does not exist', async () => {
+      const store = await loadStore();
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=getActive-1');
+      assert.equal(mod.getActiveKey('nonexistent'), null);
+    });
+
+    it('returns null when the provider has no keys', async () => {
+      const store = await loadStore();
+      await store.add({ id: 'minimax', name: 'MiniMax' });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=getActive-2');
+      assert.equal(mod.getActiveKey('minimax'), null);
+    });
+
+    it('returns the active key with the env value resolved', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Backup', status: 'standby' },
+        ],
+      });
+      process.env.BIZAR_MINIMAX_KEY = 'sk-cp-active-value';
+      process.env.BIZAR_MINIMAX_BACKUP = 'sk-cp-backup-value';
+
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=getActive-3');
+      const active = mod.getActiveKey('minimax');
+      assert.ok(active);
+      assert.equal(active.envVar, 'BIZAR_MINIMAX_KEY');
+      assert.equal(active.label, 'Primary');
+      assert.equal(active.status, 'active');
+      assert.equal(active.key, 'sk-cp-active-value');
+      delete process.env.BIZAR_MINIMAX_KEY;
+      delete process.env.BIZAR_MINIMAX_BACKUP;
+    });
+
+    it('falls back to standby when active is missing', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Backup', status: 'standby' },
+        ],
+      });
+      process.env.BIZAR_MINIMAX_BACKUP = 'sk-cp-backup-only';
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=getActive-4');
+      const active = mod.getActiveKey('minimax');
+      assert.equal(active.envVar, 'BIZAR_MINIMAX_BACKUP');
+      assert.equal(active.status, 'standby');
+      delete process.env.BIZAR_MINIMAX_BACKUP;
+    });
+  });
+
+  describe('v4.6.0 — markKeyError', () => {
+    beforeEach(async () => {
+      delete process.env.MINIMAX_API_KEY;
+      delete process.env.MINIMAX_API_KEY_BACKUP;
+      await resetOpencodeJson();
+    });
+
+    it('records errorCount + lastError on the named envVar', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+        ],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=markErr-1');
+      mod.markKeyError('minimax', 'BIZAR_MINIMAX_KEY', new Error('http_429 too many requests'));
+      const list = store.list();
+      const minimax = list.find((p) => p.id === 'minimax');
+      assert.equal(minimax.keys[0].errorCount, 1);
+      assert.match(minimax.keys[0].lastError, /http_429/);
+      assert.equal(minimax.keys[0].status, 'active'); // below threshold
+    });
+
+    it('demotes to cooldown after ERROR_COOLDOWN_THRESHOLD errors', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+        ],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=markErr-2');
+      // Threshold is 3
+      mod.markKeyError('minimax', 'BIZAR_MINIMAX_KEY', 'err1');
+      mod.markKeyError('minimax', 'BIZAR_MINIMAX_KEY', 'err2');
+      const afterTwo = store.list().find((p) => p.id === 'minimax').keys[0];
+      assert.equal(afterTwo.errorCount, 2);
+      assert.equal(afterTwo.status, 'active'); // still below
+      mod.markKeyError('minimax', 'BIZAR_MINIMAX_KEY', 'err3');
+      const afterThree = store.list().find((p) => p.id === 'minimax').keys[0];
+      assert.equal(afterThree.errorCount, 3);
+      assert.equal(afterThree.status, 'cooldown');
+    });
+
+    it('is a no-op for unknown envVars', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [{ envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' }],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=markErr-3');
+      const result = mod.markKeyError('minimax', 'NONEXISTENT_ENV', 'err');
+      assert.equal(result, null);
+      const list = store.list();
+      assert.equal(list.find((p) => p.id === 'minimax').keys[0].errorCount, 0);
+    });
+  });
+
+  describe('v4.6.0 — rotateKey', () => {
+    beforeEach(async () => {
+      delete process.env.MINIMAX_API_KEY;
+      delete process.env.MINIMAX_API_KEY_BACKUP;
+      await resetOpencodeJson();
+    });
+
+    it('promotes the next standby key', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Backup', status: 'standby' },
+        ],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=rotate-1');
+      const rotated = mod.rotateKey('minimax');
+      assert.ok(rotated);
+      assert.equal(rotated.envVar, 'BIZAR_MINIMAX_BACKUP');
+      const list = store.list();
+      const minimax = list.find((p) => p.id === 'minimax');
+      assert.equal(minimax.keys[0].status, 'disabled');
+      assert.equal(minimax.keys[1].status, 'active');
+    });
+
+    it('returns null when no rotation target exists', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [{ envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' }],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=rotate-2');
+      const rotated = mod.rotateKey('minimax');
+      assert.equal(rotated, null);
+    });
+  });
+
+  describe('v4.6.0 — addBackupKey / removeBackupKey', () => {
+    beforeEach(async () => {
+      delete process.env.MINIMAX_API_KEY;
+      delete process.env.MINIMAX_API_KEY_BACKUP;
+      await resetOpencodeJson();
+    });
+
+    it('addBackupKey appends a new standby key', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [{ envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' }],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=addRm-1');
+      const inserted = mod.addBackupKey('minimax', 'BIZAR_MINIMAX_BACKUP', 'Personal');
+      assert.equal(inserted.envVar, 'BIZAR_MINIMAX_BACKUP');
+      assert.equal(inserted.status, 'standby');
+      assert.equal(inserted.label, 'Personal');
+      const list = store.list().find((p) => p.id === 'minimax');
+      assert.equal(list.keys.length, 2);
+    });
+
+    it('addBackupKey rejects duplicate envVar', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [{ envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' }],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=addRm-2');
+      assert.throws(() => mod.addBackupKey('minimax', 'BIZAR_MINIMAX_KEY', 'dup'), /already exists/);
+    });
+
+    it('removeBackupKey refuses to remove the last key', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [{ envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' }],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=addRm-3');
+      assert.throws(() => mod.removeBackupKey('minimax', 'BIZAR_MINIMAX_KEY'), /last key/);
+    });
+
+    it('removeBackupKey removes a non-last key', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Backup', status: 'standby' },
+        ],
+      });
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=addRm-4');
+      const ok = mod.removeBackupKey('minimax', 'BIZAR_MINIMAX_BACKUP');
+      assert.equal(ok, true);
+      const list = store.list().find((p) => p.id === 'minimax');
+      assert.equal(list.keys.length, 1);
+      assert.equal(list.keys[0].envVar, 'BIZAR_MINIMAX_KEY');
+    });
+  });
+
+  describe('v4.6.0 — withKeyRotation', () => {
+    beforeEach(async () => {
+      delete process.env.MINIMAX_API_KEY;
+      delete process.env.MINIMAX_API_KEY_BACKUP;
+      await resetOpencodeJson();
+    });
+
+    it('returns the fn result on first success', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Backup', status: 'standby' },
+        ],
+      });
+      process.env.BIZAR_MINIMAX_KEY = 'sk-cp-primary';
+      process.env.BIZAR_MINIMAX_BACKUP = 'sk-cp-backup';
+
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=rot-fn-1');
+      const result = await mod.withKeyRotation('minimax', async (key, envVar) => {
+        assert.equal(key, 'sk-cp-primary');
+        assert.equal(envVar, 'BIZAR_MINIMAX_KEY');
+        return 'ok';
+      });
+      assert.equal(result, 'ok');
+
+      delete process.env.BIZAR_MINIMAX_KEY;
+      delete process.env.BIZAR_MINIMAX_BACKUP;
+    });
+
+    it('retries on retryable errors (429) and rotates to backup', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Backup', status: 'standby' },
+        ],
+      });
+      process.env.BIZAR_MINIMAX_KEY = 'sk-cp-primary';
+      process.env.BIZAR_MINIMAX_BACKUP = 'sk-cp-backup';
+
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=rot-fn-2');
+      let callCount = 0;
+      const result = await mod.withKeyRotation('minimax', async (key, envVar) => {
+        callCount++;
+        if (callCount === 1) {
+          // Primary key gets 429
+          const e = new Error('rate limit');
+          e.status = 429;
+          throw e;
+        }
+        assert.equal(key, 'sk-cp-backup');
+        assert.equal(envVar, 'BIZAR_MINIMAX_BACKUP');
+        return 'rotated';
+      });
+      assert.equal(result, 'rotated');
+      assert.equal(callCount, 2);
+
+      // Verify the primary was errored and rotated
+      const list = store.list().find((p) => p.id === 'minimax');
+      const primary = list.keys.find((k) => k.envVar === 'BIZAR_MINIMAX_KEY');
+      assert.ok(primary);
+      assert.ok(primary.errorCount >= 1);
+      assert.equal(primary.status, 'disabled'); // rotated away
+
+      delete process.env.BIZAR_MINIMAX_KEY;
+      delete process.env.BIZAR_MINIMAX_BACKUP;
+    });
+
+    it('does NOT rotate on non-retryable errors', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Backup', status: 'standby' },
+        ],
+      });
+      process.env.BIZAR_MINIMAX_KEY = 'sk-cp-primary';
+      process.env.BIZAR_MINIMAX_BACKUP = 'sk-cp-backup';
+
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=rot-fn-3');
+      await assert.rejects(async () => {
+        await mod.withKeyRotation('minimax', async () => {
+          const e = new Error('ECONNRESET fetch failed');
+          throw e;
+        });
+      }, /ECONNRESET/);
+
+      // No rotation should have happened
+      const list = store.list().find((p) => p.id === 'minimax');
+      const primary = list.keys.find((k) => k.envVar === 'BIZAR_MINIMAX_KEY');
+      assert.equal(primary.status, 'active');
+
+      delete process.env.BIZAR_MINIMAX_KEY;
+      delete process.env.BIZAR_MINIMAX_BACKUP;
+    });
+
+    it('throws rotation_exhausted when all keys fail', async () => {
+      const store = await loadStore();
+      await store.add({
+        id: 'minimax',
+        name: 'MiniMax',
+        keys: [
+          { envVar: 'BIZAR_MINIMAX_KEY', label: 'Primary', status: 'active' },
+          { envVar: 'BIZAR_MINIMAX_BACKUP', label: 'Backup', status: 'standby' },
+        ],
+      });
+      process.env.BIZAR_MINIMAX_KEY = 'sk-cp-primary';
+      process.env.BIZAR_MINIMAX_BACKUP = 'sk-cp-backup';
+
+      const mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=rot-fn-4');
+      await assert.rejects(async () => {
+        await mod.withKeyRotation('minimax', async () => {
+          const e = new Error('http_429 too many');
+          e.status = 429;
+          throw e;
+        });
+      }, (err) => {
+        assert.equal(err.code, 'rotation_exhausted');
+        assert.equal(err.attempts, 2);
+        return true;
+      });
+
+      delete process.env.BIZAR_MINIMAX_KEY;
+      delete process.env.BIZAR_MINIMAX_BACKUP;
+    });
+  });
+
+  describe('v4.6.0 — isRetryableError', () => {
+    let mod;
+    before(async () => {
+      mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + '?cb=retry-1');
+    });
+
+    it('treats HTTP 401/403 as retryable', () => {
+      assert.equal(mod.isRetryableError({ status: 401 }), true);
+      assert.equal(mod.isRetryableError({ status: 403 }), true);
+    });
+    it('treats HTTP 429 as retryable', () => {
+      assert.equal(mod.isRetryableError({ status: 429 }), true);
+    });
+    it('treats 5xx as retryable', () => {
+      assert.equal(mod.isRetryableError({ status: 500 }), true);
+      assert.equal(mod.isRetryableError({ status: 502 }), true);
+      assert.equal(mod.isRetryableError({ status: 503 }), true);
+      assert.equal(mod.isRetryableError({ status: 599 }), true);
+    });
+    it('treats minimax-style http_NNN error code as retryable', () => {
+      assert.equal(mod.isRetryableError({ error: 'http_429', status: 429 }), true);
+      assert.equal(mod.isRetryableError({ error: 'http_503' }), true);
+    });
+    it('does NOT treat network errors as retryable', () => {
+      assert.equal(mod.isRetryableError(new Error('ECONNRESET')), false);
+      assert.equal(mod.isRetryableError(new Error('fetch failed')), false);
+      assert.equal(mod.isRetryableError(new Error('AbortError')), false);
+    });
+    it('does NOT treat 4xx-other (400/404/422) as retryable', () => {
+      assert.equal(mod.isRetryableError({ status: 400 }), false);
+      assert.equal(mod.isRetryableError({ status: 404 }), false);
+      assert.equal(mod.isRetryableError({ status: 422 }), false);
+    });
+    it('handles quota/rate-limit messages', () => {
+      assert.equal(mod.isRetryableError(new Error('rate limit exceeded')), true);
+      assert.equal(mod.isRetryableError(new Error('insufficient credits')), true);
+    });
+  });
 });

package/bizar-dash/tests/providers-store-search.node.test.mjs

@@ -0,0 +1,166 @@
+/**
+ * providers-store-search.node.test.mjs — fuzzy search across the v4.6.0
+ * provider catalog.
+ *
+ * The catalog (`PROVIDER_CATALOG` in providers-store.mjs) is the curated
+ * list surfaced by the dashboard's "Add provider" wizard. The wizard
+ * shows a search box; typing a query should narrow the list down.
+ *
+ * Run with: node --test tests/providers-store-search.node.test.mjs
+ */
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { resolve } from 'node:path';
+
+const REPO = resolve(import.meta.dirname, '..', '..');
+
+let mod;
+before(async () => {
+  const cacheBust = '?cb=' + Date.now() + '-' + Math.random().toString(36).slice(2);
+  mod = await import(join(REPO, 'bizar-dash/src/server/providers-store.mjs') + cacheBust);
+});
+
+import { join } from 'node:path';
+
+describe('PROVIDER_CATALOG (v4.6.0)', () => {
+  it('exports a frozen catalog with at least 11 entries', () => {
+    assert.ok(Array.isArray(mod.PROVIDER_CATALOG));
+    assert.ok(Object.isFrozen(mod.PROVIDER_CATALOG));
+    assert.ok(mod.PROVIDER_CATALOG.length >= 11,
+      `expected at least 11 catalog entries, got ${mod.PROVIDER_CATALOG.length}`);
+  });
+
+  it('each entry has the wizard-facing fields', () => {
+    for (const e of mod.PROVIDER_CATALOG) {
+      assert.equal(typeof e.id, 'string', `${e.id} id not string`);
+      assert.ok(e.id.length > 0);
+      assert.equal(typeof e.name, 'string');
+      assert.ok(e.name.length > 0);
+      assert.equal(typeof e.baseURL, 'string');
+      assert.equal(e.keyPattern instanceof RegExp, true, `${e.id} keyPattern not a RegExp`);
+      assert.equal(typeof e.keyHint, 'string', `${e.id} keyHint not string`);
+      assert.equal(typeof e.docs, 'string', `${e.id} docs not string`);
+      assert.ok(Array.isArray(e.models), `${e.id} models not array`);
+      assert.equal(typeof e.requiresKey, 'boolean', `${e.id} requiresKey not boolean`);
+      assert.ok(Object.isFrozen(e), `${e.id} entry not frozen`);
+    }
+  });
+
+  it('contains the headline providers we expect', () => {
+    const ids = mod.PROVIDER_CATALOG.map((p) => p.id);
+    for (const expected of ['opencode', 'anthropic', 'openai', 'google', 'minimax', 'groq', 'mistral', 'cohere', 'ollama', 'lmstudio', 'custom']) {
+      assert.ok(ids.includes(expected), `catalog missing ${expected}`);
+    }
+  });
+
+  it('local providers (ollama, lmstudio) have requiresKey=false', () => {
+    const ollama = mod.findCatalogEntry('ollama');
+    const lmstudio = mod.findCatalogEntry('lmstudio');
+    assert.equal(ollama.requiresKey, false);
+    assert.equal(lmstudio.requiresKey, false);
+  });
+
+  it('cloud providers have requiresKey=true', () => {
+    const anthropic = mod.findCatalogEntry('anthropic');
+    const minimax = mod.findCatalogEntry('minimax');
+    assert.equal(anthropic.requiresKey, true);
+    assert.equal(minimax.requiresKey, true);
+  });
+
+  it('MiniMax keyPattern accepts sk-cp-, sk-ant-, sk-or-', () => {
+    const minimax = mod.findCatalogEntry('minimax');
+    assert.ok(minimax.keyPattern.test('sk-cp-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'));
+    assert.ok(minimax.keyPattern.test('sk-ant-aaaaaaaaaaaaaaaaaaaaaaaaaaaaa'));
+    assert.ok(minimax.keyPattern.test('sk-or-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'));
+    assert.equal(minimax.keyPattern.test('sk-bogus-aaaaaaaaaaaaaaaaaaaaaaaaaa'), false);
+    assert.equal(minimax.keyPattern.test('not-a-key'), false);
+  });
+});
+
+describe('listCatalog (v4.6.0)', () => {
+  it('returns the public shape (no keyPattern)', () => {
+    const result = mod.listCatalog();
+    assert.ok(Array.isArray(result));
+    assert.equal(result.length, mod.PROVIDER_CATALOG.length);
+    for (const e of result) {
+      assert.equal('keyPattern' in e, false, 'listCatalog leaked keyPattern');
+      assert.equal(typeof e.id, 'string');
+      assert.equal(typeof e.name, 'string');
+      assert.equal(typeof e.baseURL, 'string');
+      assert.equal(typeof e.keyHint, 'string');
+      assert.equal(typeof e.docs, 'string');
+      assert.ok(Array.isArray(e.models));
+    }
+  });
+});
+
+describe('searchProviders (v4.6.0)', () => {
+  it('empty query returns full catalog', () => {
+    const result = mod.searchProviders('');
+    assert.equal(result.length, mod.PROVIDER_CATALOG.length);
+  });
+
+  it('exact id match ranks first', () => {
+    const result = mod.searchProviders('minimax');
+    assert.ok(result.length > 0);
+    assert.equal(result[0].id, 'minimax');
+    assert.ok(result[0].score >= 100);
+  });
+
+  it('fuzzy id prefix match finds minimax when typing "mini"', () => {
+    const result = mod.searchProviders('mini');
+    const ids = result.map((r) => r.id);
+    assert.ok(ids.includes('minimax'));
+  });
+
+  it('name match: "GPT" finds openai/opencode (curated names)', () => {
+    const result = mod.searchProviders('claude');
+    const ids = result.map((r) => r.id);
+    assert.ok(ids.includes('anthropic'));
+  });
+
+  it('docs URL match: "openrouter" finds openrouter', () => {
+    const result = mod.searchProviders('openrouter');
+    const ids = result.map((r) => r.id);
+    assert.ok(ids.includes('openrouter'));
+  });
+
+  it('non-matching query returns empty array', () => {
+    const result = mod.searchProviders('xyzzy-no-such-provider-xyzzy');
+    assert.equal(result.length, 0);
+  });
+
+  it('respects limit option', () => {
+    const result = mod.searchProviders('', { limit: 3 });
+    assert.ok(result.length <= 3);
+  });
+
+  it('does not leak keyPattern in results', () => {
+    const result = mod.searchProviders('openai');
+    for (const r of result) {
+      assert.equal('keyPattern' in r, false);
+    }
+  });
+
+  it('finds ollama and lmstudio via "local" docs URL match', () => {
+    const result = mod.searchProviders('local');
+    const ids = result.map((r) => r.id);
+    assert.ok(ids.includes('ollama'));
+    assert.ok(ids.includes('lmstudio'));
+  });
+});
+
+describe('findCatalogEntry (v4.6.0)', () => {
+  it('returns the entry for known ids', () => {
+    const e = mod.findCatalogEntry('anthropic');
+    assert.ok(e);
+    assert.equal(e.id, 'anthropic');
+  });
+  it('returns null for unknown ids', () => {
+    assert.equal(mod.findCatalogEntry('not-a-real-provider'), null);
+  });
+  it('returns null for falsy input', () => {
+    assert.equal(mod.findCatalogEntry(''), null);
+    assert.equal(mod.findCatalogEntry(null), null);
+  });
+});