onbuzz 3.9.7 → 3.9.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "3.9.7",
+  "version": "3.9.10",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

package/src/__tests__/resolvePreferredModel.test.js

@@ -1,152 +1,110 @@
 /**
- * Tests for resolvePreferredModel — the loosely-coupled model resolver
- * used by agent templates to auto-select the best available model.
+ * Tests for resolvePreferredModel — catalog-driven model resolver.
+ * Uses recommended_for and tags from the model catalog instead of name matching.
  */
 
 import { describe, test, expect, beforeAll } from '@jest/globals';
 
-let resolvePreferredModel, AGENT_TEMPLATES, TEMPLATE_MODEL_PREFERENCES;
+let resolvePreferredModel, AGENT_TEMPLATES, TEMPLATE_PURPOSE_MAP;
 
 beforeAll(async () => {
-  ({ resolvePreferredModel, AGENT_TEMPLATES, TEMPLATE_MODEL_PREFERENCES } =
+  ({ resolvePreferredModel, AGENT_TEMPLATES, TEMPLATE_PURPOSE_MAP } =
     await import('../../web-ui/src/constants/index.js'));
 });
 
-// Simulate available models — id is just the model name (no suffix)
+// Models with catalog computed fields
 const MOCK_MODELS = [
-  { id: 'gpt-5.4', modelName: 'gpt-5.4' },
-  { id: 'gpt-5.4-mini', modelName: 'gpt-5.4-mini' },
-  { id: 'gpt-5.4-nano', modelName: 'gpt-5.4-nano' },
-  { id: 'gpt-5.3-codex', modelName: 'gpt-5.3-codex' },
-  { id: 'gpt-5.2-chat', modelName: 'gpt-5.2-chat' },
-  { id: 'gpt-5-mini', modelName: 'gpt-5-mini' },
-  { id: 'gpt-4.1', modelName: 'gpt-4.1' },
-  { id: 'gpt-4.1-mini', modelName: 'gpt-4.1-mini' },
-  { id: 'o4-mini', modelName: 'o4-mini' },
-  { id: 'o3', modelName: 'o3' },
-  { id: 'grok-4', modelName: 'grok-4' },
-  { id: 'grok-4-fast-reasoning', modelName: 'grok-4-fast-reasoning' },
-  { id: 'DeepSeek-V3.2', modelName: 'DeepSeek-V3.2' },
-  { id: 'DeepSeek-R1-0528', modelName: 'DeepSeek-R1-0528' },
-  { id: 'Kimi-K2.5', modelName: 'Kimi-K2.5' },
-  { id: 'Phi-4-reasoning', modelName: 'Phi-4-reasoning' },
+  { id: 'o4-mini', modelName: 'o4-mini', recommended_for: ['vision', 'reasoning', 'default'], tags: ['vision', 'reasoning', 'agentic', 'budget', 'fast'], tier: 'budget' },
+  { id: 'gpt-5.3-codex', modelName: 'gpt-5.3-codex', recommended_for: ['coding'], tags: ['agentic', 'standard-cost'], tier: 'standard' },
+  { id: 'gpt-5.4', modelName: 'gpt-5.4', recommended_for: ['creative'], tags: ['agentic', 'standard-cost'], tier: 'standard' },
+  { id: 'gpt-5-mini', modelName: 'gpt-5-mini', recommended_for: ['vision', 'default'], tags: ['vision', 'agentic', 'budget', 'fast'], tier: 'budget' },
+  { id: 'Kimi-K2.5', modelName: 'Kimi-K2.5', recommended_for: ['vision'], tags: ['vision', 'budget'], tier: 'budget' },
+  { id: 'grok-4', modelName: 'grok-4', recommended_for: [], tags: ['agentic', 'standard-cost'], tier: 'standard' },
+  { id: 'DeepSeek-V3.2', modelName: 'DeepSeek-V3.2', recommended_for: [], tags: ['agentic', 'budget'], tier: 'budget' },
 ];
 
-describe('resolvePreferredModel', () => {
-  // ── Exact match ──────────────────────────────────────────────
-  describe('exact match (tier 1)', () => {
-    test('Coding Assistant resolves to gpt-5.3-codex', () => {
-      expect(resolvePreferredModel(AGENT_TEMPLATES.CODING_ASSISTANT, MOCK_MODELS))
-        .toBe('gpt-5.3-codex');
-    });
-
-    test('Data Analyst resolves to gpt-5.4-mini', () => {
-      expect(resolvePreferredModel(AGENT_TEMPLATES.DATA_ANALYST, MOCK_MODELS))
-        .toBe('gpt-5.4-mini');
-    });
+describe('resolvePreferredModel (catalog-driven)', () => {
 
-    test('Creative Writer resolves to gpt-5.4', () => {
-      expect(resolvePreferredModel(AGENT_TEMPLATES.CREATIVE_WRITER, MOCK_MODELS))
-        .toBe('gpt-5.4');
+  describe('recommended_for matching', () => {
+    test('Coding Assistant resolves to model recommended for coding', () => {
+      const result = resolvePreferredModel(AGENT_TEMPLATES.CODING_ASSISTANT, MOCK_MODELS);
+      expect(result).toBe('gpt-5.3-codex');
     });
 
-    test('Security Architect resolves to o4-mini', () => {
-      expect(resolvePreferredModel(AGENT_TEMPLATES.SECURITY_ARCHITECT, MOCK_MODELS))
-        .toBe('o4-mini');
+    test('Security Architect resolves to model recommended for reasoning', () => {
+      const result = resolvePreferredModel(AGENT_TEMPLATES.SECURITY_ARCHITECT, MOCK_MODELS);
+      expect(result).toBe('o4-mini');
     });
 
-    test('Team Manager resolves to gpt-5.4-mini', () => {
-      expect(resolvePreferredModel(AGENT_TEMPLATES.TEAM_MANAGER, MOCK_MODELS))
-        .toBe('gpt-5.4-mini');
+    test('Creative Writer resolves to model recommended for creative', () => {
+      const result = resolvePreferredModel(AGENT_TEMPLATES.CREATIVE_WRITER, MOCK_MODELS);
+      expect(result).toBe('gpt-5.4');
     });
 
-    test('System Admin resolves to gpt-5.4-mini', () => {
-      expect(resolvePreferredModel(AGENT_TEMPLATES.SYSTEM_ADMIN, MOCK_MODELS))
-        .toBe('gpt-5.4-mini');
+    test('System Admin resolves to model recommended for default', () => {
+      const result = resolvePreferredModel(AGENT_TEMPLATES.SYSTEM_ADMIN, MOCK_MODELS);
+      expect(result).toBe('o4-mini'); // first model with recommended_for: 'default'
     });
 
-    test('System Analyst resolves to gpt-5.4', () => {
-      expect(resolvePreferredModel(AGENT_TEMPLATES.SYSTEM_ANALYST, MOCK_MODELS))
-        .toBe('gpt-5.4');
-    });
-
-    test('Custom resolves to gpt-5.4-mini', () => {
-      expect(resolvePreferredModel(AGENT_TEMPLATES.CUSTOM, MOCK_MODELS))
-        .toBe('gpt-5.4-mini');
+    test('Custom resolves to default model', () => {
+      const result = resolvePreferredModel(AGENT_TEMPLATES.CUSTOM, MOCK_MODELS);
+      expect(result).toBe('o4-mini');
     });
   });
 
-  // ── Term scoring fallback ────────────────────────────────────
-  describe('term scoring fallback (preferred model not available)', () => {
-    test('Coding Assistant falls back to a gpt model when gpt-5.3-codex missing', () => {
-      const models = MOCK_MODELS.filter(m => m.modelName !== 'gpt-5.3-codex');
+  describe('tag fallback', () => {
+    test('falls back to tag match when no recommended_for match', () => {
+      // Models without any recommended_for
+      const models = [
+        { id: 'model-a', modelName: 'model-a', tags: ['coding'], recommended_for: [] },
+        { id: 'model-b', modelName: 'model-b', tags: ['general'], recommended_for: [] },
+      ];
       const result = resolvePreferredModel(AGENT_TEMPLATES.CODING_ASSISTANT, models);
-      const selected = models.find(m => m.id === result);
-      // Terms are ['gpt', 'codex', '5.3'] — should match a gpt model with high version
-      expect(selected.modelName).toMatch(/gpt/);
-    });
-
-    test('Data Analyst falls back to a gpt model when gpt-5.4-mini missing', () => {
-      const models = MOCK_MODELS.filter(m => m.modelName !== 'gpt-5.4-mini');
-      const result = resolvePreferredModel(AGENT_TEMPLATES.DATA_ANALYST, models);
-      const selected = models.find(m => m.id === result);
-      // Should still pick a model that matches at least "gpt" or "5.4"
-      expect(selected).toBeDefined();
-    });
-
-    test('Security Architect falls back to a model matching at least one term when o4-mini missing', () => {
-      const models = MOCK_MODELS.filter(m => m.modelName !== 'o4-mini');
-      const result = resolvePreferredModel(AGENT_TEMPLATES.SECURITY_ARCHITECT, models);
-      expect(result).toBeTruthy();
-      // The resolver picks the best scoring model — any match on 'o4', 'reasoning', or 'o3' is valid
-      // Version-number bonus may also influence the pick (e.g., DeepSeek-R1-0528 has high digits)
+      expect(result).toBe('model-a');
     });
+  });
 
-    test('higher version numbers are preferred as tiebreaker', () => {
+  describe('default fallback', () => {
+    test('falls back to default-recommended model when purpose not found', () => {
       const models = [
-        { id: 'gpt-5.2', modelName: 'gpt-5.2' },
-        { id: 'gpt-5.4', modelName: 'gpt-5.4' },
-        { id: 'gpt-5.3', modelName: 'gpt-5.3' },
+        { id: 'exotic', modelName: 'exotic', recommended_for: ['default'], tags: [] },
+        { id: 'other', modelName: 'other', recommended_for: [], tags: [] },
       ];
-      // Creative Writer: terms are ['gpt', '5.4'], exact match hits gpt-5.4
-      expect(resolvePreferredModel(AGENT_TEMPLATES.CREATIVE_WRITER, models))
-        .toBe('gpt-5.4');
+      // Creative Writer with no 'creative' recommended_for → falls to 'default'
+      const result = resolvePreferredModel(AGENT_TEMPLATES.CREATIVE_WRITER, models);
+      expect(result).toBe('exotic');
     });
   });
 
-  // ── Random fallback ──────────────────────────────────────────
-  describe('random fallback (no terms match)', () => {
-    test('returns a model even when no terms match at all', () => {
-      const exoticModels = [
-        { id: 'exotic-1', modelName: 'totally-unknown' },
-        { id: 'exotic-2', modelName: 'another-unknown' },
+  describe('first-available fallback', () => {
+    test('returns first model when no tags or recommended_for match', () => {
+      const models = [
+        { id: 'unknown-1', modelName: 'unknown-1' },
+        { id: 'unknown-2', modelName: 'unknown-2' },
       ];
-      const result = resolvePreferredModel(AGENT_TEMPLATES.CODING_ASSISTANT, exoticModels);
-      expect(result).toBeTruthy();
-      expect(['exotic-1', 'exotic-2']).toContain(result);
+      const result = resolvePreferredModel(AGENT_TEMPLATES.CODING_ASSISTANT, models);
+      expect(result).toBe('unknown-1');
     });
   });
 
-  // ── Edge cases ───────────────────────────────────────────────
   describe('edge cases', () => {
-    test('returns null for empty model list', () => {
+    test('returns null for empty list', () => {
       expect(resolvePreferredModel(AGENT_TEMPLATES.CODING_ASSISTANT, [])).toBeNull();
     });
 
-    test('returns null for null model list', () => {
+    test('returns null for null', () => {
       expect(resolvePreferredModel(AGENT_TEMPLATES.CODING_ASSISTANT, null)).toBeNull();
     });
 
-    test('handles unknown template (returns first model)', () => {
+    test('handles unknown template gracefully', () => {
       const result = resolvePreferredModel('nonexistent', MOCK_MODELS);
-      expect(result).toBe(MOCK_MODELS[0].id);
+      // Unknown template defaults to 'default' purpose → finds o4-mini
+      expect(result).toBe('o4-mini');
     });
 
-    test('every AGENT_TEMPLATE has a preference defined', () => {
+    test('every AGENT_TEMPLATE has a purpose in TEMPLATE_PURPOSE_MAP', () => {
       for (const key of Object.values(AGENT_TEMPLATES)) {
-        expect(TEMPLATE_MODEL_PREFERENCES[key]).toBeDefined();
-        expect(TEMPLATE_MODEL_PREFERENCES[key].preferredModel).toBeTruthy();
-        expect(TEMPLATE_MODEL_PREFERENCES[key].terms.length).toBeGreaterThan(0);
+        expect(TEMPLATE_PURPOSE_MAP[key]).toBeDefined();
       }
     });
   });