@gotza02/seq-thinking 1.1.21 → 1.1.23

package/dist/__tests__/specialist-agent.test.js

@@ -1,39 +1,662 @@
-import { test, describe } from 'node:test';
+/**
+ * Specialist Agent Test Suite
+ * Comprehensive tests for SpecialistAgent including unit tests and integration tests
+ * @module tests/specialist-agent
+ * @version 1.0.0
+ */
+import { describe, test, beforeEach, before } from 'node:test';
 import assert from 'node:assert';
 import { SpecialistAgent } from '../agents/specialist-agent.js';
-import { AgentType } from '../types/index.js';
+import { AgentType, TaskStatus } from '../types/index.js';
 describe('SpecialistAgent', () => {
-    test('should return correct type', () => {
-        const agent = new SpecialistAgent({ name: 'Test Specialist' });
-        assert.strictEqual(agent.getType(), AgentType.SPECIALIST);
+    let agent;
+    const originalEnv = process.env.MOCK_LLM;
+    // Enable LLM mocking before all tests
+    before(() => {
+        process.env.MOCK_LLM = 'true';
     });
-    test('should handle string capabilities', () => {
-        const agent = new SpecialistAgent({
-            name: 'Test Specialist',
-            capabilities: ['logic', 'math']
-        });
-        const caps = agent.getCapabilities();
-        assert.strictEqual(caps.length, 2);
-        assert.strictEqual(caps[0].name, 'logic');
-        assert.strictEqual(caps[1].name, 'math');
+    // Cleanup after all tests
+    beforeEach(() => {
+        process.env.MOCK_LLM = 'true';
     });
-    test('should check if can handle task', () => {
-        const agent = new SpecialistAgent({
-            name: 'Test Specialist',
-            capabilities: ['logic', 'math']
-        });
-        const task = {
-            requirements: {
-                requiredCapabilities: ['logic']
+    describe('Unit Tests - Agent Creation', () => {
+        test('should create specialist agent with default configuration', () => {
+            const defaultAgent = new SpecialistAgent({ name: 'Test Specialist' });
+            assert.strictEqual(defaultAgent.config.name, 'Test Specialist');
+            assert.strictEqual(defaultAgent.getType(), AgentType.SPECIALIST);
+            assert.ok(defaultAgent.id);
+            assert.ok(typeof defaultAgent.id === 'string');
+        });
+        test('should create specialist agent with single capability', () => {
+            const singleCapAgent = new SpecialistAgent({
+                name: 'Code Review Specialist',
+                capabilities: [
+                    {
+                        name: 'code-review',
+                        description: 'Review code for quality and bugs',
+                        confidence: 0.9,
+                        performanceMetrics: {
+                            tasksCompleted: 0,
+                            averageQuality: 0,
+                            averageTimeMs: 0
+                        }
+                    }
+                ]
+            });
+            const caps = singleCapAgent.getCapabilities();
+            assert.strictEqual(caps.length, 1);
+            assert.strictEqual(caps[0].name, 'code-review');
+            assert.strictEqual(caps[0].confidence, 0.9);
+        });
+        test('should create specialist agent with multiple capabilities', () => {
+            agent = new SpecialistAgent({
+                name: 'Security Specialist',
+                capabilities: [
+                    {
+                        name: 'security-audit',
+                        description: 'Security audit and vulnerability assessment',
+                        confidence: 0.9,
+                        performanceMetrics: {
+                            tasksCompleted: 10,
+                            averageQuality: 0.85,
+                            averageTimeMs: 1200
+                        }
+                    },
+                    {
+                        name: 'penetration-testing',
+                        description: 'Penetration testing and exploitation',
+                        confidence: 0.85,
+                        performanceMetrics: {
+                            tasksCompleted: 5,
+                            averageQuality: 0.9,
+                            averageTimeMs: 3000
+                        }
+                    },
+                    {
+                        name: 'threat-analysis',
+                        description: 'Threat modeling and analysis',
+                        confidence: 0.88,
+                        performanceMetrics: {
+                            tasksCompleted: 8,
+                            averageQuality: 0.82,
+                            averageTimeMs: 1500
+                        }
+                    }
+                ]
+            });
+            const caps = agent.getCapabilities();
+            assert.strictEqual(caps.length, 3);
+            assert.ok(caps.some(c => c.name === 'security-audit'));
+            assert.ok(caps.some(c => c.name === 'penetration-testing'));
+            assert.ok(caps.some(c => c.name === 'threat-analysis'));
+        });
+        test('should normalize string capabilities to AgentCapability objects', () => {
+            const stringCapAgent = new SpecialistAgent({
+                name: 'String Capabilities Specialist',
+                capabilities: ['logic', 'math', 'statistics', 'data-analysis']
+            });
+            const caps = stringCapAgent.getCapabilities();
+            assert.strictEqual(caps.length, 4);
+            // Check that all capabilities are properly normalized
+            caps.forEach((cap, index) => {
+                assert.ok(cap.name);
+                assert.ok(cap.description.includes(cap.name));
+                assert.strictEqual(cap.confidence, 0.8);
+                assert.strictEqual(cap.performanceMetrics.tasksCompleted, 0);
+            });
+            assert.strictEqual(caps[0].name, 'logic');
+            assert.strictEqual(caps[1].name, 'math');
+            assert.strictEqual(caps[2].name, 'statistics');
+            assert.strictEqual(caps[3].name, 'data-analysis');
+        });
+        test('should handle mixed string and object capabilities', () => {
+            const mixedCapAgent = new SpecialistAgent({
+                name: 'Mixed Capabilities Specialist',
+                capabilities: [
+                    'string-cap-1',
+                    {
+                        name: 'object-cap-1',
+                        description: 'An object capability',
+                        confidence: 0.95,
+                        performanceMetrics: {
+                            tasksCompleted: 5,
+                            averageQuality: 0.9,
+                            averageTimeMs: 1000
+                        }
+                    },
+                    'string-cap-2'
+                ]
+            });
+            const caps = mixedCapAgent.getCapabilities();
+            assert.strictEqual(caps.length, 3);
+            // String capability should be normalized
+            assert.strictEqual(caps[0].name, 'string-cap-1');
+            assert.strictEqual(caps[0].confidence, 0.8);
+            // Object capability should preserve values
+            assert.strictEqual(caps[1].name, 'object-cap-1');
+            assert.strictEqual(caps[1].confidence, 0.95);
+            // String capability should be normalized
+            assert.strictEqual(caps[2].name, 'string-cap-2');
+            assert.strictEqual(caps[2].confidence, 0.8);
+        });
+        test('should handle empty capabilities array', () => {
+            const emptyCapAgent = new SpecialistAgent({
+                name: 'Empty Capabilities Specialist',
+                capabilities: []
+            });
+            const caps = emptyCapAgent.getCapabilities();
+            assert.strictEqual(caps.length, 0);
+        });
+        test('should handle undefined capabilities', () => {
+            const undefinedCapAgent = new SpecialistAgent({
+                name: 'Undefined Capabilities Specialist'
+            });
+            const caps = undefinedCapAgent.getCapabilities();
+            assert.strictEqual(caps.length, 0);
+        });
+        test('should use default confidence threshold when not specified', () => {
+            const defaultThresholdAgent = new SpecialistAgent({
+                name: 'Default Threshold Specialist',
+                capabilities: ['test']
+            });
+            assert.strictEqual(defaultThresholdAgent.config.confidenceThreshold, 0.7);
+        });
+        test('should use custom confidence threshold when specified', () => {
+            const customThresholdAgent = new SpecialistAgent({
+                name: 'Custom Threshold Specialist',
+                capabilities: ['test'],
+                confidenceThreshold: 0.85
+            });
+            assert.strictEqual(customThresholdAgent.config.confidenceThreshold, 0.85);
+        });
+        test('should have unique ID for each agent instance', () => {
+            const agent1 = new SpecialistAgent({ name: 'Agent 1' });
+            const agent2 = new SpecialistAgent({ name: 'Agent 2' });
+            const agent3 = new SpecialistAgent({ name: 'Agent 3' });
+            assert.notStrictEqual(agent1.id, agent2.id);
+            assert.notStrictEqual(agent2.id, agent3.id);
+            assert.notStrictEqual(agent1.id, agent3.id);
+        });
+    });
+    describe('Unit Tests - Capability Checking', () => {
+        beforeEach(() => {
+            agent = new SpecialistAgent({
+                name: 'Test Specialist',
+                capabilities: [
+                    { name: 'code-review', description: 'Code review', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } },
+                    { name: 'security-audit', description: 'Security audit', confidence: 0.85, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } },
+                    { name: 'performance-optimization', description: 'Performance optimization', confidence: 0.8, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+        });
+        test('should return correct type', () => {
+            assert.strictEqual(agent.getType(), AgentType.SPECIALIST);
+        });
+        test('should check if has specific capability', () => {
+            assert.strictEqual(agent.hasCapability('code-review'), true);
+            assert.strictEqual(agent.hasCapability('security-audit'), true);
+            assert.strictEqual(agent.hasCapability('performance-optimization'), true);
+            assert.strictEqual(agent.hasCapability('non-existent'), false);
+        });
+        test('should get capability confidence', () => {
+            assert.strictEqual(agent.getCapabilityConfidence('code-review'), 0.9);
+            assert.strictEqual(agent.getCapabilityConfidence('security-audit'), 0.85);
+            assert.strictEqual(agent.getCapabilityConfidence('performance-optimization'), 0.8);
+            assert.strictEqual(agent.getCapabilityConfidence('unknown'), 0);
+        });
+        test('should check if can handle task with required capabilities', () => {
+            const taskWithMatchingCaps = createMockTask({
+                requirements: {
+                    requiredCapabilities: ['code-review'],
+                    minConfidence: 0.5,
+                    maxTimeMs: 5000
+                }
+            });
+            const taskWithMultipleMatchingCaps = createMockTask({
+                requirements: {
+                    requiredCapabilities: ['code-review', 'security-audit'],
+                    minConfidence: 0.5,
+                    maxTimeMs: 5000
+                }
+            });
+            const taskWithNonMatchingCaps = createMockTask({
+                requirements: {
+                    requiredCapabilities: ['machine-learning'],
+                    minConfidence: 0.5,
+                    maxTimeMs: 5000
+                }
+            });
+            const taskWithPartialMatchingCaps = createMockTask({
+                requirements: {
+                    requiredCapabilities: ['code-review', 'machine-learning'],
+                    minConfidence: 0.5,
+                    maxTimeMs: 5000
+                }
+            });
+            assert.strictEqual(agent.canHandleTask(taskWithMatchingCaps), true);
+            assert.strictEqual(agent.canHandleTask(taskWithMultipleMatchingCaps), true);
+            assert.strictEqual(agent.canHandleTask(taskWithNonMatchingCaps), false);
+            assert.strictEqual(agent.canHandleTask(taskWithPartialMatchingCaps), false);
+        });
+        test('should return all capabilities', () => {
+            const caps = agent.getCapabilities();
+            assert.ok(Array.isArray(caps));
+            assert.strictEqual(caps.length, 3);
+            caps.forEach(cap => {
+                assert.ok(cap.name);
+                assert.ok(cap.description);
+                assert.ok(typeof cap.confidence === 'number');
+                assert.ok(cap.performanceMetrics);
+            });
+        });
+    });
+    describe('Unit Tests - Task Processing', () => {
+        beforeEach(() => {
+            process.env.MOCK_LLM = 'true';
+            agent = new SpecialistAgent({
+                name: 'Code Review Specialist',
+                capabilities: [
+                    { name: 'code-review', description: 'Code review', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } },
+                    { name: 'security-audit', description: 'Security audit', confidence: 0.85, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+        });
+        test('should process task with single capability', async () => {
+            const task = createMockTask({
+                type: 'code-review',
+                description: 'Review this code for bugs',
+                input: { code: 'function add(a, b) { return a + b; }' }
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.taskId, task.id);
+            assert.strictEqual(result.agentId, agent.id);
+            assert.strictEqual(result.success, true);
+            assert.ok(result.output);
+        });
+        test('should process task with multiple capabilities', async () => {
+            const task = createMockTask({
+                type: 'security-audit',
+                description: 'Audit code for security vulnerabilities',
+                input: { code: 'eval(userInput);', language: 'javascript' }
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.taskId, task.id);
+            assert.strictEqual(result.agentId, agent.id);
+            assert.strictEqual(result.success, true);
+            assert.ok(result.output);
+        });
+        test('should include capabilities in prompt output', async () => {
+            const task = createMockTask({
+                description: 'Test task',
+                input: { data: 'test' }
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.ok(result.output);
+            // Output should contain conclusion with capabilities used
+            const output = result.output;
+            assert.ok(output.conclusion);
+            assert.ok(output.specialistRole);
+            assert.strictEqual(output.specialistRole, 'Code Review Specialist');
+            assert.ok(Array.isArray(output.capabilitiesUsed));
+            assert.ok(output.capabilitiesUsed.includes('code-review'));
+            assert.ok(output.capabilitiesUsed.includes('security-audit'));
+        });
+        test('should return success result on LLM success', async () => {
+            const task = createMockTask({
+                description: 'Successful task',
+                input: { data: 'test' }
+            });
+            const result = await agent.process(task);
+            assert.strictEqual(result.success, true);
+            assert.ok(result.confidence > 0);
+            assert.ok(result.processingTimeMs >= 0);
+        });
+        test('should set correct confidence on success', async () => {
+            const task = createMockTask({
+                description: 'Test confidence',
+                input: {}
+            });
+            const result = await agent.process(task);
+            // When LLM succeeds, confidence should be 0.85
+            assert.strictEqual(result.confidence, 0.85);
+        });
+        test('should handle task with empty input', async () => {
+            const task = createMockTask({
+                description: 'Empty input task',
+                input: {}
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+        test('should handle task with string input', async () => {
+            const task = createMockTask({
+                description: 'String input task',
+                input: 'This is a string input'
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+        test('should handle task with complex nested input', async () => {
+            const task = createMockTask({
+                description: 'Complex input task',
+                input: {
+                    users: [
+                        { id: 1, name: 'Alice', roles: ['admin', 'user'] },
+                        { id: 2, name: 'Bob', roles: ['user'] }
+                    ],
+                    settings: {
+                        theme: 'dark',
+                        notifications: true,
+                        preferences: {
+                            language: 'en',
+                            timezone: 'UTC'
+                        }
+                    }
+                }
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+        test('should handle task with null input', async () => {
+            const task = createMockTask({
+                description: 'Null input task',
+                input: null
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+        test('should handle task with array input', async () => {
+            const task = createMockTask({
+                description: 'Array input task',
+                input: [1, 2, 3, 4, 5]
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+        test('should handle long description', async () => {
+            const task = createMockTask({
+                description: 'This is a very long description that contains a lot of text and details about what needs to be done for this particular task. It should be handled properly without any issues.',
+                input: { data: 'test' }
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+    });
+    describe('Integration Tests', () => {
+        beforeEach(() => {
+            process.env.MOCK_LLM = 'true';
+        });
+        test('should handle complex task input with mixed data types', async () => {
+            const complexAgent = new SpecialistAgent({
+                name: 'Data Analysis Specialist',
+                capabilities: [
+                    { name: 'data-analysis', description: 'Data analysis', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } },
+                    { name: 'visualization', description: 'Data visualization', confidence: 0.85, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            const task = createMockTask({
+                type: 'data-analysis',
+                description: 'Analyze sales data and create visualizations',
+                input: {
+                    salesData: [
+                        { month: 'Jan', revenue: 10000, units: 100 },
+                        { month: 'Feb', revenue: 15000, units: 150 },
+                        { month: 'Mar', revenue: 12000, units: 120 }
+                    ],
+                    targetRevenue: 14000,
+                    options: {
+                        includeTrends: true,
+                        includeForecast: false,
+                        chartTypes: ['line', 'bar']
+                    },
+                    metadata: {
+                        source: 'CRM',
+                        lastUpdated: new Date().toISOString()
+                    }
+                }
+            });
+            const result = await complexAgent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+            assert.ok(result.output);
+            assert.strictEqual(result.confidence, 0.85);
+        });
+        test('should process different task types', async () => {
+            const agent = new SpecialistAgent({
+                name: 'Multi-Purpose Specialist',
+                capabilities: [
+                    { name: 'code-review', description: 'Code review', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } },
+                    { name: 'documentation', description: 'Documentation', confidence: 0.85, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } },
+                    { name: 'refactoring', description: 'Refactoring', confidence: 0.88, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            // Code review task
+            const codeReviewTask = createMockTask({
+                type: 'code-review',
+                description: 'Review pull request',
+                input: { code: 'const x = 1;' }
+            });
+            // Documentation task
+            const docTask = createMockTask({
+                type: 'documentation',
+                description: 'Generate API docs',
+                input: { endpoints: ['/api/users', '/api/posts'] }
+            });
+            // Refactoring task
+            const refactoringTask = createMockTask({
+                type: 'refactoring',
+                description: 'Refactor legacy code',
+                input: { file: 'legacy.js', lines: 1000 }
+            });
+            const result1 = await agent.process(codeReviewTask);
+            const result2 = await agent.process(docTask);
+            const result3 = await agent.process(refactoringTask);
+            assert.strictEqual(result1.success, true);
+            assert.strictEqual(result2.success, true);
+            assert.strictEqual(result3.success, true);
+        });
+        test('should execute task through execute method', async () => {
+            const agent = new SpecialistAgent({
+                name: 'Execute Test Specialist',
+                capabilities: [
+                    { name: 'test', description: 'Test capability', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            const task = createMockTask({
+                description: 'Execute test',
+                input: { test: true }
+            });
+            const result = await agent.execute(task);
+            assert.ok(result);
+            assert.strictEqual(result.taskId, task.id);
+            assert.strictEqual(result.agentId, agent.id);
+            assert.strictEqual(result.success, true);
+            assert.ok(result.output);
+            assert.ok(typeof result.confidence === 'number');
+            assert.ok(typeof result.processingTimeMs === 'number');
+        });
+        test('should track performance metrics after task execution', async () => {
+            const agent = new SpecialistAgent({
+                name: 'Metrics Test Specialist',
+                capabilities: [
+                    { name: 'metrics-test', description: 'Metrics test', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            const initialMetrics = agent.getPerformanceMetrics();
+            assert.strictEqual(initialMetrics.tasksCompleted, 0);
+            // Execute multiple tasks
+            for (let i = 0; i < 3; i++) {
+                await agent.execute(createMockTask({
+                    description: `Task ${i}`,
+                    input: { index: i }
+                }));
             }
-        };
-        assert.ok(agent.canHandleTask(task));
-        const hardTask = {
-            requirements: {
-                requiredCapabilities: ['physics']
+            const finalMetrics = agent.getPerformanceMetrics();
+            assert.strictEqual(finalMetrics.tasksCompleted, 3);
+            assert.ok(finalMetrics.successRate >= 0 && finalMetrics.successRate <= 1);
+        });
+        test('should handle multiple sequential tasks', async () => {
+            const agent = new SpecialistAgent({
+                name: 'Sequential Test Specialist',
+                capabilities: [
+                    { name: 'sequential', description: 'Sequential processing', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            const results = [];
+            for (let i = 0; i < 5; i++) {
+                const task = createMockTask({
+                    description: `Sequential task ${i}`,
+                    input: { sequence: i }
+                });
+                const result = await agent.process(task);
+                results.push(result);
             }
-        };
-        assert.ok(!agent.canHandleTask(hardTask));
+            assert.strictEqual(results.length, 5);
+            results.forEach((result, index) => {
+                assert.strictEqual(result.success, true);
+                assert.ok(result.output);
+            });
+        });
+        test('should handle task with special characters in input', async () => {
+            const agent = new SpecialistAgent({
+                name: 'Special Chars Specialist',
+                capabilities: [
+                    { name: 'text-processing', description: 'Text processing', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            const task = createMockTask({
+                description: 'Process text with special characters',
+                input: {
+                    text: 'Special chars: <>&"\'\\n\\t`~!@#$%^&*()_+-=[]{}|;:,.<>?'
+                }
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+        test('should handle task with unicode input', async () => {
+            const agent = new SpecialistAgent({
+                name: 'Unicode Specialist',
+                capabilities: [
+                    { name: 'unicode-processing', description: 'Unicode processing', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            const task = createMockTask({
+                description: 'Process unicode text',
+                input: {
+                    text: 'Unicode: 你好世界 🌍 Привет мир مرحبا بالعالم'
+                }
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+    });
+    describe('Edge Cases and Error Handling', () => {
+        test('should handle task with very long input', async () => {
+            process.env.MOCK_LLM = 'true';
+            const agent = new SpecialistAgent({
+                name: 'Long Input Specialist',
+                capabilities: [
+                    { name: 'processing', description: 'Processing', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            const longString = 'a'.repeat(10000);
+            const task = createMockTask({
+                description: 'Process long input',
+                input: { data: longString }
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+        test('should handle task with deeply nested input', async () => {
+            process.env.MOCK_LLM = 'true';
+            const agent = new SpecialistAgent({
+                name: 'Nested Input Specialist',
+                capabilities: [
+                    { name: 'processing', description: 'Processing', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            // Create deeply nested object
+            let nested = { value: 'deep' };
+            for (let i = 0; i < 10; i++) {
+                nested = { nested: nested };
+            }
+            const task = createMockTask({
+                description: 'Process nested input',
+                input: nested
+            });
+            const result = await agent.process(task);
+            assert.ok(result);
+            assert.strictEqual(result.success, true);
+        });
+        test('should set status during execution', async () => {
+            process.env.MOCK_LLM = 'true';
+            const agent = new SpecialistAgent({
+                name: 'Status Test Specialist',
+                capabilities: [
+                    { name: 'status-test', description: 'Status test', confidence: 0.9, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            const task = createMockTask({
+                description: 'Status test',
+                input: {}
+            });
+            // Before execution, status should be idle
+            assert.strictEqual(agent.getStatus(), 'idle');
+            const result = await agent.execute(task);
+            // After execution, status should return to idle
+            assert.strictEqual(agent.getStatus(), 'idle');
+            assert.ok(result);
+        });
+        test('should handle capabilities with zero confidence', () => {
+            const agent = new SpecialistAgent({
+                name: 'Zero Confidence Specialist',
+                capabilities: [
+                    { name: 'zero-cap', description: 'Zero confidence capability', confidence: 0, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            assert.strictEqual(agent.getCapabilityConfidence('zero-cap'), 0);
+            assert.strictEqual(agent.hasCapability('zero-cap'), true);
+        });
+        test('should handle capability with very high confidence', () => {
+            const agent = new SpecialistAgent({
+                name: 'High Confidence Specialist',
+                capabilities: [
+                    { name: 'high-cap', description: 'High confidence capability', confidence: 0.999, performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 } }
+                ]
+            });
+            assert.strictEqual(agent.getCapabilityConfidence('high-cap'), 0.999);
+        });
     });
 });
-//# sourceMappingURL=specialist-agent.test.js.map
+// Helper function to create mock tasks
+function createMockTask(overrides = {}) {
+    return {
+        id: `task-${Math.random().toString(36).substr(2, 9)}`,
+        type: 'test',
+        description: 'Test task',
+        input: {},
+        context: { dependencies: [] },
+        requirements: {
+            requiredCapabilities: [],
+            minConfidence: 0.5,
+            maxTimeMs: 5000,
+        },
+        assignedAgentId: null,
+        status: TaskStatus.PENDING,
+        result: null,
+        metadata: { createdAt: new Date() },
+        ...overrides,
+    };
+}