onbuzz 3.9.5 → 3.9.7

package/package.json

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

package/src/index.js

@@ -38,8 +38,7 @@ import TaskManagerTool from './tools/taskManagerTool.js';
 import ImportAnalyzerTool from './tools/importAnalyzerTool.js';
 import DependencyResolverTool from './tools/dependencyResolverTool.js';
 import ImageTool from './tools/imageTool.js';
-// TODO: Re-enable video generation once Sora replacement is available
-// import VideoTool from './tools/videoTool.js';
+import VideoTool from './tools/videoTool.js';
 import StaticAnalysisTool from './tools/staticAnalysisTool.js';
 import CloneDetectionTool from './tools/cloneDetectionTool.js';
 import FileTreeTool from './tools/fileTreeTool.js';
@@ -436,9 +435,8 @@ class LoxiaApplication {
     // Register Image Generation Tool
     await this.toolsRegistry.registerTool(ImageTool);
 
-    // Register Video Generation Tool
-    // TODO: Re-enable video generation once Sora replacement is available
-    // await this.toolsRegistry.registerTool(VideoTool);
+    // Register Video Generation Tool (Sora 2)
+    await this.toolsRegistry.registerTool(VideoTool);
 
     // Register Static Analysis Tool
     await this.toolsRegistry.registerTool(StaticAnalysisTool);
@@ -544,16 +542,16 @@ class LoxiaApplication {
       this.logger.info('Dependencies set for Vision Tool');
     }
 
-    // TODO: Re-enable video generation once Sora replacement is available
-    // const videoTool = this.toolsRegistry.getTool('video-gen');
-    // if (videoTool && typeof videoTool.setAIService === 'function') {
-    //   videoTool.setAIService(this.aiService);
-    //   this.logger.info('AIService set for Video Generation Tool');
-    // }
-    // if (videoTool && typeof videoTool.setAgentPool === 'function') {
-    //   videoTool.setAgentPool(this.agentPool);
-    //   this.logger.info('AgentPool set for Video Generation Tool');
-    // }
+    // Video generation (Sora 2)
+    const videoTool = this.toolsRegistry.getTool('video-gen');
+    if (videoTool && typeof videoTool.setAIService === 'function') {
+      videoTool.setAIService(this.aiService);
+      this.logger.info('AIService set for Video Generation Tool');
+    }
+    if (videoTool && typeof videoTool.setAgentPool === 'function') {
+      videoTool.setAgentPool(this.agentPool);
+      this.logger.info('AgentPool set for Video Generation Tool');
+    }
 
     // Set WhatsApp Service dependency for WhatsApp Tool
     const whatsappTool = this.toolsRegistry.getTool('whatsapp');
@@ -792,7 +790,29 @@ class LoxiaApplication {
         'Navigation timeout',
         'net::ERR_',
         'Requesting main frame too early',
-        'Connection closed'
+        'Connection closed',
+        // AI/model errors should NOT crash the server
+        'HTTP 4',            // 400, 401, 403, 404, 429, etc.
+        'HTTP 5',            // 500, 502, 503, etc.
+        'circuit breaker',
+        'Rate limit',
+        'Insufficient credits',
+        'not suitable for chat',
+        'No API key configured',
+        'Message content is empty',
+        'Backend returned malformed',
+        'stream generator',
+        'No response choices',
+        'model error',
+        'isModelError',
+        'Service temporarily unavailable',
+        'Failed to fetch models',
+        'ECONNREFUSED',
+        'ETIMEDOUT',
+        'ECONNRESET',
+        'fetch failed',
+        'AbortError',
+        'The operation was aborted'
       ];
 
       const isNonCritical = nonCriticalPatterns.some(pattern =>

package/src/interfaces/webServer.js

@@ -1267,7 +1267,11 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
           apiKey = authHeader.substring(7);
         }
         
-        // If no API key, try to get from config or environment
+        // If no API key, try apiKeyManager, config, or environment
+        if (!apiKey && this.apiKeyManager) {
+          const keys = this.apiKeyManager.getKeysForRequest?.(null, { platformProvided: true });
+          if (keys?.loxiaApiKey) apiKey = keys.loxiaApiKey;
+        }
         if (!apiKey) {
           apiKey = this.config.loxiaApiKey || process.env.LOXIA_API_KEY;
         }

package/src/services/aiService.js

@@ -1298,13 +1298,13 @@ class AIService {
   }
 
   /**
-   * Generate a video using Sora
+   * Generate a video using Sora 2 (or dynamically resolved video model)
    * This submits a video generation job and returns a job ID for polling
    * @param {string} prompt - Text description of the video to generate
    * @param {Object} options - Options
-   * @param {number} options.width - Video width (default: 1080)
+   * @param {number} options.width - Video width (default: 1920)
    * @param {number} options.height - Video height (default: 1080)
-   * @param {number} options.duration - Duration in seconds 1-20 (default: 5)
+   * @param {number} options.duration - Duration in seconds 1-25 (default: 10)
    * @param {number} options.variants - Number of variants 1-4 (default: 1)
    * @param {string} options.model - Model to use (resolved from modelsService if omitted)
    * @param {string} options.sessionId - Session ID for API key retrieval

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/videoTool.js

@@ -10,23 +10,27 @@ import { BaseTool } from './baseTool.js';
 
 /**
  * Configuration constants for video generation
- * Based on Sora 1 API specifications
+ * Updated for Sora 2 API specifications (supports both Sora 1 and Sora 2)
  */
 const VIDEO_CONFIG = {
   DEFAULT_MODEL: null, // Resolved dynamically from modelsService via aiService
-  DEFAULT_WIDTH: 1080,
+  DEFAULT_WIDTH: 1920,
   DEFAULT_HEIGHT: 1080,
-  DEFAULT_DURATION: 5,  // seconds
+  DEFAULT_DURATION: 10, // seconds
   DEFAULT_VARIANTS: 1,
-  // Sora 1 supported resolutions
+  // Sora 2 supported resolutions (superset of Sora 1 + new HD/4K options)
   VALID_RESOLUTIONS: [
-    '480x480', '480x854', '854x480', '720x720',
-    '720x1280', '1280x720', '1080x1080', '1080x1920', '1920x1080'
+    // Landscape
+    '1920x1080', '1792x1024', '1280x720', '854x480',
+    // Portrait
+    '1080x1920', '1024x1792', '720x1280', '480x854',
+    // Square
+    '1080x1080', '720x720', '480x480'
   ],
   MIN_DURATION: 1,
-  MAX_DURATION: 20,  // seconds (Sora 1 limit)
+  MAX_DURATION: 25,  // seconds (Sora 2 supports up to 25s)
   MAX_VARIANTS: 4,
-  MAX_CONCURRENT: 2,  // Sora limits concurrent jobs to 2
+  MAX_CONCURRENT: 2,
   QUEUE_LIMIT: 5,
   POLL_INTERVAL: 5000,   // 5 seconds between status checks
   MAX_POLL_TIME: 600000, // 10 minutes max wait
@@ -36,7 +40,7 @@ const VIDEO_CONFIG = {
 };
 
 /**
- * VideoTool - Generate videos using Sora AI model
+ * VideoTool - Generate videos using Sora 2 AI model
  * Supports async job-based processing with polling
  */
 export class VideoTool extends BaseTool {
@@ -91,9 +95,9 @@ export class VideoTool extends BaseTool {
    * @returns {string} Formatted tool description
    */
   getDescription() {
-    return `Tool: Video Generator - Generate videos using Sora AI
+    return `Tool: Video Generator - Generate videos using Sora 2
 
-**Purpose:** Generate videos from text descriptions using Sora. Videos are saved to files and displayed in chat.
+**Purpose:** Generate videos from text descriptions using Sora 2. Videos are saved to files and displayed in chat.
 
 **CRITICAL: Automatic Execution**
 - ANY \`\`\`json block with "toolId": "video-gen" will be EXECUTED IMMEDIATELY
@@ -107,9 +111,9 @@ export class VideoTool extends BaseTool {
   "parameters": {
     "prompt": "Detailed description of the video",
     "outputPath": "videos/filename.mp4",
-    "width": 1080,
+    "width": 1920,
     "height": 1080,
-    "duration": 5
+    "duration": 10
   }
 }
 \`\`\`
@@ -117,12 +121,12 @@ export class VideoTool extends BaseTool {
 **Parameters:**
 - **prompt** (required): Detailed description of video to generate
 - **outputPath** (optional): Path to save video (permanent). Omit for temp file.
-- **width** (optional): Video width - 480, 720, 854, 1080, 1280, 1792, 1920 (default: 1080)
-- **height** (optional): Video height - 480, 720, 854, 1080, 1280, 1792, 1920 (default: 1080)
-- **duration** (optional): Duration in seconds, 1-20 (default: 5)
+- **width** (optional): Video width - 480, 720, 854, 1024, 1080, 1280, 1792, 1920 (default: 1920)
+- **height** (optional): Video height - 480, 720, 854, 1024, 1080, 1280, 1792, 1920 (default: 1080)
+- **duration** (optional): Duration in seconds, 1-25 (default: 10)
 - **variants** (optional): Number of video variants to generate, 1-4 (default: 1)
 
-**Valid Resolutions:** 480x480, 480x854, 854x480, 720x720, 720x1280, 1280x720, 1080x1080, 1080x1920, 1920x1080
+**Valid Resolutions:** 1920x1080, 1792x1024, 1280x720, 854x480, 1080x1920, 1024x1792, 720x1280, 480x854, 1080x1080, 720x720, 480x480
 
 **EXAMPLE:**
 User: "create a video of a cat playing"

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(

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-D39j_ic7.js"></script>
+    <script type="module" crossorigin src="/static/index-CNhxse_k.js"></script>
     <link rel="stylesheet" crossorigin href="/static/index-BwNJoEC1.css">
   </head>
   <body>

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

@@ -0,0 +1 @@
+import{g as f}from"./index-CNhxse_k.js";import{r as s}from"./index-DTSROa9m.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-AoL-lRFD.js

@@ -0,0 +1 @@
+import{r as s,g as f}from"./index-CNhxse_k.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-96OFWMCD.js

@@ -0,0 +1 @@
+import{g as s}from"./index-CNhxse_k.js";import{a as i}from"./index-DTSROa9m.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/abnf-C41Cofd6.js

@@ -0,0 +1 @@
+import{d as s,g as c}from"./index-CNhxse_k.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/accesslog-BcnAo7ES.js

@@ -0,0 +1 @@
+import{g as n}from"./index-CNhxse_k.js";import{b as f}from"./index-DTSROa9m.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-BFOz5mA2.js

@@ -0,0 +1 @@
+import{e as a,g as s}from"./index-CNhxse_k.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-DJGQt8u5.js

@@ -0,0 +1 @@
+import{g as a}from"./index-CNhxse_k.js";import{c as s}from"./index-DTSROa9m.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-CwKeODqT.js

@@ -0,0 +1 @@
+import{f as s,g as c}from"./index-CNhxse_k.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};

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

@@ -0,0 +1 @@
+import{g as s}from"./index-CNhxse_k.js";import{d as i}from"./index-DTSROa9m.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};