onbuzz 3.9.6 → 3.9.7

package/package.json

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

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

@@ -0,0 +1,212 @@
+/**
+ * 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.
+ */
+
+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);
+
+  // 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;
+  }
+
+  // 3. First available vision model
+  if (visionModels.length > 0) return visionModels[0].name;
+
+  return null;
+}
+
+function getVisionModels(models) {
+  return (models || []).filter(m => m.supportsVision === true);
+}
+
+// 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 },
+];
+
+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');
+    });
+
+    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');
+    });
+  });
+
+  // ── 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');
+    });
+  });
+
+  // ── 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');
+    });
+  });
+
+  // ── 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();
+    });
+  });
+
+  // ── 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('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');
+    });
+  });
+
+  // ── 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);
+    });
+  });
+});

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

@@ -0,0 +1,121 @@
+/**
+ * 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
+ */
+
+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;
+
+  const allModels = modelsService.getModels?.() || [];
+  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;
+  }
+
+  return visionModels[0].name;
+}
+
+function makeContext(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');
+  });
+
+  test('selects o3 when only o3 and grok have vision', () => {
+    const models = [
+      { name: 'o3', supportsVision: true },
+      { name: 'grok-4', supportsVision: true },
+    ];
+    expect(selectVisionModel(makeContext(models))).toBe('o3');
+  });
+
+  test('falls back to first vision model when no keywords match', () => {
+    const models = [
+      { name: 'exotic-vision-1', supportsVision: true },
+      { name: 'exotic-vision-2', supportsVision: true },
+    ];
+    expect(selectVisionModel(makeContext(models))).toBe('exotic-vision-1');
+  });
+
+  test('skips non-vision models', () => {
+    const models = [
+      { name: 'gpt-5.3-codex', supportsVision: false },
+      { name: 'grok-4', supportsVision: true },
+    ];
+    expect(selectVisionModel(makeContext(models))).toBe('grok-4');
+  });
+
+  test('returns null when no vision models exist', () => {
+    const models = [
+      { name: 'gpt-5.3-codex', supportsVision: false },
+    ];
+    expect(selectVisionModel(makeContext(models))).toBeNull();
+  });
+
+  test('returns null when models list is empty', () => {
+    expect(selectVisionModel(makeContext([]))).toBeNull();
+  });
+
+  test('returns null when aiService has no modelsService', () => {
+    expect(selectVisionModel({ aiService: {} })).toBeNull();
+  });
+
+  test('returns null when context has no aiService', () => {
+    expect(selectVisionModel({})).toBeNull();
+  });
+
+  test('analyzeScreenshot would use o4-mini as fallback 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,12 @@ 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 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'];
 
 const MAX_IMAGE_SIZE_BYTES = 20 * 1024 * 1024; // 20MB
 const SESSION_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes

package/src/tools/webTool.js

@@ -2832,6 +2832,28 @@ 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
+   * @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;
+
+    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;
+    }
+
+    return visionModels[0].name;
+  }
+
   /**
    * Analyze screenshot using AI vision model
    * @param {Page} page - Puppeteer page
@@ -2856,8 +2878,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(