npm - onbuzz - Versions diffs - 3.9.7 → 3.9.10 - Mend

onbuzz 3.9.7 → 3.9.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (945) hide show

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

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,212 +1,86 @@
 /**
- * Tests for VisionTool vision model selection logic.
- *
- * The _selectVisionModel method picks the best available vision model
- * using a priority keyword list, falling back to agent's current model
- * or the first available vision model.
- *
- * We test the logic directly (same approach as webTool.visionModel.test.js)
- * to avoid importing the full VisionTool with its heavy BaseTool + fs dependencies.
+ * 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';
-// Replicate the exact priority list from visionTool.js
-const VISION_MODEL_PRIORITY = ['o4-mini', 'kimi', 'gpt-5-mini', 'gpt-5-nano', 'gpt-4.1-mini', 'gpt-4.1', 'o3', 'gpt-5'];
-/**
- * Replicate _selectVisionModel + _getVisionModels logic from visionTool.js
- */
 function selectVisionModel(models, context = {}) {
   const visionModels = (models || []).filter(m => m.supportsVision === true);
+  if (visionModels.length === 0) return null;
-  // 1. Priority keyword search
-  for (const keyword of VISION_MODEL_PRIORITY) {
-    const match = visionModels.find(m => m.name.toLowerCase().includes(keyword));
-    if (match) return match.name;
-  }
-  // 2. Agent's current model if it has vision
-  const agentModel = context.currentModel;
-  if (agentModel && visionModels.some(m => m.name === agentModel)) {
-    return agentModel;
-  }
+  // 1. Model recommended for vision
+  const recommended = visionModels.find(m => m.recommended_for?.includes('vision'));
+  if (recommended) return recommended.name;
-  // 3. First available vision model
-  if (visionModels.length > 0) return visionModels[0].name;
+  // 2. Budget-tier vision model
+  const budget = visionModels.find(m => m.tier === 'budget');
+  if (budget) return budget.name;
-  return null;
-}
+  // 3. Agent's current model
+  const agentModel = context.currentModel;
+  if (agentModel && visionModels.some(m => m.name === agentModel)) return agentModel;
-function getVisionModels(models) {
-  return (models || []).filter(m => m.supportsVision === true);
+  // 4. First available
+  return visionModels[0].name;
 }
