onbuzz 4.9.13 → 4.10.0

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

@@ -1,195 +1,195 @@
-/**
- * WebTool Unit Tests
- *
- * Tests the WebTool's error detection, validation, and feedback quality
- * WITHOUT requiring a real browser. Uses mocked Puppeteer page objects.
- */
-
-import { describe, test, expect, beforeEach, jest } from '@jest/globals';
-
-// We test the static helper and the core logic by importing WebTool
-// and mocking the browser layer.
-
-let WebTool;
-
-beforeEach(async () => {
-  const mod = await import('../../tools/webTool.js');
-  WebTool = mod.default;
-});
-
-// ─── _dedupeErrors ───────────────────────────────────────────────────────────
-
-describe('WebTool._dedupeErrors', () => {
-  test('returns empty array for empty input', () => {
-    expect(WebTool._dedupeErrors([])).toEqual([]);
-  });
-
-  test('returns empty array for null/undefined input', () => {
-    expect(WebTool._dedupeErrors(null)).toEqual([]);
-    expect(WebTool._dedupeErrors(undefined)).toEqual([]);
-  });
-
-  test('single unique error passes through unchanged', () => {
-    expect(WebTool._dedupeErrors(['Error A'])).toEqual(['Error A']);
-  });
-
-  test('deduplicates repeated errors with count', () => {
-    const input = ['Error A', 'Error A', 'Error A'];
-    expect(WebTool._dedupeErrors(input)).toEqual(['Error A (x3)']);
-  });
-
-  test('preserves order and mixes unique + repeated', () => {
-    const input = [
-      'Cannot read properties of undefined',
-      'Cannot read properties of undefined',
-      'Cannot read properties of undefined',
-      'Cannot read properties of undefined',
-      'Unique error: widget failed',
-      'GET https://api.bad.com/data → net::ERR_NAME_NOT_RESOLVED',
-      'GET https://api.bad.com/data → net::ERR_NAME_NOT_RESOLVED',
-      'GET https://api.bad.com/data → net::ERR_NAME_NOT_RESOLVED',
-      'GET https://api.other.com/v2 → net::ERR_NAME_NOT_RESOLVED',
-    ];
-    const result = WebTool._dedupeErrors(input);
-    expect(result).toEqual([
-      'Cannot read properties of undefined (x4)',
-      'Unique error: widget failed',
-      'GET https://api.bad.com/data → net::ERR_NAME_NOT_RESOLVED (x3)',
-      'GET https://api.other.com/v2 → net::ERR_NAME_NOT_RESOLVED',
-    ]);
-  });
-
-  test('does not add count suffix for single occurrences', () => {
-    const input = ['Error A', 'Error B', 'Error C'];
-    const result = WebTool._dedupeErrors(input);
-    expect(result).toEqual(['Error A', 'Error B', 'Error C']);
-    result.forEach(r => {
-      expect(r).not.toContain('(x');
-    });
-  });
-
-  test('handles two duplicates correctly', () => {
-    expect(WebTool._dedupeErrors(['X', 'X'])).toEqual(['X (x2)']);
-  });
-});
-
-// ─── URL Validation ──────────────────────────────────────────────────────────
-
-describe('WebTool URL validation', () => {
-  let wt;
-  const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
-
-  beforeEach(() => {
-    wt = new WebTool({ logger: silentLogger });
-  });
-
-  test('fetch with no URL returns error', async () => {
-    const result = await wt.execute({ operation: 'fetch' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/URL is required/i);
-  });
-
-  test('fetch with empty string URL returns error', async () => {
-    const result = await wt.execute({ operation: 'fetch', url: '' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/URL is required/i);
-  });
-
-  test('fetch with invalid URL format returns error', async () => {
-    const result = await wt.execute({ operation: 'fetch', url: 'not-a-url' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/Invalid URL format/);
-    expect(result.error).toContain('not-a-url');
-  });
-
-  test('fetch with missing protocol returns error', async () => {
-    const result = await wt.execute({ operation: 'fetch', url: 'example.com' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/Invalid URL format/);
-  });
-
-  test('unknown operation returns error', async () => {
-    const result = await wt.execute({ operation: 'foobar' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/Unknown operation/);
-  });
-});
-
-// ─── Search validation ───────────────────────────────────────────────────────
-
-describe('WebTool search validation', () => {
-  let wt;
-  const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
-
-  beforeEach(() => {
-    wt = new WebTool({ logger: silentLogger });
-  });
-
-  test('search with empty query returns error', async () => {
-    const result = await wt.execute({ operation: 'search', query: '' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/query is required/i);
-  });
-
-  test('search with unknown engine returns error', async () => {
-    const result = await wt.execute({ operation: 'search', query: 'hello', engine: 'fakesearch' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/Unknown search engine/i);
-  });
-});
-
-// ─── Execute wrapper ─────────────────────────────────────────────────────────
-
-describe('WebTool execute wrapper', () => {
-  let wt;
-  const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
-
-  beforeEach(() => {
-    wt = new WebTool({ logger: silentLogger });
-  });
-
-  test('respects operation success=false flag', async () => {
-    // fetch with invalid URL should propagate success=false
-    const result = await wt.execute({ operation: 'fetch', url: 'invalid' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    // Must NOT be overridden to true
-  });
-
-  test('includes operation name in result', async () => {
-    const result = await wt.execute({ operation: 'fetch', url: 'bad' }, { agentId: 'test', context: {} });
-    expect(result.operation).toBe('fetch');
-  });
-
-  test('includes toolUsed in result', async () => {
-    const result = await wt.execute({ operation: 'fetch', url: 'bad' }, { agentId: 'test', context: {} });
-    expect(result.toolUsed).toBe('web');
-  });
-});
-
-// ─── Parameter parsing ───────────────────────────────────────────────────────
-
-describe('WebTool parameter parsing', () => {
-  let wt;
-  const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
-
-  beforeEach(() => {
-    wt = new WebTool({ logger: silentLogger });
-  });
-
-  test('missing operation returns error', async () => {
-    const result = await wt.execute({}, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-  });
-
-  test('authenticate with no siteId returns error', async () => {
-    const result = await wt.execute({ operation: 'authenticate' }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(false);
-    expect(result.error).toMatch(/site.*required/i);
-  });
-
-  test('interactive with empty actions array succeeds vacuously', async () => {
-    const result = await wt.execute({ operation: 'interactive', actions: [] }, { agentId: 'test', context: {} });
-    expect(result.success).toBe(true);
-    expect(result.data.actionsExecuted).toBe(0);
-  });
-});
+/**
+ * WebTool Unit Tests
+ *
+ * Tests the WebTool's error detection, validation, and feedback quality
+ * WITHOUT requiring a real browser. Uses mocked Puppeteer page objects.
+ */
+
+import { describe, test, expect, beforeEach } from '@jest/globals';
+
+// We test the static helper and the core logic by importing WebTool
+// and mocking the browser layer.
+
+let WebTool;
+
+beforeEach(async () => {
+  const mod = await import('../../tools/webTool.js');
+  WebTool = mod.default;
+});
+
+// ─── _dedupeErrors ───────────────────────────────────────────────────────────
+
+describe('WebTool._dedupeErrors', () => {
+  test('returns empty array for empty input', () => {
+    expect(WebTool._dedupeErrors([])).toEqual([]);
+  });
+
+  test('returns empty array for null/undefined input', () => {
+    expect(WebTool._dedupeErrors(null)).toEqual([]);
+    expect(WebTool._dedupeErrors(undefined)).toEqual([]);
+  });
+
+  test('single unique error passes through unchanged', () => {
+    expect(WebTool._dedupeErrors(['Error A'])).toEqual(['Error A']);
+  });
+
+  test('deduplicates repeated errors with count', () => {
+    const input = ['Error A', 'Error A', 'Error A'];
+    expect(WebTool._dedupeErrors(input)).toEqual(['Error A (x3)']);
+  });
+
+  test('preserves order and mixes unique + repeated', () => {
+    const input = [
+      'Cannot read properties of undefined',
+      'Cannot read properties of undefined',
+      'Cannot read properties of undefined',
+      'Cannot read properties of undefined',
+      'Unique error: widget failed',
+      'GET https://api.bad.com/data → net::ERR_NAME_NOT_RESOLVED',
+      'GET https://api.bad.com/data → net::ERR_NAME_NOT_RESOLVED',
+      'GET https://api.bad.com/data → net::ERR_NAME_NOT_RESOLVED',
+      'GET https://api.other.com/v2 → net::ERR_NAME_NOT_RESOLVED',
+    ];
+    const result = WebTool._dedupeErrors(input);
+    expect(result).toEqual([
+      'Cannot read properties of undefined (x4)',
+      'Unique error: widget failed',
+      'GET https://api.bad.com/data → net::ERR_NAME_NOT_RESOLVED (x3)',
+      'GET https://api.other.com/v2 → net::ERR_NAME_NOT_RESOLVED',
+    ]);
+  });
+
+  test('does not add count suffix for single occurrences', () => {
+    const input = ['Error A', 'Error B', 'Error C'];
+    const result = WebTool._dedupeErrors(input);
+    expect(result).toEqual(['Error A', 'Error B', 'Error C']);
+    result.forEach(r => {
+      expect(r).not.toContain('(x');
+    });
+  });
+
+  test('handles two duplicates correctly', () => {
+    expect(WebTool._dedupeErrors(['X', 'X'])).toEqual(['X (x2)']);
+  });
+});
+
+// ─── URL Validation ──────────────────────────────────────────────────────────
+
+describe('WebTool URL validation', () => {
+  let wt;
+  const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
+
+  beforeEach(() => {
+    wt = new WebTool({ logger: silentLogger });
+  });
+
+  test('fetch with no URL returns error', async () => {
+    const result = await wt.execute({ operation: 'fetch' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/URL is required/i);
+  });
+
+  test('fetch with empty string URL returns error', async () => {
+    const result = await wt.execute({ operation: 'fetch', url: '' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/URL is required/i);
+  });
+
+  test('fetch with invalid URL format returns error', async () => {
+    const result = await wt.execute({ operation: 'fetch', url: 'not-a-url' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/Invalid URL format/);
+    expect(result.error).toContain('not-a-url');
+  });
+
+  test('fetch with missing protocol returns error', async () => {
+    const result = await wt.execute({ operation: 'fetch', url: 'example.com' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/Invalid URL format/);
+  });
+
+  test('unknown operation returns error', async () => {
+    const result = await wt.execute({ operation: 'foobar' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/Unknown operation/);
+  });
+});
+
+// ─── Search validation ───────────────────────────────────────────────────────
+
+describe('WebTool search validation', () => {
+  let wt;
+  const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
+
+  beforeEach(() => {
+    wt = new WebTool({ logger: silentLogger });
+  });
+
+  test('search with empty query returns error', async () => {
+    const result = await wt.execute({ operation: 'search', query: '' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/query is required/i);
+  });
+
+  test('search with unknown engine returns error', async () => {
+    const result = await wt.execute({ operation: 'search', query: 'hello', engine: 'fakesearch' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/Unknown search engine/i);
+  });
+});
+
+// ─── Execute wrapper ─────────────────────────────────────────────────────────
+
+describe('WebTool execute wrapper', () => {
+  let wt;
+  const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
+
+  beforeEach(() => {
+    wt = new WebTool({ logger: silentLogger });
+  });
+
+  test('respects operation success=false flag', async () => {
+    // fetch with invalid URL should propagate success=false
+    const result = await wt.execute({ operation: 'fetch', url: 'invalid' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    // Must NOT be overridden to true
+  });
+
+  test('includes operation name in result', async () => {
+    const result = await wt.execute({ operation: 'fetch', url: 'bad' }, { agentId: 'test', context: {} });
+    expect(result.operation).toBe('fetch');
+  });
+
+  test('includes toolUsed in result', async () => {
+    const result = await wt.execute({ operation: 'fetch', url: 'bad' }, { agentId: 'test', context: {} });
+    expect(result.toolUsed).toBe('web');
+  });
+});
+
+// ─── Parameter parsing ───────────────────────────────────────────────────────
+
+describe('WebTool parameter parsing', () => {
+  let wt;
+  const silentLogger = { info() {}, warn() {}, error() {}, debug() {} };
+
+  beforeEach(() => {
+    wt = new WebTool({ logger: silentLogger });
+  });
+
+  test('missing operation returns error', async () => {
+    const result = await wt.execute({}, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+  });
+
+  test('authenticate with no siteId returns error', async () => {
+    const result = await wt.execute({ operation: 'authenticate' }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/site.*required/i);
+  });
+
+  test('interactive with empty actions array succeeds vacuously', async () => {
+    const result = await wt.execute({ operation: 'interactive', actions: [] }, { agentId: 'test', context: {} });
+    expect(result.success).toBe(true);
+    expect(result.data.actionsExecuted).toBe(0);
+  });
+});

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

@@ -1,75 +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');
-  });
-});
+/**
+ * Tests for WebTool._selectVisionModel() — catalog-driven.
+ * Uses recommended_for and tier instead of hardcoded name lists.
+ */
+
+import { 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/agentCommunicationTool.js

@@ -157,7 +157,7 @@ LIMITS:
         try {
           const parsed = JSON.parse(content);
           return this.parseParameters(parsed); // Recursive call to handle the parsed object
-        } catch (error) {
+        } catch {
           // Not valid JSON, continue to XML parsing
         }
       }
@@ -829,7 +829,7 @@ LIMITS:
   /**
    * Get unreplied messages for an agent
    */
-  async getUnrepliedMessages(agentId, parameters, context) {
+  async getUnrepliedMessages(agentId, parameters) {
     try {
       const {
         'include-low-priority': includeLowPriority = false,
@@ -900,7 +900,7 @@ LIMITS:
   /**
    * Mark a conversation as ended
    */
-  async markConversationEnded(agentId, parameters, context) {
+  async markConversationEnded(agentId, parameters) {
     try {
       const {
         'conversation-id': conversationId,
@@ -1000,7 +1000,7 @@ LIMITS:
   async _processAttachments(attachments, agentId, context = {}) {
     if (!attachments) return [];
 
-    let attachmentList = [];
+    let attachmentList;
     if (typeof attachments === 'string') {
       try {
         attachmentList = JSON.parse(attachments);
@@ -1278,13 +1278,13 @@ ${message.attachments.length > 0 ? `**Attachments:** ${message.attachments.lengt
         for (const attachment of message.attachments) {
           try {
             await fs.unlink(attachment.storagePath);
-          } catch (error) {
+          } catch {
             // Ignore errors for missing files
           }
         }
         
         // Remove from inboxes
-        for (const [agentId, inbox] of this.agentInboxes.entries()) {
+        for (const [, inbox] of this.agentInboxes.entries()) {
           inbox.delete(messageId);
         }
         
@@ -1297,7 +1297,7 @@ ${message.attachments.length > 0 ? `**Attachments:** ${message.attachments.lengt
       const lastActivity = new Date(conversation.lastActivity).getTime();
       if (lastActivity < retentionCutoff || conversation.status === 'ended') {
         // Remove from agent conversations
-        for (const [agentId, convs] of this.agentConversations.entries()) {
+        for (const [, convs] of this.agentConversations.entries()) {
           convs.delete(conversationId);
         }
         
@@ -1379,9 +1379,7 @@ ${message.attachments.length > 0 ? `**Attachments:** ${message.attachments.lengt
    * Check if sender can send message to recipient
    * @private
    */
-  async _canSendMessage(senderAgent, recipientId, context) {
-    const agentPool = context.agentPool;
-
+  async _canSendMessage(senderAgent, recipientId) {
     // Ensure interAgentTracking is a Map (defensive - may be plain object from JSON)
     if (!senderAgent.interAgentTracking || !(senderAgent.interAgentTracking instanceof Map)) {
       if (senderAgent.interAgentTracking && typeof senderAgent.interAgentTracking === 'object') {