onbuzz 4.0.2 → 4.2.0

package/src/tools/__tests__/agentCommunicationTool.test.js

@@ -600,4 +600,118 @@ describe('AgentCommunicationTool', () => {
       expect(result.yourTeams[0].role).toBe('manager');
     });
   });
+
+  // Per-agent toolConfig overrides (agent.toolConfig.agentcommunication).
+  // Effective limits resolve via BaseTool#getEffectiveConfig at each
+  // check-point in the tool.
+  describe('per-agent toolConfig overrides', () => {
+    test('per-agent maxRecipientsPerMessage overrides global default', async () => {
+      const { tool, context } = createTestSetup();
+      // Global default = 3; per-agent override = 1 → sending to 2 must fail.
+      const result = await tool.sendMessage('agent-sender', {
+        recipients: ['agent-recipient', 'agent-other'],
+        subject: 's',
+        message: 'm',
+      }, { ...context, toolConfig: { maxRecipientsPerMessage: 1 } });
+      expect(result.success).toBe(false);
+      expect(result.error).toMatch(/Maximum 1 recipients allowed/);
+    });
+
+    test('global default still applies when no per-agent override', async () => {
+      const { tool, context } = createTestSetup();
+      // Global default = 3; 4 recipients fails without any override.
+      const result = await tool.sendMessage('agent-sender', {
+        recipients: ['a', 'b', 'c', 'd'],
+        subject: 's',
+        message: 'm',
+      }, context);
+      expect(result.success).toBe(false);
+      expect(result.error).toMatch(/Maximum 3 recipients allowed/);
+    });
+
+    test('per-agent maxAttachmentsPerMessage overrides global default', async () => {
+      const { tool, context } = createTestSetup();
+      const atts = [
+        { path: '/a.txt' },
+        { path: '/b.txt' },
+        { path: '/c.txt' },
+      ];
+      await expect(
+        tool._processAttachments(atts, 'agent-sender', { ...context, toolConfig: { maxAttachmentsPerMessage: 2 } })
+      ).rejects.toThrow(/Maximum 2 attachments allowed/);
+    });
+
+    test('per-agent maxAttachmentSize overrides global default', async () => {
+      const { tool, context } = createTestSetup();
+      // Stat returns size 100; override to 10 → too large. The tool's
+      // per-attachment try/catch swallows the error and just skips the
+      // attachment, so the emitted array is empty. We also assert the
+      // error was logged as proof the size gate actually fired.
+      fsMock.stat.mockResolvedValue({ size: 100 });
+      const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+      const out = await tool._processAttachments([{ path: '/big.txt' }], 'agent-sender', {
+        ...context,
+        toolConfig: { maxAttachmentSize: 10 },
+      });
+      expect(out).toEqual([]);
+      expect(errorSpy).toHaveBeenCalledWith(
+        expect.stringMatching(/Failed to process attachment/),
+        expect.objectContaining({ message: expect.stringMatching(/exceeds size limit/) })
+      );
+      errorSpy.mockRestore();
+    });
+
+    test('per-agent maxAttachmentSize ALLOWS attachments within limit', async () => {
+      const { tool, context } = createTestSetup();
+      fsMock.stat.mockResolvedValue({ size: 50 });
+      const out = await tool._processAttachments([{ path: '/small.txt' }], 'agent-sender', {
+        ...context,
+        toolConfig: { maxAttachmentSize: 1024 },
+      });
+      expect(out).toHaveLength(1);
+    });
+
+    test('per-agent maxConversationDepth caps reply chain', async () => {
+      // Start a fresh conversation with a per-agent cap of 1: the first
+      // reply goes through, the second hits the limit. Mirrors the
+      // existing "rejects reply when conversation depth limit reached"
+      // test but drives the cap from context.toolConfig instead of
+      // mutating tool.config.
+      const { tool, context } = createTestSetup();
+
+      const sendResult = await tool.execute({
+        action: 'send-message',
+        recipient: 'agent-recipient',
+        subject: 'Deep',
+        message: 'Start',
+      }, { ...context, toolConfig: { maxConversationDepth: 1 } });
+      expect(sendResult.success).toBe(true);
+
+      // First reply (depth 1) — should succeed even under the cap.
+      const reply1 = await tool.execute({
+        action: 'reply-to-message',
+        'message-id': sendResult.messageId,
+        message: 'Reply 1',
+      }, { agentId: 'agent-recipient', agentPool: context.agentPool, toolConfig: { maxConversationDepth: 1 } });
+      expect(reply1.success).toBe(true);
+
+      // Second reply — depth now 1, cap is 1, must fail.
+      const reply2 = await tool.execute({
+        action: 'reply-to-message',
+        'message-id': reply1.messageId,
+        message: 'Reply 2',
+      }, { ...context, toolConfig: { maxConversationDepth: 1 } });
+      expect(reply2.success).toBe(false);
+      expect(reply2.error).toMatch(/depth limit reached \(1\)/);
+    });
+
+    test('_processAttachments with no context uses global config (backward compat)', async () => {
+      const { tool } = createTestSetup();
+      // Global = 5; 4 atts → ok (stat mocked to size 100, global max = 10MB).
+      fsMock.stat.mockResolvedValue({ size: 100 });
+      const atts = [{ path: '/a.txt' }, { path: '/b.txt' }];
+      const out = await tool._processAttachments(atts, 'agent-sender');
+      expect(Array.isArray(out)).toBe(true);
+    });
+  });
 });

