@baize-ai/core 0.3.15 → 0.3.16

package/test/model-provider.test.js

@@ -41,6 +41,10 @@ function readToml() {
   const p = path.join(homeDir, '.codex', 'config.toml');
   return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
 }
+function readProjectToml() {
+  const p = path.join(baizeDir, '.codex', 'config.toml');
+  return fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : '';
+}
 function readStore() {
   const p = path.join(baizeDir, '.baize', 'providers.json');
   return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : {};
@@ -52,10 +56,11 @@ describe('provider store', () => {
     expect(mp.getProviders()).toEqual({ active: 'official', providers: [] });
   });
 
-  test('saveProvider validates name and url', async () => {
+  test('saveProvider validates name, url, and kind', async () => {
     expect((await mp.saveProvider({})).success).toBe(false);
     expect((await mp.saveProvider({ name: 'x', cc: { baseUrl: 'ftp://bad' } })).success).toBe(false);
     expect((await mp.saveProvider({ name: 'x', codex: { baseUrl: 'nope' } })).success).toBe(false);
+    expect((await mp.saveProvider({ name: 'x', codex: { kind: 'bogus-kind' } })).success).toBe(false);
   });
 
   test('saveProvider persists sanitized entry (no secrets echoed)', async () => {
@@ -70,6 +75,64 @@ describe('provider store', () => {
     expect(stored.providers[0].cc.authToken).toBe('sk-ds-token'); // persisted, just not echoed
   });
 
+  test('saveProvider assigns codex kind + providerKey (D51)', async () => {
+    const r = await mp.saveProvider(DEEPSEEK);
+    expect(r.provider.codex.kind).toBe('responses-compatible');
+    expect(r.provider.codex.providerKey).toBe('deepseek');
+    // Stored (not just sanitized) so the slug is stable across restarts.
+    const stored = readStore();
+    expect(stored.providers[0].codex.kind).toBe('responses-compatible');
+    expect(stored.providers[0].codex.providerKey).toBe('deepseek');
+  });
+
+  test('provider without codex.baseUrl defaults to openai-official kind', async () => {
+    const r = await mp.saveProvider({ name: 'Claude Only', cc: { baseUrl: 'https://a', authToken: 'sk', model: 'm' } });
+    expect(r.success).toBe(true);
+    expect(r.provider.codex.kind).toBe('openai-official');
+    expect(r.provider.codex.providerKey).toBe('claude-only');
+  });
+
+  test('codex kind can be set explicitly, chat-only included', async () => {
+    const r = await mp.saveProvider({ name: 'Old Gateway', codex: { baseUrl: 'https://legacy.example.com', kind: 'chat-only' } });
+    expect(r.success).toBe(true);
+    expect(r.provider.codex.kind).toBe('chat-only');
+  });
+
+  test('providerKey falls back to codex-<hash8> for reserved slugs (D51)', async () => {
+    // Raw reserved key 'openai' → codex-<hash8>; the id itself is sanitized to
+    // 'openai-custom' by genId, which is a safe non-reserved slug.
+    const r = await mp.saveProvider({ name: 'OpenAI', codex: { baseUrl: 'https://api.deepseek.com', apiKey: 'sk', model: 'm' } });
+    expect(r.success).toBe(true);
+    expect(r.provider.id).toBe('openai-custom'); // genId reservation (D51-extended)
+    expect(r.provider.codex.providerKey).toBe('openai-custom');
+    expect(r.provider.codex.providerKey).not.toBe('openai');
+  });
+
+  test('explicit kind survives an update; slug stays stable (D51)', async () => {
+    const created = await mp.saveProvider(DEEPSEEK);
+    const updated = await mp.saveProvider({ id: created.provider.id, name: 'DeepSeek 主', codex: { baseUrl: 'https://api.deepseek.com/v2', apiKey: 'sk2', model: 'm2' } });
+    expect(updated.success).toBe(true);
+    expect(updated.provider.codex.kind).toBe('responses-compatible'); // unchanged
+    expect(updated.provider.codex.providerKey).toBe('deepseek'); // slug never regenerated
+  });
+
+  test('lazy migration backfills kind/providerKey for legacy store entries (D51)', async () => {
+    // Simulate a pre-D51 providers.json: codex config but no kind/providerKey.
+    fs.writeFileSync(
+      path.join(baizeDir, '.baize', 'providers.json'),
+      JSON.stringify({
+        active: 'legacy',
+        providers: [{ id: 'legacy', name: 'Legacy', codex: { baseUrl: 'https://api.deepseek.com', apiKey: 'sk', model: 'm' } }],
+      }),
+    );
+    const list = mp.getProviders();
+    expect(list.providers[0].codex.kind).toBe('responses-compatible');
+    expect(list.providers[0].codex.providerKey).toBe('legacy');
+    // Backfill is persisted by the lazy migration.
+    expect(readStore().providers[0].codex.kind).toBe('responses-compatible');
+    expect(readStore().providers[0].codex.providerKey).toBe('legacy');
+  });
+
   test('deleteProvider falls back to official when active', async () => {
     await mp.saveProvider(DEEPSEEK);
     const store = readStore();
@@ -82,7 +145,7 @@ describe('provider store', () => {
 });
 
 describe('activateProvider — external (cc + codex)', () => {
-  test('applies env/settings/auth/toml, stashes official key, restarts', async () => {
+  test('applies env/settings/auth + provider block, stashes official key, restarts', async () => {
     // Pre-configure an official API key via D5-style storage
     fs.writeFileSync(path.join(baizeDir, '.env'), 'ANTHROPIC_API_KEY=sk-ant-official-key\n');
     fs.mkdirSync(path.join(homeDir, '.claude'), { recursive: true });
@@ -104,7 +167,7 @@ describe('activateProvider — external (cc + codex)', () => {
     expect(env).toMatch(/^ANTHROPIC_BASE_URL=https:\/\/api\.deepseek\.com\/anthropic$/m);
     expect(env).toMatch(/^ANTHROPIC_MODEL=deepseek-chat$/m);
     expect(env).toMatch(/^ANTHROPIC_SMALL_FAST_MODEL=deepseek-chat$/m);
-    expect(env).toMatch(/^OPENAI_BASE_URL=https:\/\/api\.deepseek\.com$/m);
+    expect(env).toMatch(/^OPENAI_BASE_URL=https:\/\/api\.deepseek\.com$/m); // legacy health-probe surface, kept
     expect(env).not.toMatch(/ANTHROPIC_API_KEY/);
 
     // settings.json env: same
@@ -115,12 +178,29 @@ describe('activateProvider — external (cc + codex)', () => {
     // stash preserved for revert
     expect(readStore().stash.apiKey).toBe('sk-ant-official-key');
 
-    // codex auth.json + config.toml
+    // codex auth.json + provider block config (D51)
     const auth = JSON.parse(fs.readFileSync(path.join(homeDir, '.codex', 'auth.json'), 'utf8'));
     expect(auth.OPENAI_API_KEY).toBe('sk-ds-key');
     const toml = readToml();
-    expect(toml).toMatch(/^model = "deepseek-chat"$/m);
-    expect(toml).toMatch(/^openai_base_url = "https:\/\/api\.deepseek\.com"$/m);
+    expect(toml).toMatch(/^model_provider = "deepseek"$/m);
+    expect(toml).toMatch(/^\[model_providers\.deepseek\]$/m);
+    expect(toml).toMatch(/^name = "deepseek"$/m);
+    expect(toml).toMatch(/^base_url = "https:\/\/api\.deepseek\.com"$/m);
+    expect(toml).toMatch(/^wire_api = "responses"$/m);
+    expect(toml).toMatch(/^experimental_bearer_token = "sk-ds-key"$/m);
+    // the legacy override must never coexist with the provider block
+    expect(toml).not.toMatch(/openai_base_url/);
+
+    // project-level: model ensured, openai_base_url cleaned, no provider block
+    const projectToml = readProjectToml();
+    expect(projectToml).toMatch(/^model = "deepseek-chat"$/m);
+    expect(projectToml).not.toMatch(/openai_base_url/);
+    expect(projectToml).not.toMatch(/model_provider/);
+    expect(projectToml).not.toMatch(/\[model_providers\./);
+
+    // token-bearing global config is user-only
+    const mode = fs.statSync(path.join(homeDir, '.codex', 'config.toml')).mode & 0o777;
+    expect(mode).toBe(0o600);
   });
 
   test('probe failure surfaces a warning but still applies', async () => {
@@ -139,6 +219,22 @@ describe('activateProvider — external (cc + codex)', () => {
   });
 });
 
+describe('activateProvider — chat-only interception (D51)', () => {
+  test('activating a chat-only provider is rejected before anything is written', async () => {
+    const saved = await mp.saveProvider({
+      name: '旧网关',
+      codex: { baseUrl: 'https://legacy.example.com', apiKey: 'sk-legacy', model: 'gpt-3.5', kind: 'chat-only' },
+    });
+    const before = readToml();
+    const r = await mp.activateProvider(saved.provider.id, { probe: async () => true, restart: noopRestart });
+    expect(r.success).toBe(false);
+    expect(r.error).toMatch(/仅支持 Chat 接口/);
+    expect(r.error).toMatch(/Claude 运行时/);
+    expect(readToml()).toBe(before); // nothing written
+    expect(readEnv()).not.toMatch(/OPENAI_BASE_URL=https:\/\/legacy\.example\.com/);
+  });
+});
+
 describe('activateProvider — official restores', () => {
   test('official clears external vars and restores stashed key', async () => {
     fs.writeFileSync(path.join(baizeDir, '.env'), 'ANTHROPIC_API_KEY=sk-ant-official-key\n');
@@ -160,58 +256,57 @@ describe('activateProvider — official restores', () => {
     expect(readStore().stash).toBeUndefined(); // stash cleared from file
   });
 
-  test('official-openai clears codex base_url and resets model', async () => {
+  test('official-openai drops the provider block and resets model to gpt-5.5 (D51)', async () => {
     await mp.saveProvider(DEEPSEEK);
     await mp.activateProvider('deepseek', { probe: async () => true, restart: noopRestart });
 
     const r = await mp.activateProvider('official-openai', { restart: noopRestart });
     expect(r.success).toBe(true);
+    expect(r.codexProviderKey).toBeNull();
     const env = readEnv();
-    expect(env).not.toMatch(/OPENAI_BASE_URL/);
     const toml = readToml();
+    expect(env).not.toMatch(/OPENAI_BASE_URL/);
     expect(toml).toMatch(/^model = "gpt-5.5"$/m);
+    expect(toml).not.toMatch(/^model_provider/m);
+    expect(toml).not.toMatch(/\[model_providers\.deepseek\]/);
     expect(toml).not.toMatch(/openai_base_url/);
-  });
-});
-
-describe('editCodexConfigToml (TOML scope aware)', () => {
-  test('top-level keys land BEFORE the first section header; section content byte-preserved', () => {
-    fs.mkdirSync(path.join(homeDir, '.codex'), { recursive: true });
-    fs.writeFileSync(path.join(homeDir, '.codex', 'config.toml'), '# comment\n\n[model_providers.my]\nbase_url = "https://x"\nmodel = "other"\n');
-    mp.editCodexConfigToml({ model: 'deepseek-chat', openaiBaseUrl: 'https://api.deepseek.com' });
-    const toml = readToml();
-    const sectionIdx = toml.indexOf('[model_providers.my]');
-    // top-level keys must appear in the prefix BEFORE the section header
-    const topLevelIdx = toml.indexOf('model = "deepseek-chat"');
-    const baseUrlIdx = toml.indexOf('openai_base_url = "https://api.deepseek.com"');
-    expect(topLevelIdx).toBeGreaterThanOrEqual(0);
-    expect(baseUrlIdx).toBeGreaterThanOrEqual(0);
-    expect(topLevelIdx).toBeLessThan(sectionIdx);
-    expect(baseUrlIdx).toBeLessThan(sectionIdx);
-    // section content untouched
-    expect(toml).toMatch(/^\[model_providers\.my\]$/m);
-    expect(toml).toMatch(/^base_url = "https:\/\/x"$/m);
-    expect(toml).toMatch(/^model = "other"$/m);
+    const projectToml = readProjectToml();
+    expect(projectToml).not.toMatch(/openai_base_url/);
   });
 
-  test('replaces existing top-level keys without duplicating', () => {
+  test('official-openai removes baize-written tables but preserves hand-edited ones (D51 review P2)', async () => {
+    // Contract (review P2): a baize-written block always has name === key &&
+    // wire_api === 'responses'. Those are removed on restore. Hand-edited
+    // user providers (any other shape) survive untouched.
     fs.mkdirSync(path.join(homeDir, '.codex'), { recursive: true });
-    fs.writeFileSync(path.join(homeDir, '.codex', 'config.toml'), 'model = "gpt-5.5"\n');
-    mp.editCodexConfigToml({ model: 'deepseek-chat', openaiBaseUrl: 'https://api.deepseek.com' });
+    fs.writeFileSync(
+      path.join(homeDir, '.codex', 'config.toml'),
+      'model_provider = "deepseek"\n\n[model_providers.deepseek]\nname = "deepseek"\nbase_url = "https://api.deepseek.com"\nwire_api = "responses"\n\n[model_providers.myrelay]\nname = "My Relay"\nbase_url = "https://r.example"\n',
+    );
+    const r = await mp.activateProvider('official-openai', { restart: noopRestart });
+    expect(r.success).toBe(true);
     const toml = readToml();
-    expect(toml.match(/^model = "deepseek-chat"$/gm)).toHaveLength(1);
-    expect(toml.match(/^openai_base_url = "https:\/\/api\.deepseek\.com"$/gm)).toHaveLength(1);
+    expect(toml).toMatch(/^model = "gpt-5.5"$/m);
+    expect(toml).not.toMatch(/^model_provider/m);
+    expect(toml).not.toMatch(/\[model_providers\.deepseek\]/, 'baize-written block removed');
+    expect(toml).toMatch(/\[model_providers\.myrelay\]/, 'hand-edited provider survives');
+    expect(toml).toMatch(/name = "My Relay"/);
   });
 
-  test('removes openai_base_url on official restore, keeping sections', () => {
+  test('activating an openai-official-kind provider keeps the built-in OpenAI provider (D51)', async () => {
+    fs.mkdirSync(path.join(baizeDir, '.baize'), { recursive: true });
+    fs.writeFileSync(path.join(baizeDir, '.baize', 'config.json'), JSON.stringify({ runtime: 'codex' }));
     fs.mkdirSync(path.join(homeDir, '.codex'), { recursive: true });
-    fs.writeFileSync(path.join(homeDir, '.codex', 'config.toml'), 'openai_base_url = "https://api.deepseek.com"\n\n[model_providers.my]\nmodel = "deepseek-chat"\n');
-    mp.editCodexConfigToml({ model: 'gpt-5.5', openaiBaseUrl: null });
+    // fixture: baize-written shape (name === key && wire_api === responses) so restore removes it
+    fs.writeFileSync(path.join(homeDir, '.codex', 'config.toml'), 'model_provider = "deepseek"\n\n[model_providers.deepseek]\nname = "deepseek"\nbase_url = "https://api.deepseek.com"\nwire_api = "responses"\n');
+    await mp.saveProvider({ name: '官方 OpenAI', codex: { apiKey: 'sk-official', model: 'gpt-5.5' } }); // no baseUrl → openai-official
+    const r = await mp.activateProvider('openai-custom', { probe: async () => true, restart: noopRestart });
+    expect(r.success).toBe(true);
+    expect(r.codexProviderKey).toBeNull();
     const toml = readToml();
-    expect(toml).not.toMatch(/^openai_base_url/m);
+    expect(toml).not.toMatch(/^model_provider/m); // built-in provider back in charge
+    expect(toml).not.toMatch(/\[model_providers\.deepseek\]/);
     expect(toml).toMatch(/^model = "gpt-5.5"$/m);
-    expect(toml).toMatch(/^\[model_providers\.my\]$/m);
-    expect(toml).toMatch(/^model = "deepseek-chat"$/m); // section model untouched
   });
 });
 
@@ -268,3 +363,18 @@ describe('activateProvider — side-coverage validation (D13)', () => {
     expect(r.success).toBe(true);
   });
 });
+
+describe('D51 migration — legacy activation cleans stale overrides', () => {
+  test('activating a provider removes a pre-existing openai_base_url override', async () => {
+    fs.mkdirSync(path.join(homeDir, '.codex'), { recursive: true });
+    fs.writeFileSync(path.join(homeDir, '.codex', 'config.toml'), 'openai_base_url = "https://old.example.com/v1"\nmodel = "old"\n');
+    fs.mkdirSync(path.join(baizeDir, '.baize'), { recursive: true });
+    fs.writeFileSync(path.join(baizeDir, '.baize', 'config.json'), JSON.stringify({ runtime: 'codex' }));
+    await mp.saveProvider({ name: 'codex-only', codex: { baseUrl: 'https://api.deepseek.com', apiKey: 'sk', model: 'deepseek-chat' } });
+    const r = await mp.activateProvider('codex-only', { probe: async () => true, restart: noopRestart });
+    expect(r.success).toBe(true);
+    const toml = readToml();
+    expect(toml).not.toMatch(/openai_base_url/);
+    expect(toml).toMatch(/^model_provider = "codex-only"$/m);
+  });
+});

package/test/web-console-routes.test.js

@@ -744,7 +744,7 @@ describe('web-console a2a authz routes (D22 单元 C)', () => {
     expect(await res.json()).toEqual({ success: true, mode: 'open', allow: [], block: [] });
   });
 
-  test('PUT authz validates mode enum and list entries', async () => {
+  test('PUT authz validates mode enum; allow/block ignored and forced empty (D52 governance)', async () => {
     ctx = await startServer({ extraEnv: a2aEnv() });
     const put = async (body) => {
       const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/authz`, {
@@ -754,17 +754,15 @@ describe('web-console a2a authz routes (D22 单元 C)', () => {
       });
       return { status: res.status, body: await res.json() };
     };
-    expect((await put({ mode: 'bogus' })).status).toBe(400);
-    expect((await put({ mode: 'open', allow: 'x' })).status).toBe(400);      // allow not an array
-    expect((await put({ mode: 'open', block: [''], allow: [] })).status).toBe(400); // empty string element
-    expect((await put({ mode: 'open', block: [42], allow: [] })).status).toBe(400); // non-string element
-    expect((await put({ mode: 'open', block: ['a', 'a'], allow: [] })).status).toBe(400); // duplicate
-    const ok = await put({ mode: 'allowlist', allow: ['peer_1', 'peer_2'], block: [] });
+    expect((await put({ mode: 'bogus' })).status).toBe(400);           // invalid mode rejected
+    expect((await put({})).status).toBe(400);                          // missing mode rejected
+    // D52: lists are admin-managed — any allow/block payload is ignored → []
+    const ok = await put({ mode: 'allowlist', allow: ['peer_1', 'peer_2'], block: ['x'] });
     expect(ok.status).toBe(200);
-    expect(ok.body).toEqual({ success: true, mode: 'allowlist', allow: ['peer_1', 'peer_2'], block: [] });
+    expect(ok.body).toEqual({ success: true, mode: 'allowlist', allow: [], block: [] });
   });
 
-  test('PUT authz writes config.json preserving other fields and trims entries', async () => {
+  test('PUT authz writes config.json preserving other fields; lists forced empty', async () => {
     ctx = await startServer({ extraEnv: a2aEnv() });
     const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/authz`, {
       method: 'PUT',
@@ -772,16 +770,16 @@ describe('web-console a2a authz routes (D22 单元 C)', () => {
       body: JSON.stringify({ mode: 'open', allow: [], block: ['  peer_9  ', 'peer_10'] }),
     });
     expect(res.status).toBe(200);
-    expect(await res.json()).toEqual({ success: true, mode: 'open', allow: [], block: ['peer_9', 'peer_10'] });
+    expect(await res.json()).toEqual({ success: true, mode: 'open', allow: [], block: [] });
     const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
-    expect(cfg.authz).toEqual({ mode: 'open', allow: [], block: ['peer_9', 'peer_10'] });
+    expect(cfg.authz).toEqual({ mode: 'open', allow: [], block: [] });
     expect(cfg.enabled).toBe(true);
     expect(cfg.agentId).toBe('agent_test');
     expect(cfg.cert).toEqual({ keyPath: '', certPath: '' });
     expect(cfg.name).toBeUndefined();
   });
 
-  test('PUT authz creates config.json when missing', async () => {
+  test('PUT authz creates config.json when missing (mode only)', async () => {
     fs.rmSync(configFile());
     ctx = await startServer({ extraEnv: a2aEnv() });
     const res = await fetch(`${ctx.baseUrl}/api/admin/a2a/authz`, {
@@ -791,7 +789,7 @@ describe('web-console a2a authz routes (D22 单元 C)', () => {
     });
     expect(res.status).toBe(200);
     const cfg = JSON.parse(fs.readFileSync(configFile(), 'utf8'));
-    expect(cfg.authz).toEqual({ mode: 'allowlist', allow: ['peer_1'], block: [] });
+    expect(cfg.authz).toEqual({ mode: 'allowlist', allow: [], block: [] });
   });
 
   test('authz routes require session when a password is set', async () => {