@sanqianx/project-knowledge 5.0.24 → 5.0.25

package/_site/_test/ai-profile-resolver-test.js

@@ -1,137 +1,137 @@
-// _site/_test/ai-profile-resolver-test.js
-//
-// Tests for the shared effective AI profile resolver. The resolver is the
-// single source of truth for "which AI profile does this project use right
-// now" — replacing the inconsistent fallback logic that used to live in
-// Workbench start-session / send-input, the analyzer, the CommitReconciler,
-// and import default assignment.
-//
-// Resolution order (per T01):
-//   1. projectConfig.aiProfileId when usable
-//   2. settings.ai.defaultProfileId when usable
-//   3. first usable configured profile in stable configured order
-//   4. otherwise AI_PROFILE_REQUIRED
-
-const assert = require('assert');
-const { resolveEffectiveAiProfile, isUsable, profileById } = require('../lib/ai-profile-resolver');
-
-const PROFILE_A = { id: 'profile-a', name: 'A', enabled: true, vendor: 'anthropic', model: 'm' };
-const PROFILE_B = { id: 'profile-b', name: 'B', enabled: true, vendor: 'anthropic', model: 'm' };
-const PROFILE_DISABLED = { id: 'profile-disabled', name: 'Disabled', enabled: false, vendor: 'anthropic', model: 'm' };
-const PROFILE_ENABLED_UNDEFINED = { id: 'profile-default-enabled', name: 'DefaultEnabled', vendor: 'anthropic', model: 'm' };
-
-function settings(profiles, defaultProfileId) {
-  return { ai: { schema: 'ai-profiles/v1', profiles, defaultProfileId: defaultProfileId || null } };
-}
-
-(async () => {
-  // ---- Case 1: explicit project profile is preferred ----
-  {
-    const s = settings([PROFILE_A, PROFILE_B], 'profile-b');
-    const r = resolveEffectiveAiProfile(s, { aiProfileId: 'profile-a' });
-    assert.strictEqual(r.source, 'project');
-    assert.strictEqual(r.profileId, 'profile-a');
-    assert.strictEqual(r.profile.id, 'profile-a');
-  }
-
-  // ---- Case 2: default profile fallback when project has none ----
-  {
-    const s = settings([PROFILE_A, PROFILE_B], 'profile-b');
-    const r = resolveEffectiveAiProfile(s, { aiProfileId: null });
-    assert.strictEqual(r.source, 'default');
-    assert.strictEqual(r.profileId, 'profile-b');
-  }
-
-  // ---- Case 3: first-usable fallback when default is missing/disabled ----
-  {
-    const s = settings([PROFILE_DISABLED, PROFILE_A, PROFILE_B], 'profile-disabled');
-    const r = resolveEffectiveAiProfile(s, { aiProfileId: null });
-    assert.strictEqual(r.source, 'first-usable');
-    assert.strictEqual(r.profileId, 'profile-a');
-  }
-
-  // ---- Case 4: stale project profile id falls back safely ----
-  {
-    const s = settings([PROFILE_A, PROFILE_B], 'profile-b');
-    const r = resolveEffectiveAiProfile(s, { aiProfileId: 'profile-deleted' });
-    assert.strictEqual(r.source, 'default');
-    assert.strictEqual(r.profileId, 'profile-b');
-  }
-
-  // ---- Case 5: disabled project profile falls back to default ----
-  {
-    const s = settings([PROFILE_DISABLED, PROFILE_B], 'profile-b');
-    const r = resolveEffectiveAiProfile(s, { aiProfileId: 'profile-disabled' });
-    assert.strictEqual(r.source, 'default');
-    assert.strictEqual(r.profileId, 'profile-b');
-  }
-
-  // ---- Case 6: no usable profile produces one clear error ----
-  {
-    const s = settings([PROFILE_DISABLED], null);
-    let threw = null;
-    try { resolveEffectiveAiProfile(s, { aiProfileId: null }); }
-    catch (error) { threw = error; }
-    assert(threw, 'resolver must throw when no usable profile exists');
-    assert.strictEqual(threw.code, 'AI_PROFILE_REQUIRED');
-    assert.strictEqual(threw.status, 409);
-    assert(threw.details && typeof threw.details.hint === 'string');
-  }
-
-  // ---- Case 7: enabled=undefined (legacy profiles) is treated as usable ----
-  {
-    const s = settings([PROFILE_ENABLED_UNDEFINED], 'profile-default-enabled');
-    const r = resolveEffectiveAiProfile(s, { aiProfileId: null });
-    assert.strictEqual(r.source, 'default');
-    assert.strictEqual(r.profileId, 'profile-default-enabled');
-  }
-
-  // ---- Case 8: empty settings produces AI_PROFILE_REQUIRED ----
-  {
-    let threw = null;
-    try { resolveEffectiveAiProfile({ ai: { profiles: [] } }, { aiProfileId: null }); }
-    catch (error) { threw = error; }
-    assert(threw, 'empty settings must throw AI_PROFILE_REQUIRED');
-    assert.strictEqual(threw.code, 'AI_PROFILE_REQUIRED');
-  }
-
-  // ---- Case 9: null/undefined inputs are tolerated ----
-  {
-    const r = resolveEffectiveAiProfile({ ai: { profiles: [PROFILE_A] } }, null);
-    assert.strictEqual(r.source, 'first-usable');
-    assert.strictEqual(r.profileId, 'profile-a');
-  }
-
-  // ---- Case 10: isUsable + profileById helpers ----
-  {
-    assert.strictEqual(isUsable(PROFILE_A), true);
-    assert.strictEqual(isUsable(PROFILE_DISABLED), false);
-    assert.strictEqual(isUsable(null), false);
-    const s = settings([PROFILE_A, PROFILE_B]);
-    assert.strictEqual(profileById(s, 'profile-a').id, 'profile-a');
-    assert.strictEqual(profileById(s, 'profile-unknown'), null);
-    assert.strictEqual(profileById(s, ''), null);
-  }
-
-  // ---- Case 11: deterministic first-usable order ----
-  {
-    const s = settings([PROFILE_A, PROFILE_B], null);
-    const r1 = resolveEffectiveAiProfile(s, { aiProfileId: null });
-    const r2 = resolveEffectiveAiProfile(s, { aiProfileId: null });
-    assert.strictEqual(r1.profileId, 'profile-a');
-    assert.strictEqual(r2.profileId, 'profile-a');
-  }
-
-  // ---- Case 12: default profile that is enabled=undefined still wins over first-usable ----
-  {
-    const s = settings([PROFILE_A, PROFILE_ENABLED_UNDEFINED], 'profile-default-enabled');
-    const r = resolveEffectiveAiProfile(s, { aiProfileId: null });
-    assert.strictEqual(r.source, 'default');
-    assert.strictEqual(r.profileId, 'profile-default-enabled');
-  }
-
-  console.log('ai-profile-resolver-test PASS');
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exit(1);
-});
+// _site/_test/ai-profile-resolver-test.js
+//
+// Tests for the shared effective AI profile resolver. The resolver is the
+// single source of truth for "which AI profile does this project use right
+// now" — replacing the inconsistent fallback logic that used to live in
+// Workbench start-session / send-input, the analyzer, the CommitReconciler,
+// and import default assignment.
+//
+// Resolution order (per T01):
+//   1. projectConfig.aiProfileId when usable
+//   2. settings.ai.defaultProfileId when usable
+//   3. first usable configured profile in stable configured order
+//   4. otherwise AI_PROFILE_REQUIRED
+
+const assert = require('assert');
+const { resolveEffectiveAiProfile, isUsable, profileById } = require('../lib/ai-profile-resolver');
+
+const PROFILE_A = { id: 'profile-a', name: 'A', enabled: true, vendor: 'anthropic', model: 'm' };
+const PROFILE_B = { id: 'profile-b', name: 'B', enabled: true, vendor: 'anthropic', model: 'm' };
+const PROFILE_DISABLED = { id: 'profile-disabled', name: 'Disabled', enabled: false, vendor: 'anthropic', model: 'm' };
+const PROFILE_ENABLED_UNDEFINED = { id: 'profile-default-enabled', name: 'DefaultEnabled', vendor: 'anthropic', model: 'm' };
+
+function settings(profiles, defaultProfileId) {
+  return { ai: { schema: 'ai-profiles/v1', profiles, defaultProfileId: defaultProfileId || null } };
+}
+
+(async () => {
+  // ---- Case 1: explicit project profile is preferred ----
+  {
+    const s = settings([PROFILE_A, PROFILE_B], 'profile-b');
+    const r = resolveEffectiveAiProfile(s, { aiProfileId: 'profile-a' });
+    assert.strictEqual(r.source, 'project');
+    assert.strictEqual(r.profileId, 'profile-a');
+    assert.strictEqual(r.profile.id, 'profile-a');
+  }
+
+  // ---- Case 2: default profile fallback when project has none ----
+  {
+    const s = settings([PROFILE_A, PROFILE_B], 'profile-b');
+    const r = resolveEffectiveAiProfile(s, { aiProfileId: null });
+    assert.strictEqual(r.source, 'default');
+    assert.strictEqual(r.profileId, 'profile-b');
+  }
+
+  // ---- Case 3: first-usable fallback when default is missing/disabled ----
+  {
+    const s = settings([PROFILE_DISABLED, PROFILE_A, PROFILE_B], 'profile-disabled');
+    const r = resolveEffectiveAiProfile(s, { aiProfileId: null });
+    assert.strictEqual(r.source, 'first-usable');
+    assert.strictEqual(r.profileId, 'profile-a');
+  }
+
+  // ---- Case 4: stale project profile id falls back safely ----
+  {
+    const s = settings([PROFILE_A, PROFILE_B], 'profile-b');
+    const r = resolveEffectiveAiProfile(s, { aiProfileId: 'profile-deleted' });
+    assert.strictEqual(r.source, 'default');
+    assert.strictEqual(r.profileId, 'profile-b');
+  }
+
+  // ---- Case 5: disabled project profile falls back to default ----
+  {
+    const s = settings([PROFILE_DISABLED, PROFILE_B], 'profile-b');
+    const r = resolveEffectiveAiProfile(s, { aiProfileId: 'profile-disabled' });
+    assert.strictEqual(r.source, 'default');
+    assert.strictEqual(r.profileId, 'profile-b');
+  }
+
+  // ---- Case 6: no usable profile produces one clear error ----
+  {
+    const s = settings([PROFILE_DISABLED], null);
+    let threw = null;
+    try { resolveEffectiveAiProfile(s, { aiProfileId: null }); }
+    catch (error) { threw = error; }
+    assert(threw, 'resolver must throw when no usable profile exists');
+    assert.strictEqual(threw.code, 'AI_PROFILE_REQUIRED');
+    assert.strictEqual(threw.status, 409);
+    assert(threw.details && typeof threw.details.hint === 'string');
+  }
+
+  // ---- Case 7: enabled=undefined (legacy profiles) is treated as usable ----
+  {
+    const s = settings([PROFILE_ENABLED_UNDEFINED], 'profile-default-enabled');
+    const r = resolveEffectiveAiProfile(s, { aiProfileId: null });
+    assert.strictEqual(r.source, 'default');
+    assert.strictEqual(r.profileId, 'profile-default-enabled');
+  }
+
+  // ---- Case 8: empty settings produces AI_PROFILE_REQUIRED ----
+  {
+    let threw = null;
+    try { resolveEffectiveAiProfile({ ai: { profiles: [] } }, { aiProfileId: null }); }
+    catch (error) { threw = error; }
+    assert(threw, 'empty settings must throw AI_PROFILE_REQUIRED');
+    assert.strictEqual(threw.code, 'AI_PROFILE_REQUIRED');
+  }
+
+  // ---- Case 9: null/undefined inputs are tolerated ----
+  {
+    const r = resolveEffectiveAiProfile({ ai: { profiles: [PROFILE_A] } }, null);
+    assert.strictEqual(r.source, 'first-usable');
+    assert.strictEqual(r.profileId, 'profile-a');
+  }
+
+  // ---- Case 10: isUsable + profileById helpers ----
+  {
+    assert.strictEqual(isUsable(PROFILE_A), true);
+    assert.strictEqual(isUsable(PROFILE_DISABLED), false);
+    assert.strictEqual(isUsable(null), false);
+    const s = settings([PROFILE_A, PROFILE_B]);
+    assert.strictEqual(profileById(s, 'profile-a').id, 'profile-a');
+    assert.strictEqual(profileById(s, 'profile-unknown'), null);
+    assert.strictEqual(profileById(s, ''), null);
+  }
+
+  // ---- Case 11: deterministic first-usable order ----
+  {
+    const s = settings([PROFILE_A, PROFILE_B], null);
+    const r1 = resolveEffectiveAiProfile(s, { aiProfileId: null });
+    const r2 = resolveEffectiveAiProfile(s, { aiProfileId: null });
+    assert.strictEqual(r1.profileId, 'profile-a');
+    assert.strictEqual(r2.profileId, 'profile-a');
+  }
+
+  // ---- Case 12: default profile that is enabled=undefined still wins over first-usable ----
+  {
+    const s = settings([PROFILE_A, PROFILE_ENABLED_UNDEFINED], 'profile-default-enabled');
+    const r = resolveEffectiveAiProfile(s, { aiProfileId: null });
+    assert.strictEqual(r.source, 'default');
+    assert.strictEqual(r.profileId, 'profile-default-enabled');
+  }
+
+  console.log('ai-profile-resolver-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});

package/_site/_test/ai-profile-test.js

@@ -1,75 +1,75 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnServer } = require('./helpers/spawn-server');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const PORT = 7795;
-const BASE = `http://127.0.0.1:${PORT}`;
-const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-ai-v2-'));
-
-async function request(method, pathname, body) {
-  const response = await fetch(`${BASE}${pathname}`, {
-    method,
-    headers: body === undefined ? undefined : { 'content-type': 'application/json' },
-    body: body === undefined ? undefined : JSON.stringify(body),
-  });
-  return { status: response.status, text: await response.text() };
-}
-
-async function json(method, pathname, body) {
-  const result = await request(method, pathname, body);
-  return { ...result, data: JSON.parse(result.text || '{}') };
-}
-
-async function waitForServer() {
-  for (let attempt = 0; attempt < 100; attempt += 1) {
-    try { if ((await fetch(`${BASE}/api/health`)).ok) return; } catch {}
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  throw new Error('server did not start');
-}
-
-(async () => {
-  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'ai-profile-v2', extraEnv: { KB_SKIP_MIGRATION: '1' } });
-  try {
-    await waitForServer();
-    let result = await json('PUT', '/api/ai-profiles', {
-      schema: 'ai-profiles/v1', defaultProfileId: 'secure', profiles: [{
-        id: 'secure', name: 'Secure', enabled: true, implementation: 'claude-code-agent', apiKeyUpdate: { mode: 'replace', value: 'sk-secret-1234' },
-      }],
-    });
-    assert.strictEqual(result.status, 200, result.text);
-    assert.strictEqual(result.data.config.profiles[0].hasApiKey, true);
-    assert.strictEqual(result.data.config.profiles[0].apiKeyMasked, '****1234');
-    assert(!result.text.includes('sk-secret-1234'));
-
-    result = await json('GET', '/api/ai-profiles');
-    assert.strictEqual(result.status, 200);
-    assert(!result.text.includes('sk-secret-1234'));
-    assert(!/"apiKey"\s*:/.test(result.text));
-
-    result = await json('PUT', '/api/ai-profiles', {
-      schema: 'ai-profiles/v1', defaultProfileId: 'secure', profiles: [{ id: 'secure', name: 'Renamed', enabled: true, implementation: 'claude-code-agent', apiKeyUpdate: { mode: 'preserve' } }],
-    });
-    assert.strictEqual(result.status, 200);
-    let settings = JSON.parse(fs.readFileSync(path.join(dataDir, 'settings.json'), 'utf8'));
-    assert.strictEqual(settings.ai.profiles[0].apiKey, 'sk-secret-1234');
-
-    result = await json('PUT', '/api/ai-profiles', {
-      schema: 'ai-profiles/v1', defaultProfileId: 'secure', profiles: [{ id: 'secure', name: 'Renamed', enabled: true, implementation: 'claude-code-agent', apiKeyUpdate: { mode: 'clear' } }],
-    });
-    assert.strictEqual(result.status, 200);
-    settings = JSON.parse(fs.readFileSync(path.join(dataDir, 'settings.json'), 'utf8'));
-    assert(!Object.prototype.hasOwnProperty.call(settings.ai.profiles[0], 'apiKey'));
-
-    result = await json('PUT', '/api/ai-profiles', { profiles: [{ id: '../bad', apiKeyUpdate: { mode: 'clear' } }] });
-    assert.strictEqual(result.status, 400);
-    assert.strictEqual(result.data.error.code, 'INVALID_ARGUMENT');
-    assert(!Object.prototype.hasOwnProperty.call(result.data.error, 'stack'));
-    console.log('ai-profile-test PASS');
-  } finally {
-    await spawned.cleanup();
-  }
-})().catch(error => { console.error(error); process.exitCode = 1; });
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnServer } = require('./helpers/spawn-server');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const PORT = 7795;
+const BASE = `http://127.0.0.1:${PORT}`;
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pkb-ai-v2-'));
+
+async function request(method, pathname, body) {
+  const response = await fetch(`${BASE}${pathname}`, {
+    method,
+    headers: body === undefined ? undefined : { 'content-type': 'application/json' },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  return { status: response.status, text: await response.text() };
+}
+
+async function json(method, pathname, body) {
+  const result = await request(method, pathname, body);
+  return { ...result, data: JSON.parse(result.text || '{}') };
+}
+
+async function waitForServer() {
+  for (let attempt = 0; attempt < 100; attempt += 1) {
+    try { if ((await fetch(`${BASE}/api/health`)).ok) return; } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('server did not start');
+}
+
+(async () => {
+  const spawned = spawnServer({ root: ROOT, port: PORT, dataDir, tag: 'ai-profile-v2', extraEnv: { KB_SKIP_MIGRATION: '1' } });
+  try {
+    await waitForServer();
+    let result = await json('PUT', '/api/ai-profiles', {
+      schema: 'ai-profiles/v1', defaultProfileId: 'secure', profiles: [{
+        id: 'secure', name: 'Secure', enabled: true, implementation: 'claude-code-agent', apiKeyUpdate: { mode: 'replace', value: 'sk-secret-1234' },
+      }],
+    });
+    assert.strictEqual(result.status, 200, result.text);
+    assert.strictEqual(result.data.config.profiles[0].hasApiKey, true);
+    assert.strictEqual(result.data.config.profiles[0].apiKeyMasked, '****1234');
+    assert(!result.text.includes('sk-secret-1234'));
+
+    result = await json('GET', '/api/ai-profiles');
+    assert.strictEqual(result.status, 200);
+    assert(!result.text.includes('sk-secret-1234'));
+    assert(!/"apiKey"\s*:/.test(result.text));
+
+    result = await json('PUT', '/api/ai-profiles', {
+      schema: 'ai-profiles/v1', defaultProfileId: 'secure', profiles: [{ id: 'secure', name: 'Renamed', enabled: true, implementation: 'claude-code-agent', apiKeyUpdate: { mode: 'preserve' } }],
+    });
+    assert.strictEqual(result.status, 200);
+    let settings = JSON.parse(fs.readFileSync(path.join(dataDir, 'settings.json'), 'utf8'));
+    assert.strictEqual(settings.ai.profiles[0].apiKey, 'sk-secret-1234');
+
+    result = await json('PUT', '/api/ai-profiles', {
+      schema: 'ai-profiles/v1', defaultProfileId: 'secure', profiles: [{ id: 'secure', name: 'Renamed', enabled: true, implementation: 'claude-code-agent', apiKeyUpdate: { mode: 'clear' } }],
+    });
+    assert.strictEqual(result.status, 200);
+    settings = JSON.parse(fs.readFileSync(path.join(dataDir, 'settings.json'), 'utf8'));
+    assert(!Object.prototype.hasOwnProperty.call(settings.ai.profiles[0], 'apiKey'));
+
+    result = await json('PUT', '/api/ai-profiles', { profiles: [{ id: '../bad', apiKeyUpdate: { mode: 'clear' } }] });
+    assert.strictEqual(result.status, 400);
+    assert.strictEqual(result.data.error.code, 'INVALID_ARGUMENT');
+    assert(!Object.prototype.hasOwnProperty.call(result.data.error, 'stack'));
+    console.log('ai-profile-test PASS');
+  } finally {
+    await spawned.cleanup();
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/_site/_test/ai-vendor-presets-test.js

@@ -1,91 +1,91 @@
-// Tests for ai-vendor-presets: 4 vendors with full fields, name/id lookup.
-
-const { AI_VENDOR_PRESETS, listVendorPresetNames, findVendorPresetByName } = require('../lib/ai-vendor-presets');
-
-function assert(cond, msg) { if (!cond) throw new Error(msg); }
-
-(() => {
-  try {
-    // 1. Exactly 4 vendors
-    assert(Array.isArray(AI_VENDOR_PRESETS), 'AI_VENDOR_PRESETS should be an array');
-    assert(AI_VENDOR_PRESETS.length === 4, `expected 4 vendors, got ${AI_VENDOR_PRESETS.length}`);
-
-    // 2. IDs unique and match the expected set
-    const ids = AI_VENDOR_PRESETS.map(v => v.id).sort();
-    assert(JSON.stringify(ids) === JSON.stringify(['anthropic', 'deepseek', 'minimax', 'zhipu']),
-      `vendor ids should be anthropic/deepseek/minimax/zhipu, got ${JSON.stringify(ids)}`);
-
-    // 3. Every preset has the required fields
-    const required = ['id', 'name', 'baseUrl', 'mainModel', 'thinkingModel',
-                      'haikuModel', 'sonnetModel', 'opusModel', 'contextWindow', 'website'];
-    for (const v of AI_VENDOR_PRESETS) {
-      for (const f of required) {
-        assert(v[f] !== undefined && v[f] !== null && v[f] !== '',
-          `vendor ${v.id} missing or empty field: ${f}`);
-      }
-    }
-
-    // 4. baseUrl: https://, no trailing slash
-    for (const v of AI_VENDOR_PRESETS) {
-      assert(/^https?:\/\//.test(v.baseUrl), `${v.id} baseUrl must start with http(s)://`);
-      assert(!/\/$/.test(v.baseUrl), `${v.id} baseUrl must NOT have trailing slash`);
-    }
-
-    // 5. contextWindow is a positive integer
-    for (const v of AI_VENDOR_PRESETS) {
-      assert(Number.isInteger(v.contextWindow) && v.contextWindow > 0,
-        `${v.id} contextWindow must be a positive integer, got ${v.contextWindow}`);
-    }
-
-    // 6. Specific known values
-    const minimax = findVendorPresetByName('MiniMax');
-    assert(minimax && minimax.baseUrl === 'https://api.minimaxi.com/anthropic',
-      `minimax baseUrl wrong: ${minimax && minimax.baseUrl}`);
-    assert(minimax && minimax.mainModel === 'MiniMax-M3',
-      `minimax mainModel wrong: ${minimax && minimax.mainModel}`);
-    assert(minimax && minimax.contextWindow === 1048576,
-      `minimax contextWindow should be 1M`);
-
-    const anthropic = findVendorPresetByName('Anthropic Claude');
-    assert(anthropic && anthropic.baseUrl === 'https://api.anthropic.com',
-      `anthropic baseUrl wrong`);
-    assert(anthropic && anthropic.contextWindow === 200000,
-      `anthropic contextWindow should be 200K`);
-
-    const zhipu = findVendorPresetByName('智谱 GLM');
-    assert(zhipu && zhipu.baseUrl === 'https://open.bigmodel.cn/api/anthropic',
-      `zhipu baseUrl wrong: ${zhipu && zhipu.baseUrl}`);
-
-    const deepseek = findVendorPresetByName('DeepSeek');
-    assert(deepseek && deepseek.baseUrl === 'https://api.deepseek.com/anthropic',
-      `deepseek baseUrl wrong: ${deepseek && deepseek.baseUrl}`);
-    assert(deepseek && deepseek.mainModel === 'deepseek-chat',
-      `deepseek mainModel wrong`);
-    assert(deepseek && deepseek.thinkingModel === 'deepseek-reasoner',
-      `deepseek thinkingModel wrong`);
-
-    // 7. Case-insensitive lookup by name
-    assert(findVendorPresetByName('minimax').id === 'minimax', 'lowercase name lookup');
-    assert(findVendorPresetByName('MINIMAX').id === 'minimax', 'uppercase name lookup');
-
-    // 8. Lookup by id also works
-    assert(findVendorPresetByName('minimax').id === 'minimax', 'id lookup');
-
-    // 9. Unknown / empty / null returns null (no false positive)
-    assert(findVendorPresetByName('Totally Unknown Vendor') === null, 'unknown vendor → null');
-    assert(findVendorPresetByName('') === null, 'empty name → null');
-    assert(findVendorPresetByName(null) === null, 'null name → null');
-    assert(findVendorPresetByName(undefined) === null, 'undefined name → null');
-
-    // 10. listVendorPresetNames returns all 4 names in stable order
-    const names = listVendorPresetNames();
-    assert(names.length === 4, `expected 4 names, got ${names.length}`);
-    assert(names.every(n => typeof n === 'string' && n.length > 0),
-      'all names should be non-empty strings');
-
-    console.log('ai-vendor-presets test passed');
-  } catch (e) {
-    console.error('ai-vendor-presets test failed:', e.message);
-    process.exitCode = 1;
-  }
-})();
+// Tests for ai-vendor-presets: 4 vendors with full fields, name/id lookup.
+
+const { AI_VENDOR_PRESETS, listVendorPresetNames, findVendorPresetByName } = require('../lib/ai-vendor-presets');
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+
+(() => {
+  try {
+    // 1. Exactly 4 vendors
+    assert(Array.isArray(AI_VENDOR_PRESETS), 'AI_VENDOR_PRESETS should be an array');
+    assert(AI_VENDOR_PRESETS.length === 4, `expected 4 vendors, got ${AI_VENDOR_PRESETS.length}`);
+
+    // 2. IDs unique and match the expected set
+    const ids = AI_VENDOR_PRESETS.map(v => v.id).sort();
+    assert(JSON.stringify(ids) === JSON.stringify(['anthropic', 'deepseek', 'minimax', 'zhipu']),
+      `vendor ids should be anthropic/deepseek/minimax/zhipu, got ${JSON.stringify(ids)}`);
+
+    // 3. Every preset has the required fields
+    const required = ['id', 'name', 'baseUrl', 'mainModel', 'thinkingModel',
+                      'haikuModel', 'sonnetModel', 'opusModel', 'contextWindow', 'website'];
+    for (const v of AI_VENDOR_PRESETS) {
+      for (const f of required) {
+        assert(v[f] !== undefined && v[f] !== null && v[f] !== '',
+          `vendor ${v.id} missing or empty field: ${f}`);
+      }
+    }
+
+    // 4. baseUrl: https://, no trailing slash
+    for (const v of AI_VENDOR_PRESETS) {
+      assert(/^https?:\/\//.test(v.baseUrl), `${v.id} baseUrl must start with http(s)://`);
+      assert(!/\/$/.test(v.baseUrl), `${v.id} baseUrl must NOT have trailing slash`);
+    }
+
+    // 5. contextWindow is a positive integer
+    for (const v of AI_VENDOR_PRESETS) {
+      assert(Number.isInteger(v.contextWindow) && v.contextWindow > 0,
+        `${v.id} contextWindow must be a positive integer, got ${v.contextWindow}`);
+    }
+
+    // 6. Specific known values
+    const minimax = findVendorPresetByName('MiniMax');
+    assert(minimax && minimax.baseUrl === 'https://api.minimaxi.com/anthropic',
+      `minimax baseUrl wrong: ${minimax && minimax.baseUrl}`);
+    assert(minimax && minimax.mainModel === 'MiniMax-M3',
+      `minimax mainModel wrong: ${minimax && minimax.mainModel}`);
+    assert(minimax && minimax.contextWindow === 1048576,
+      `minimax contextWindow should be 1M`);
+
+    const anthropic = findVendorPresetByName('Anthropic Claude');
+    assert(anthropic && anthropic.baseUrl === 'https://api.anthropic.com',
+      `anthropic baseUrl wrong`);
+    assert(anthropic && anthropic.contextWindow === 200000,
+      `anthropic contextWindow should be 200K`);
+
+    const zhipu = findVendorPresetByName('智谱 GLM');
+    assert(zhipu && zhipu.baseUrl === 'https://open.bigmodel.cn/api/anthropic',
+      `zhipu baseUrl wrong: ${zhipu && zhipu.baseUrl}`);
+
+    const deepseek = findVendorPresetByName('DeepSeek');
+    assert(deepseek && deepseek.baseUrl === 'https://api.deepseek.com/anthropic',
+      `deepseek baseUrl wrong: ${deepseek && deepseek.baseUrl}`);
+    assert(deepseek && deepseek.mainModel === 'deepseek-chat',
+      `deepseek mainModel wrong`);
+    assert(deepseek && deepseek.thinkingModel === 'deepseek-reasoner',
+      `deepseek thinkingModel wrong`);
+
+    // 7. Case-insensitive lookup by name
+    assert(findVendorPresetByName('minimax').id === 'minimax', 'lowercase name lookup');
+    assert(findVendorPresetByName('MINIMAX').id === 'minimax', 'uppercase name lookup');
+
+    // 8. Lookup by id also works
+    assert(findVendorPresetByName('minimax').id === 'minimax', 'id lookup');
+
+    // 9. Unknown / empty / null returns null (no false positive)
+    assert(findVendorPresetByName('Totally Unknown Vendor') === null, 'unknown vendor → null');
+    assert(findVendorPresetByName('') === null, 'empty name → null');
+    assert(findVendorPresetByName(null) === null, 'null name → null');
+    assert(findVendorPresetByName(undefined) === null, 'undefined name → null');
+
+    // 10. listVendorPresetNames returns all 4 names in stable order
+    const names = listVendorPresetNames();
+    assert(names.length === 4, `expected 4 names, got ${names.length}`);
+    assert(names.every(n => typeof n === 'string' && n.length > 0),
+      'all names should be non-empty strings');
+
+    console.log('ai-vendor-presets test passed');
+  } catch (e) {
+    console.error('ai-vendor-presets test failed:', e.message);
+    process.exitCode = 1;
+  }
+})();