package/src/tools/__tests__/baseTool.getEffectiveConfig.test.js

@@ -0,0 +1,77 @@
+/**
+ * Tests for BaseTool#getEffectiveConfig — the helper tools use to merge
+ * global defaults (this.config) with per-agent overrides delivered via
+ * context.toolConfig (from agent.toolConfig[toolId]).
+ *
+ * Contract: per-agent > global > fallbacks. Missing/malformed context
+ * leaves the tool looking only at its own config (no crash).
+ */
+
+import { describe, test, expect } from '@jest/globals';
+import { BaseTool } from '../baseTool.js';
+
+function makeTool(config = {}) {
+  const t = new BaseTool(config, { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} });
+  return t;
+}
+
+describe('BaseTool.getEffectiveConfig', () => {
+  test('returns this.config when context is missing', () => {
+    const tool = makeTool({ allowedCommands: ['git'] });
+    expect(tool.getEffectiveConfig(null)).toEqual({ allowedCommands: ['git'] });
+    expect(tool.getEffectiveConfig(undefined)).toEqual({ allowedCommands: ['git'] });
+    expect(tool.getEffectiveConfig({})).toEqual({ allowedCommands: ['git'] });
+  });
+
+  test('returns this.config when context has no toolConfig', () => {
+    const tool = makeTool({ allowedCommands: ['git'] });
+    expect(tool.getEffectiveConfig({ toolConfig: null })).toEqual({ allowedCommands: ['git'] });
+  });
+
+  test('per-agent toolConfig overrides global config field', () => {
+    const tool = makeTool({ allowedCommands: ['git'] });
+    const effective = tool.getEffectiveConfig({
+      toolConfig: { allowedCommands: ['git', 'npm'] },
+    });
+    expect(effective.allowedCommands).toEqual(['git', 'npm']);
+  });
+
+  test('per-agent toolConfig merges extra fields with global config', () => {
+    const tool = makeTool({ allowedCommands: ['git'], maxBackgroundCommandsPerAgent: 3 });
+    const effective = tool.getEffectiveConfig({
+      toolConfig: { blockedCommands: ['rm -rf'] },
+    });
+    expect(effective).toEqual({
+      allowedCommands: ['git'],
+      maxBackgroundCommandsPerAgent: 3,
+      blockedCommands: ['rm -rf'],
+    });
+  });
+
+  test('fallbacks are applied only when neither global nor per-agent sets the field', () => {
+    const tool = makeTool({ allowedCommands: ['git'] });
+    const effective = tool.getEffectiveConfig({ toolConfig: { } }, {
+      maxFileSize: 10_000,
+      allowedCommands: ['SHOULD NOT WIN'],
+    });
+    expect(effective.allowedCommands).toEqual(['git']);    // global wins over fallback
+    expect(effective.maxFileSize).toBe(10_000);            // fallback fills the gap
+  });
+
+  test('malformed toolConfig (array) is ignored', () => {
+    const tool = makeTool({ allowedCommands: ['git'] });
+    const effective = tool.getEffectiveConfig({ toolConfig: ['not', 'an', 'object'] });
+    expect(effective).toEqual({ allowedCommands: ['git'] });
+  });
+
+  test('malformed toolConfig (primitive) is ignored', () => {
+    const tool = makeTool({ allowedCommands: ['git'] });
+    expect(tool.getEffectiveConfig({ toolConfig: 'bogus' })).toEqual({ allowedCommands: ['git'] });
+    expect(tool.getEffectiveConfig({ toolConfig: 42 })).toEqual({ allowedCommands: ['git'] });
+  });
+
+  test('agents with empty toolConfig get plain global config', () => {
+    const tool = makeTool({ allowedCommands: ['git'] });
+    expect(tool.getEffectiveConfig({ toolConfig: {} })).toEqual({ allowedCommands: ['git'] });
+  });
+});