@gotza02/seq-thinking 1.1.22 → 1.1.24

package/dist/__tests__/agents/base-agent.js

@@ -0,0 +1,215 @@
+/**
+ * Base Agent Class
+ * @module agents/base-agent
+ * @version 1.0.0
+ */
+import { AgentType, AgentStatus } from '../types/index.js';
+import { Logger } from '../utils/logger.js';
+/**
+ * Abstract base class for all agents
+ */
+export class BaseAgent {
+    /** Agent ID */
+    id;
+    /** Agent configuration */
+    config;
+    /** Current status */
+    status = AgentStatus.IDLE;
+    /** Current task IDs */
+    currentTasks = new Set();
+    /** Performance history */
+    performanceHistory = [];
+    /** Message handlers */
+    messageHandlers = [];
+    /**
+     * Create a new base agent
+     * @param config - Agent configuration
+     */
+    constructor(config) {
+        this.id = config.id || `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        this.config = {
+            id: this.id,
+            name: config.name,
+            type: config.type || AgentType.UTILITY,
+            subtype: config.subtype,
+            capabilities: config.capabilities || [],
+            maxConcurrentTasks: config.maxConcurrentTasks || 3,
+            confidenceThreshold: config.confidenceThreshold || 0.7,
+            metadata: {
+                createdAt: new Date(),
+                version: '1.0.0',
+                config: config.metadata?.config || {}
+            }
+        };
+    }
+    /**
+     * Execute a task
+     * @param task - Task to execute
+     * @returns Task result
+     */
+    async execute(task) {
+        const startTime = Date.now();
+        this.status = AgentStatus.BUSY;
+        this.currentTasks.add(task.id);
+        try {
+            const result = await this.process(task);
+            const processingTime = Date.now() - startTime;
+            this.performanceHistory.push({
+                taskId: task.id,
+                quality: result.confidence,
+                timeMs: processingTime,
+                timestamp: new Date()
+            });
+            this.currentTasks.delete(task.id);
+            this.status = this.currentTasks.size === 0 ? AgentStatus.IDLE : AgentStatus.BUSY;
+            return result;
+        }
+        catch (error) {
+            this.currentTasks.delete(task.id);
+            this.status = this.currentTasks.size === 0 ? AgentStatus.IDLE : AgentStatus.BUSY;
+            return {
+                taskId: task.id,
+                agentId: this.id,
+                success: false,
+                output: null,
+                confidence: 0,
+                processingTimeMs: Date.now() - startTime,
+                metadata: {
+                    tokensUsed: 0,
+                    reasoningSteps: 0,
+                    intermediateResults: [],
+                    error: error instanceof Error ? error.message : String(error)
+                }
+            };
+        }
+    }
+    /**
+     * Register a message handler
+     * @param handler - Message handler function
+     * @returns Unsubscribe function
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+        return () => {
+            const index = this.messageHandlers.indexOf(handler);
+            if (index > -1) {
+                this.messageHandlers.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Receive a message
+     * @param message - Message to receive
+     */
+    receiveMessage(message) {
+        for (const handler of this.messageHandlers) {
+            try {
+                const result = handler(message);
+                if (result instanceof Promise) {
+                    result.catch(error => {
+                        Logger.error(`Error in message handler for agent ${this.id}`, { error });
+                    });
+                }
+            }
+            catch (error) {
+                Logger.error(`Error in message handler for agent ${this.id}`, { error });
+            }
+        }
+    }
+    /**
+     * Get agent status
+     * @returns Current status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Set agent status
+     * @param status - New status
+     */
+    setStatus(status) {
+        this.status = status;
+    }
+    /**
+     * Get current task IDs
+     * @returns Array of task IDs
+     */
+    getCurrentTasks() {
+        return Array.from(this.currentTasks);
+    }
+    /**
+     * Get performance metrics
+     * @returns Performance metrics
+     */
+    getPerformanceMetrics() {
+        if (this.performanceHistory.length === 0) {
+            return {
+                tasksCompleted: 0,
+                averageQuality: 0,
+                averageTimeMs: 0,
+                successRate: 0
+            };
+        }
+        const completed = this.performanceHistory.length;
+        const avgQuality = this.performanceHistory.reduce((sum, p) => sum + p.quality, 0) / completed;
+        const avgTime = this.performanceHistory.reduce((sum, p) => sum + p.timeMs, 0) / completed;
+        const successRate = this.performanceHistory.filter(p => p.quality > 0.5).length / completed;
+        return {
+            tasksCompleted: completed,
+            averageQuality: avgQuality,
+            averageTimeMs: avgTime,
+            successRate
+        };
+    }
+    /**
+     * Check if agent has a capability
+     * @param capabilityName - Capability name
+     * @returns True if agent has capability
+     */
+    hasCapability(capabilityName) {
+        return this.getCapabilities().some(c => c.name === capabilityName);
+    }
+    /**
+     * Get capability confidence
+     * @param capabilityName - Capability name
+     * @returns Confidence level (0-1)
+     */
+    getCapabilityConfidence(capabilityName) {
+        const cap = this.getCapabilities().find(c => c.name === capabilityName);
+        return cap?.confidence || 0;
+    }
+    /**
+     * Check if agent can handle a task
+     * @param task - Task to check
+     * @returns True if agent can handle task
+     */
+    canHandleTask(task) {
+        const requiredCaps = task.requirements.requiredCapabilities;
+        return requiredCaps.every(cap => this.hasCapability(cap));
+    }
+    /**
+     * Create a task result
+     * @param taskId - Task ID
+     * @param output - Output data
+     * @param confidence - Confidence level
+     * @param processingTimeMs - Processing time in ms
+     * @param metadata - Additional metadata
+     * @returns Task result
+     */
+    createTaskResult(taskId, output, confidence, processingTimeMs, metadata = {}) {
+        return {
+            taskId,
+            agentId: this.id,
+            success: confidence > 0.5,
+            output,
+            confidence,
+            processingTimeMs,
+            metadata: {
+                tokensUsed: metadata.tokensUsed || 0,
+                reasoningSteps: metadata.reasoningSteps || 1,
+                intermediateResults: metadata.intermediateResults || [],
+                error: metadata.error
+            }
+        };
+    }
+}

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

@@ -0,0 +1,75 @@
+/**
+ * Specialist Agent Implementation
+ * @module agents/specialist-agent
+ * @version 1.0.0
+ */
+import { BaseAgent } from './base-agent.js';
+import { AgentType } from '../types/index.js';
+import { LLMAdapter } from '../utils/llm-adapter.js';
+/**
+ * Specialist agent that focuses on specific domain capabilities
+ */
+export class SpecialistAgent extends BaseAgent {
+    /**
+     * Create a new specialist agent
+     * @param config - Agent configuration
+     */
+    constructor(config) {
+        // Convert string capabilities to AgentCapability objects if needed
+        const normalizedCapabilities = (config.capabilities || []).map(cap => {
+            if (typeof cap === 'string') {
+                return {
+                    name: cap,
+                    description: `Specialized capability: ${cap}`,
+                    confidence: 0.8,
+                    performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+                };
+            }
+            return cap;
+        });
+        super({
+            name: config.name,
+            type: AgentType.SPECIALIST,
+            capabilities: normalizedCapabilities,
+            confidenceThreshold: config.confidenceThreshold || 0.7
+        });
+    }
+    /**
+     * Get agent type
+     * @returns Agent type
+     */
+    getType() {
+        return AgentType.SPECIALIST;
+    }
+    /**
+     * Get agent capabilities
+     * @returns Array of capabilities
+     */
+    getCapabilities() {
+        return this.config.capabilities;
+    }
+    /**
+     * Process a task using specialist domain knowledge
+     * @param task - Task to process
+     * @returns Task result
+     */
+    async process(task) {
+        const startTime = Date.now();
+        const input = typeof task.input === 'string' ? task.input : JSON.stringify(task.input);
+        const capabilitiesList = this.getCapabilities().map(c => c.name).join(', ');
+        const prompt = `You are a specialist agent named "${this.config.name}" with expertise in: ${capabilitiesList}.
+Your task is: ${task.description}
+Input details: ${input}
+
+Provide a detailed expert response based on your specialized knowledge.`;
+        const systemPrompt = `You are an expert specialist in ${capabilitiesList}. Provide precise, high-quality technical or domain-specific analysis.`;
+        const response = await LLMAdapter.call(prompt, systemPrompt);
+        const output = response.content || `Error: ${response.error}`;
+        const confidence = response.error ? 0 : 0.85;
+        return this.createTaskResult(task.id, {
+            conclusion: output,
+            specialistRole: this.config.name,
+            capabilitiesUsed: this.getCapabilities().map(c => c.name)
+        }, confidence, Date.now() - startTime);
+    }
+}