onbuzz 3.9.6 → 3.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "3.9.6",
+  "version": "3.9.8",
   "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();
       }
     });
   });

package/src/interfaces/__tests__/remoteSessionAuth.test.js

@@ -33,6 +33,9 @@ function buildRemoteSessionApp(sessionToken) {
     // Health endpoint is public
     if (req.path === '/api/health' || req.path === '/health') return next();
 
+    // Static assets are public (CSS, JS, images, fonts)
+    if (req.path.startsWith('/static/') || req.path.endsWith('.svg') || req.path.endsWith('.png') || req.path.endsWith('.ico') || req.path.endsWith('.woff2')) return next();
+
     // Parse cookies manually
     const cookies = {};
     (req.headers.cookie || '').split(';').forEach(c => {
@@ -69,6 +72,10 @@ function buildRemoteSessionApp(sessionToken) {
   // ── Test routes behind the gate ────────────────────────────────
   app.get('/api/health', (req, res) => res.json({ status: 'healthy' }));
   app.get('/health', (req, res) => res.json({ status: 'healthy' }));
+  app.get('/static/index-abc123.js', (req, res) => res.type('js').send('console.log("app")'));
+  app.get('/static/index-abc123.css', (req, res) => res.type('css').send('body{}'));
+  app.get('/loxia-icon.svg', (req, res) => res.type('svg').send('<svg></svg>'));
+  app.get('/favicon.ico', (req, res) => res.type('ico').send(''));
   app.get('/api/test', (req, res) => res.json({ success: true, data: 'protected' }));
   app.get('/', (req, res) => res.send('<html><body>Web UI</body></html>'));
   app.get('/dashboard', (req, res) => res.send('<html><body>Dashboard</body></html>'));
@@ -113,6 +120,45 @@ describe('Remote Session Auth Gate', () => {
     });
   });
 
+  // ── Static assets bypass (public) ──────────────────────────────────
+  describe('static assets (public, no auth needed)', () => {
+    it('/static/*.js is accessible without any token', async () => {
+      const app = buildRemoteSessionApp(VALID_TOKEN);
+      const { server: s, baseUrl } = await startServer(app);
+      server = s;
+
+      const res = await fetch(`${baseUrl}/static/index-abc123.js`);
+      expect(res.status).toBe(200);
+    });
+
+    it('/static/*.css is accessible without any token', async () => {
+      const app = buildRemoteSessionApp(VALID_TOKEN);
+      const { server: s, baseUrl } = await startServer(app);
+      server = s;
+
+      const res = await fetch(`${baseUrl}/static/index-abc123.css`);
+      expect(res.status).toBe(200);
+    });
+
+    it('.svg files are accessible without any token', async () => {
+      const app = buildRemoteSessionApp(VALID_TOKEN);
+      const { server: s, baseUrl } = await startServer(app);
+      server = s;
+
+      const res = await fetch(`${baseUrl}/loxia-icon.svg`);
+      expect(res.status).toBe(200);
+    });
+
+    it('.ico files are accessible without any token', async () => {
+      const app = buildRemoteSessionApp(VALID_TOKEN);
+      const { server: s, baseUrl } = await startServer(app);
+      server = s;
+
+      const res = await fetch(`${baseUrl}/favicon.ico`);
+      expect(res.status).toBe(200);
+    });
+  });
+
   // ── Token via query param (first access) ─────────────────────────
   describe('?session_token= query param (first access)', () => {
     it('valid token sets cookie and redirects (strips token from URL)', async () => {

package/src/interfaces/webServer.js

@@ -269,6 +269,11 @@ class WebServer {
         // Health endpoint is public (used by session manager to check readiness)
         if (req.path === '/api/health' || req.path === '/health') return next();
 
+        // Static assets are public — CSS, JS, images, fonts, icons
+        // These are hashed build artifacts with no sensitive data.
+        // Blocking them breaks the UI on first load (before cookie is set).
+        if (req.path.startsWith('/static/') || req.path.endsWith('.svg') || req.path.endsWith('.png') || req.path.endsWith('.ico') || req.path.endsWith('.woff2')) return next();
+
         // Check for session token in cookie or query param
         // Parse cookie manually (avoid adding cookie-parser dependency)
         const cookies = {};
@@ -287,10 +292,13 @@ class WebServer {
             maxAge: (parseInt(process.env.SESSION_TTL) || 7200) * 1000,
             path: '/'
           });
-          // Strip the session_token param from URL and redirect
+          // Strip the session_token param and redirect via a tiny HTML page
+          // that sets sessionStorage flag before navigating (so the SPA knows
+          // this is a remote session with a pre-configured API key).
           const url = new URL(req.originalUrl, `http://${req.headers.host}`);
           url.searchParams.delete('session_token');
-          return res.redirect(url.pathname + url.search);
+          const target = url.pathname + url.search || '/';
+          return res.send(`<html><head><script>sessionStorage.setItem('loxia-remote-session','true');window.location.replace('${target}');</script></head><body></body></html>`);
         }
 
         if (tokenFromCookie === sessionToken) {

package/src/tools/__tests__/visionTool.modelSelection.test.js

@@ -0,0 +1,86 @@
+/**
+ * Tests for VisionTool vision model selection — catalog-driven.
+ * Uses recommended_for and tier from the catalog instead of name lists.
+ */
+
+import { describe, test, expect } from '@jest/globals';
+
+function selectVisionModel(models, context = {}) {
+  const visionModels = (models || []).filter(m => m.supportsVision === true);
+  if (visionModels.length === 0) return null;
+
+  // 1. Model recommended for vision
+  const recommended = visionModels.find(m => m.recommended_for?.includes('vision'));
+  if (recommended) return recommended.name;
+
+  // 2. Budget-tier vision model
+  const budget = visionModels.find(m => m.tier === 'budget');
+  if (budget) return budget.name;
+
+  // 3. Agent's current model
+  const agentModel = context.currentModel;
+  if (agentModel && visionModels.some(m => m.name === agentModel)) return agentModel;
+
+  // 4. First available
+  return visionModels[0].name;
+}
+
+const ALL_MODELS = [
+  { name: 'o4-mini', supportsVision: true, recommended_for: ['vision', 'reasoning', 'default'], tier: 'budget' },
+  { name: 'gpt-5-mini', supportsVision: true, recommended_for: ['vision', 'default'], tier: 'budget' },
+  { name: 'Kimi-K2.5', supportsVision: true, recommended_for: ['vision'], tier: 'budget' },
+  { name: 'gpt-5.4', supportsVision: false, recommended_for: ['creative'], tier: 'standard' },
+  { name: 'grok-4', supportsVision: true, recommended_for: [], tier: 'standard' },
+  { name: 'DeepSeek-V3.2', supportsVision: false, recommended_for: [], tier: 'budget' },
+  { name: 'gpt-5.3-codex', supportsVision: false, recommended_for: ['coding'], tier: 'standard' },
+];
+
+describe('VisionTool model selection (catalog-driven)', () => {
+
+  test('selects model recommended for vision', () => {
+    expect(selectVisionModel(ALL_MODELS)).toBe('o4-mini');
+  });
+
+  test('selects budget vision model when no recommended_for match', () => {
+    const models = ALL_MODELS.map(m => ({ ...m, recommended_for: [] }));
+    expect(selectVisionModel(models)).toBe('o4-mini'); // still budget + vision
+  });
+
+  test('skips non-vision models even if recommended', () => {
+    const models = [
+      { name: 'non-vision', supportsVision: false, recommended_for: ['vision'], tier: 'budget' },
+      { name: 'actual-vision', supportsVision: true, recommended_for: [], tier: 'standard' },
+    ];
+    expect(selectVisionModel(models)).toBe('actual-vision');
+  });
+
+  test('uses agent current model when no recommended/budget match', () => {
+    const models = [
+      { name: 'premium-vision', supportsVision: true, recommended_for: [], tier: 'premium' },
+      { name: 'agent-model', supportsVision: true, recommended_for: [], tier: 'premium' },
+    ];
+    expect(selectVisionModel(models, { currentModel: 'agent-model' })).toBe('agent-model');
+  });
+
+  test('falls back to first available', () => {
+    const models = [
+      { name: 'only-option', supportsVision: true, recommended_for: [], tier: 'premium' },
+    ];
+    expect(selectVisionModel(models)).toBe('only-option');
+  });
+
+  test('returns null when no vision models', () => {
+    expect(selectVisionModel([{ name: 'text-only', supportsVision: false }])).toBeNull();
+    expect(selectVisionModel([])).toBeNull();
+    expect(selectVisionModel(null)).toBeNull();
+  });
+
+  test('no hardcoded model names in selection logic', () => {
+    // All models are fictional — proves zero name dependence
+    const models = [
+      { name: 'xyz-model-alpha', supportsVision: true, recommended_for: ['vision'], tier: 'budget' },
+      { name: 'abc-model-beta', supportsVision: true, recommended_for: [], tier: 'standard' },
+    ];
+    expect(selectVisionModel(models)).toBe('xyz-model-alpha');
+  });
+});

package/src/tools/__tests__/webTool.visionModel.test.js

@@ -0,0 +1,75 @@
+/**
+ * Tests for WebTool._selectVisionModel() — catalog-driven.
+ * Uses recommended_for and tier instead of hardcoded name lists.
+ */
+
+import { jest, describe, test, expect } from '@jest/globals';
+
+function selectVisionModel(context) {
+  const modelsService = context.aiService?.modelsService;
+  if (!modelsService) return null;
+
+  const allModels = modelsService.getModels?.() || [];
+  const visionModels = allModels.filter(m => m.supportsVision === true);
+  if (visionModels.length === 0) return null;
+
+  const recommended = visionModels.find(m => m.recommended_for?.includes('vision'));
+  if (recommended) return recommended.name;
+
+  const budget = visionModels.find(m => m.tier === 'budget');
+  if (budget) return budget.name;
+
+  return visionModels[0].name;
+}
+
+function makeContext(models) {
+  return { aiService: { modelsService: { getModels: () => models } } };
+}
+
+describe('WebTool._selectVisionModel (catalog-driven)', () => {
+
+  test('selects model recommended for vision', () => {
+    const models = [
+      { name: 'vision-model', supportsVision: true, recommended_for: ['vision'], tier: 'budget' },
+      { name: 'other', supportsVision: true, recommended_for: [], tier: 'standard' },
+    ];
+    expect(selectVisionModel(makeContext(models))).toBe('vision-model');
+  });
+
+  test('selects budget vision model as fallback', () => {
+    const models = [
+      { name: 'premium', supportsVision: true, recommended_for: [], tier: 'premium' },
+      { name: 'cheap', supportsVision: true, recommended_for: [], tier: 'budget' },
+    ];
+    expect(selectVisionModel(makeContext(models))).toBe('cheap');
+  });
+
+  test('returns first available when no tags match', () => {
+    const models = [
+      { name: 'only-one', supportsVision: true, recommended_for: [], tier: 'premium' },
+    ];
+    expect(selectVisionModel(makeContext(models))).toBe('only-one');
+  });
+
+  test('skips non-vision models', () => {
+    const models = [
+      { name: 'text-only', supportsVision: false, recommended_for: ['vision'], tier: 'budget' },
+      { name: 'actual-vision', supportsVision: true, recommended_for: [], tier: 'standard' },
+    ];
+    expect(selectVisionModel(makeContext(models))).toBe('actual-vision');
+  });
+
+  test('returns null when no models available', () => {
+    expect(selectVisionModel(makeContext([]))).toBeNull();
+  });
+
+  test('returns null when no aiService', () => {
+    expect(selectVisionModel({})).toBeNull();
+  });
+
+  test('falls back to o4-mini when _selectVisionModel returns null', () => {
+    // The actual code does: this._selectVisionModel(context) || 'o4-mini'
+    const result = selectVisionModel({}) || 'o4-mini';
+    expect(result).toBe('o4-mini');
+  });
+});

package/src/tools/visionTool.js

@@ -4,7 +4,7 @@
  * Purpose:
  * - Analyze images from disk with natural language questions
  * - Session-based: first call uploads image, subsequent calls reuse it
- * - Uses the best available vision model (prefers Anthropic Sonnet/Opus)
+ * - Uses the best available vision model (prefers o4-mini for best MMMU/cost ratio)
  * - Returns structured answers only (no filler text)
  *
  * Actions:
@@ -18,12 +18,8 @@ import { BaseTool } from './baseTool.js';
 import { promises as fs } from 'fs';
 import path from 'path';
 
-// Dynamic vision model selection priority:
-// 1. Model with "opus" in name + vision capability
-// 2. Model with "sonnet" in name + vision capability
-// 3. Agent's current model if it has vision capability
-// 4. First model in the list with vision capability
-const VISION_MODEL_PRIORITY = ['opus', 'sonnet'];
+// Vision model selection uses catalog tags + recommended_for fields.
+// No hardcoded model names — the catalog determines which models are best for vision.
 
 const MAX_IMAGE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB
 const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
@@ -436,31 +432,29 @@ ANSWERS: Structured, direct answers only — no filler text.`;
 
   _selectVisionModel(context = {}) {
     const visionModels = this._getVisionModels();
-
-    // 1. Search by priority keywords (opus, sonnet)
-    for (const keyword of VISION_MODEL_PRIORITY) {
-      const match = visionModels.find(m => m.name.toLowerCase().includes(keyword));
-      if (match) {
-        this._selectedModel = match.name;
-        return this._selectedModel;
-      }
+    if (visionModels.length === 0) {
+      this.logger?.warn('[VisionTool] No vision-capable model found in model list');
+      return null;
     }
 
-    // 2. Agent's current model if it has vision capability
+    // 1. Model explicitly recommended for vision (from catalog)
+    const recommended = visionModels.find(m => m.recommended_for?.includes('vision'));
+    if (recommended) { this._selectedModel = recommended.name; return this._selectedModel; }
+
+    // 2. Vision model with budget tier (best cost/quality)
+    const budgetVision = visionModels.find(m => m.tier === 'budget');
+    if (budgetVision) { this._selectedModel = budgetVision.name; return this._selectedModel; }
+
+    // 3. Agent's current model if it has vision capability
     const agentModel = context.currentModel;
     if (agentModel && visionModels.some(m => m.name === agentModel)) {
       this._selectedModel = agentModel;
       return this._selectedModel;
     }
 
-    // 3. First available vision model
-    if (visionModels.length > 0) {
-      this._selectedModel = visionModels[0].name;
-      return this._selectedModel;
-    }
-
-    this.logger?.warn('[VisionTool] No vision-capable model found in model list');
-    return null;
+    // 4. First available vision model
+    this._selectedModel = visionModels[0].name;
+    return this._selectedModel;
   }
 
   _getVisionModels() {

package/src/tools/webTool.js

@@ -2832,6 +2832,31 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
     };
   }
 
+  /**
+   * Select the best available vision model for screenshot analysis.
+   * Uses catalog tags + recommended_for — no hardcoded model names.
+   * @private
+   */
+  _selectVisionModel(context) {
+    const modelsService = context.aiService?.modelsService;
+    if (!modelsService) return null;
+
+    const allModels = modelsService.getModels?.() || [];
+    const visionModels = allModels.filter(m => m.supportsVision === true);
+    if (visionModels.length === 0) return null;
+
+    // 1. Model recommended for vision (from catalog)
+    const recommended = visionModels.find(m => m.recommended_for?.includes('vision'));
+    if (recommended) return recommended.name;
+
+    // 2. Budget-tier vision model (best cost/quality)
+    const budget = visionModels.find(m => m.tier === 'budget');
+    if (budget) return budget.name;
+
+    // 3. First available
+    return visionModels[0].name;
+  }
+
   /**
    * Analyze screenshot using AI vision model
    * @param {Page} page - Puppeteer page
@@ -2856,8 +2881,8 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
     });
 
     try {
-      // Use vision model (prefer o3 if available, fallback to gpt-4-vision)
-      const model = 'o3'; // Will be mapped by AI service
+      // Select best available vision model dynamically
+      const model = this._selectVisionModel(context) || 'o4-mini';
 
       // Create message with image
       const response = await aiService.sendMessage(

package/web-ui/build/index.html

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Loxia Autopilot One</title>
     <meta name="description" content="AI Agents System - No-code/vibe-code/companion-coder platform" />
-    <script type="module" crossorigin src="/static/index-CNhxse_k.js"></script>
+    <script type="module" crossorigin src="/static/index-DY0DLa8y.js"></script>
     <link rel="stylesheet" crossorigin href="/static/index-BwNJoEC1.css">
   </head>
   <body>

package/web-ui/build/static/1c-CbzecjHi.js

@@ -0,0 +1 @@
+import{g as f}from"./index-DY0DLa8y.js";import{r as s}from"./index-ClWUfRkv.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const c=Object.getOwnPropertyDescriptor(e,r);c&&Object.defineProperty(t,r,c.get?c:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=s();const p=f(a),l=i({__proto__:null,default:p},[a]);export{l as _};

package/web-ui/build/static/abap-B64Rmd3x.js

@@ -0,0 +1 @@
+import{r as s,g as f}from"./index-DY0DLa8y.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var p=s();const i=f(p),b=c({__proto__:null,default:i},[p]);export{b as a};

package/web-ui/build/static/abnf-0eZ1ofqG.js

@@ -0,0 +1 @@
+import{d as s,g as c}from"./index-DY0DLa8y.js";function i(t,a){for(var o=0;o<a.length;o++){const e=a[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const n=Object.getOwnPropertyDescriptor(e,r);n&&Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=s();const p=c(f),b=i({__proto__:null,default:p},[f]);export{b as a};

package/web-ui/build/static/abnf-BhANbO1L.js

@@ -0,0 +1 @@
+import{g as s}from"./index-DY0DLa8y.js";import{a as i}from"./index-ClWUfRkv.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=i();const p=s(f),g=c({__proto__:null,default:p},[f]);export{g as a};

package/web-ui/build/static/accesslog-clFlGMX1.js

@@ -0,0 +1 @@
+import{g as n}from"./index-DY0DLa8y.js";import{b as f}from"./index-ClWUfRkv.js";function g(t,c){for(var o=0;o<c.length;o++){const e=c[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const s=Object.getOwnPropertyDescriptor(e,r);s&&Object.defineProperty(t,r,s.get?s:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=f();const l=n(a),u=g({__proto__:null,default:l},[a]);export{u as a};

package/web-ui/build/static/actionscript-DXab4IMG.js

@@ -0,0 +1 @@
+import{e as a,g as s}from"./index-DY0DLa8y.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=a();const f=s(n),g=p({__proto__:null,default:f},[n]);export{g as a};

package/web-ui/build/static/actionscript-RFf8wL8w.js

@@ -0,0 +1 @@
+import{g as a}from"./index-DY0DLa8y.js";import{c as s}from"./index-ClWUfRkv.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=s();const f=a(n),l=p({__proto__:null,default:f},[n]);export{l as a};

package/web-ui/build/static/ada-Bm94vJQR.js

@@ -0,0 +1 @@
+import{f as s,g as c}from"./index-DY0DLa8y.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=s();const p=c(f),d=i({__proto__:null,default:p},[f]);export{d as a};