-// Full model catalog simulation
 const ALL_MODELS = [
-  { name: 'gpt-5.4', supportsVision: false },
-  { name: 'gpt-5.4-mini', supportsVision: false },
-  { name: 'gpt-5-chat', supportsVision: true },
-  { name: 'gpt-5-mini', supportsVision: true },
-  { name: 'gpt-5-nano', supportsVision: true },
-  { name: 'gpt-4.1', supportsVision: true },
-  { name: 'gpt-4.1-mini', supportsVision: true },
-  { name: 'gpt-4.1-nano', supportsVision: true },
-  { name: 'o4-mini', supportsVision: true },
-  { name: 'o3', supportsVision: true },
-  { name: 'grok-4', supportsVision: true },
-  { name: 'grok-4-fast-reasoning', supportsVision: true },
-  { name: 'Kimi-K2.5', supportsVision: true },
-  { name: 'DeepSeek-V3.2', supportsVision: false },
-  { name: 'DeepSeek-R1-0528', supportsVision: false },
-  { name: 'gpt-5.3-codex', supportsVision: false },
-  { name: 'Phi-4-reasoning', supportsVision: false },
+  { 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 logic', () => {
-  // ── Priority keyword matching ────────────────────────────────
-  describe('priority-based selection', () => {
-    test('selects o4-mini as top priority', () => {
-      expect(selectVisionModel(ALL_MODELS)).toBe('o4-mini');
-    });
-    test('selects Kimi-K2.5 when o4-mini unavailable', () => {
-      const models = ALL_MODELS.filter(m => m.name !== 'o4-mini');
-      expect(selectVisionModel(models)).toBe('Kimi-K2.5');
-    });
-    test('selects gpt-5-mini when o4-mini and Kimi unavailable', () => {
-      const models = ALL_MODELS.filter(m => !['o4-mini', 'Kimi-K2.5'].includes(m.name));
-      expect(selectVisionModel(models)).toBe('gpt-5-mini');
-    });
+describe('VisionTool model selection (catalog-driven)', () => {
-    test('selects gpt-5-nano when higher-priority mini models unavailable', () => {
-      const models = ALL_MODELS.filter(m =>
-        !['o4-mini', 'Kimi-K2.5', 'gpt-5-mini'].includes(m.name)
-      );
-      expect(selectVisionModel(models)).toBe('gpt-5-nano');
-    });
-    test('selects gpt-4.1-mini next', () => {
-      const models = ALL_MODELS.filter(m =>
-        !['o4-mini', 'Kimi-K2.5', 'gpt-5-mini', 'gpt-5-nano'].includes(m.name)
-      );
-      expect(selectVisionModel(models)).toBe('gpt-4.1-mini');
-    });
-    test('selects gpt-4.1 after mini variant', () => {
-      const models = ALL_MODELS.filter(m =>
-        !['o4-mini', 'Kimi-K2.5', 'gpt-5-mini', 'gpt-5-nano', 'gpt-4.1-mini'].includes(m.name)
-      );
-      expect(selectVisionModel(models)).toBe('gpt-4.1');
-    });
-    test('selects o3 when only reasoning models available', () => {
-      const models = [
-        { name: 'o3', supportsVision: true },
-        { name: 'grok-4', supportsVision: true },
-      ];
-      expect(selectVisionModel(models)).toBe('o3');
-    });
-    test('matches gpt-5-chat via "gpt-5" keyword (last in priority)', () => {
-      const models = [
-        { name: 'gpt-5-chat', supportsVision: true },
-        { name: 'grok-4', supportsVision: true },
-      ];
-      expect(selectVisionModel(models)).toBe('gpt-5-chat');
-    });
-    test('skips non-vision models even if name matches priority keyword', () => {
-      const models = [
-        { name: 'gpt-5-mini-no-vision', supportsVision: false },
-        { name: 'grok-4', supportsVision: true },
-      ];
-      expect(selectVisionModel(models)).toBe('grok-4');
-    });
+  test('selects model recommended for vision', () => {
+    expect(selectVisionModel(ALL_MODELS)).toBe('o4-mini');
   });
-  // ── Agent current model fallback ─────────────────────────────
-  describe('agent current model fallback', () => {
-    test('uses agent current model when no priority keywords match', () => {
-      const models = [
-        { name: 'exotic-vision-model', supportsVision: true },
-        { name: 'another-exotic', supportsVision: true },
-      ];
-      expect(selectVisionModel(models, { currentModel: 'exotic-vision-model' }))
-        .toBe('exotic-vision-model');
-    });
-    test('ignores agent current model if it lacks vision', () => {
-      const models = [
-        { name: 'agent-model', supportsVision: false },
-        { name: 'fallback-vision', supportsVision: true },
-      ];
-      expect(selectVisionModel(models, { currentModel: 'agent-model' }))
-        .toBe('fallback-vision');
-    });
-    test('prefers priority keyword over agent current model', () => {
-      expect(selectVisionModel(ALL_MODELS, { currentModel: 'grok-4' }))
-        .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
   });
-  // ── First available fallback ─────────────────────────────────
-  describe('first available fallback', () => {
-    test('falls back to first vision model when nothing matches', () => {
-      const models = [
-        { name: 'custom-a', supportsVision: true },
-        { name: 'custom-b', supportsVision: true },
-      ];
-      expect(selectVisionModel(models)).toBe('custom-a');
-    });
+  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');
   });
-  // ── No vision models ─────────────────────────────────────────
-  describe('no vision models', () => {
-    test('returns null when no models have vision', () => {
-      const models = [
-        { name: 'gpt-5.3-codex', supportsVision: false },
-        { name: 'DeepSeek-V3.2', supportsVision: false },
-      ];
-      expect(selectVisionModel(models)).toBeNull();
-    });
-    test('returns null for empty list', () => {
-      expect(selectVisionModel([])).toBeNull();
-    });
-    test('returns null for null', () => {
-      expect(selectVisionModel(null)).toBeNull();
-    });
+  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');
   });
-  // ── getVisionModels filtering ────────────────────────────────
-  describe('getVisionModels', () => {
-    test('only returns models with supportsVision === true', () => {
-      const result = getVisionModels(ALL_MODELS);
-      expect(result.every(m => m.supportsVision)).toBe(true);
-      expect(result.length).toBe(ALL_MODELS.filter(m => m.supportsVision).length);
-    });
+  test('falls back to first available', () => {
+    const models = [
+      { name: 'only-option', supportsVision: true, recommended_for: [], tier: 'premium' },
+    ];
+    expect(selectVisionModel(models)).toBe('only-option');
+  });
-    test('excludes codex, DeepSeek, Phi models (no vision)', () => {
-      const result = getVisionModels(ALL_MODELS);
-      const names = result.map(m => m.name);
-      expect(names).not.toContain('gpt-5.3-codex');
-      expect(names).not.toContain('DeepSeek-V3.2');
-      expect(names).not.toContain('Phi-4-reasoning');
-    });
+  test('returns null when no vision models', () => {
+    expect(selectVisionModel([{ name: 'text-only', supportsVision: false }])).toBeNull();
+    expect(selectVisionModel([])).toBeNull();
+    expect(selectVisionModel(null)).toBeNull();
   });
-  // ── Old Anthropic keywords no longer match ───────────────────
-  describe('Anthropic removal verification', () => {
-    test('priority list does NOT contain opus or sonnet', () => {
-      expect(VISION_MODEL_PRIORITY).not.toContain('opus');
-      expect(VISION_MODEL_PRIORITY).not.toContain('sonnet');
-      expect(VISION_MODEL_PRIORITY.some(k => k.includes('claude'))).toBe(false);
-      expect(VISION_MODEL_PRIORITY.some(k => k.includes('anthropic'))).toBe(false);
-    });
+  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 CHANGED Viewed

@@ -1,22 +1,10 @@
 /**
- * Tests for WebTool._selectVisionModel() — the dynamic vision model
- * selector used for screenshot analysis.
- *
- * Verifies:
- *   - Priority keyword matching (o4-mini > kimi > gpt-5-mini > ...)
- *   - Falls back to first vision model when no keywords match
- *   - Returns null when modelsService is unavailable
- *   - Non-vision models are excluded
+ * Tests for WebTool._selectVisionModel() — catalog-driven.
+ * Uses recommended_for and tier instead of hardcoded name lists.
  */
 import { jest, describe, test, expect } from '@jest/globals';
-// We can't easily import the full WebTool (heavy Puppeteer dependency),
-// so we extract and test the _selectVisionModel logic directly.
-// The method is simple enough to replicate in isolation.
-const PRIORITY = ['o4-mini', 'kimi', 'gpt-5-mini', 'gpt-5-nano', 'gpt-4.1-mini', 'gpt-4.1', 'o3', 'gpt-5'];
 function selectVisionModel(context) {
   const modelsService = context.aiService?.modelsService;
   if (!modelsService) return null;
@@ -25,95 +13,61 @@ function selectVisionModel(context) {
   const visionModels = allModels.filter(m => m.supportsVision === true);
   if (visionModels.length === 0) return null;
-  for (const keyword of PRIORITY) {
-    const match = visionModels.find(m => m.name.toLowerCase().includes(keyword));
-    if (match) return match.name;
-  }
+  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
-      }
-    }
-  };
+  return { aiService: { modelsService: { getModels: () => models } } };
 }
-const ALL_MODELS = [
-  { name: 'o4-mini', supportsVision: true },
-  { name: 'o3', supportsVision: true },
-  { name: 'gpt-5-mini', supportsVision: true },
-  { name: 'gpt-4.1', supportsVision: true },
-  { name: 'Kimi-K2.5', supportsVision: true },
-  { name: 'grok-4', supportsVision: true },
-  { name: 'gpt-5.3-codex', supportsVision: false },
-  { name: 'DeepSeek-V3.2', supportsVision: false },
-];
-describe('WebTool._selectVisionModel (logic test)', () => {
-  test('selects o4-mini as top priority', () => {
-    expect(selectVisionModel(makeContext(ALL_MODELS))).toBe('o4-mini');
-  });
-  test('selects Kimi-K2.5 when o4-mini unavailable', () => {
-    const models = ALL_MODELS.filter(m => m.name !== 'o4-mini');
-    expect(selectVisionModel(makeContext(models))).toBe('Kimi-K2.5');
-  });
-  test('selects gpt-5-mini when o4-mini and Kimi unavailable', () => {
-    const models = ALL_MODELS.filter(m => !['o4-mini', 'Kimi-K2.5'].includes(m.name));
-    expect(selectVisionModel(makeContext(models))).toBe('gpt-5-mini');
-  });
+describe('WebTool._selectVisionModel (catalog-driven)', () => {
-  test('selects o3 when only o3 and grok have vision', () => {
+  test('selects model recommended for vision', () => {
     const models = [
-      { name: 'o3', supportsVision: true },
-      { name: 'grok-4', supportsVision: true },
+      { name: 'vision-model', supportsVision: true, recommended_for: ['vision'], tier: 'budget' },
+      { name: 'other', supportsVision: true, recommended_for: [], tier: 'standard' },
     ];
-    expect(selectVisionModel(makeContext(models))).toBe('o3');
+    expect(selectVisionModel(makeContext(models))).toBe('vision-model');
   });
-  test('falls back to first vision model when no keywords match', () => {
+  test('selects budget vision model as fallback', () => {
     const models = [
-      { name: 'exotic-vision-1', supportsVision: true },
-      { name: 'exotic-vision-2', supportsVision: true },
+      { name: 'premium', supportsVision: true, recommended_for: [], tier: 'premium' },
+      { name: 'cheap', supportsVision: true, recommended_for: [], tier: 'budget' },
     ];
-    expect(selectVisionModel(makeContext(models))).toBe('exotic-vision-1');
+    expect(selectVisionModel(makeContext(models))).toBe('cheap');
   });
-  test('skips non-vision models', () => {
+  test('returns first available when no tags match', () => {
     const models = [
-      { name: 'gpt-5.3-codex', supportsVision: false },
-      { name: 'grok-4', supportsVision: true },
+      { name: 'only-one', supportsVision: true, recommended_for: [], tier: 'premium' },
     ];
-    expect(selectVisionModel(makeContext(models))).toBe('grok-4');
+    expect(selectVisionModel(makeContext(models))).toBe('only-one');
   });
-  test('returns null when no vision models exist', () => {
+  test('skips non-vision models', () => {
     const models = [
-      { name: 'gpt-5.3-codex', supportsVision: false },
+      { name: 'text-only', supportsVision: false, recommended_for: ['vision'], tier: 'budget' },
+      { name: 'actual-vision', supportsVision: true, recommended_for: [], tier: 'standard' },
     ];
-    expect(selectVisionModel(makeContext(models))).toBeNull();
+    expect(selectVisionModel(makeContext(models))).toBe('actual-vision');
   });
-  test('returns null when models list is empty', () => {
+  test('returns null when no models available', () => {
     expect(selectVisionModel(makeContext([]))).toBeNull();
   });
-  test('returns null when aiService has no modelsService', () => {
-    expect(selectVisionModel({ aiService: {} })).toBeNull();
-  });
-  test('returns null when context has no aiService', () => {
+  test('returns null when no aiService', () => {
     expect(selectVisionModel({})).toBeNull();
   });
-  test('analyzeScreenshot would use o4-mini as fallback when _selectVisionModel returns null', () => {
+  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 CHANGED Viewed

@@ -18,12 +18,8 @@ import { BaseTool } from './baseTool.js';
 import { promises as fs } from 'fs';
 import path from 'path';
-// Vision model selection priority (best MMMU-Pro score / cost ratio):
-// 1. Keyword match from priority list below (filtered to vision-capable only)
-// 2. Agent's current model if it has vision capability
-// 3. First available vision model
-// o4-mini (79.2%, cheapest), Kimi (78.5%, cheap), gpt-5-mini (75.3%, very cheap), gpt-4.1 (69.3%, solid)
-const VISION_MODEL_PRIORITY = ['o4-mini', 'kimi', 'gpt-5-mini', 'gpt-5-nano', 'gpt-4.1-mini', 'gpt-4.1', 'o3', 'gpt-5'];
+// 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 CHANGED Viewed

@@ -2834,7 +2834,7 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
   /**
    * Select the best available vision model for screenshot analysis.
-   * Priority: o4-mini > kimi > gpt-5-mini > gpt-4.1 > o3 > first vision model
+   * Uses catalog tags + recommended_for — no hardcoded model names.
    * @private
    */
   _selectVisionModel(context) {
@@ -2845,12 +2845,15 @@ If blocked (CAPTCHA, access denied), use stealthLevel: "maximum" (visible browse
     const visionModels = allModels.filter(m => m.supportsVision === true);
     if (visionModels.length === 0) return null;
-    const priority = ['o4-mini', 'kimi', 'gpt-5-mini', 'gpt-5-nano', 'gpt-4.1-mini', 'gpt-4.1', 'o3', 'gpt-5'];
-    for (const keyword of priority) {
-      const match = visionModels.find(m => m.name.toLowerCase().includes(keyword));
-      if (match) return match.name;
-    }
+    // 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;
   }