@gotza02/seq-thinking 1.1.0

package/src/agents/reasoner-agent.ts

@@ -0,0 +1,312 @@
+/**
+ * Reasoner Agent Implementation
+ * @module agents/reasoner-agent
+ * @version 1.0.0
+ */
+
+import { BaseAgent } from './base-agent.js';
+import {
+  AgentType,
+  ReasoningStrategy,
+  type Task,
+  type TaskResult,
+  type AgentCapability
+} from '../types/index.js';
+import { LLMAdapter } from '../utils/llm-adapter.js';
+
+/**
+ * Reasoning step
+ */
+interface ReasoningStep {
+  step: number;
+  content: string;
+  confidence: number;
+  isFinal: boolean;
+}
+
+/**
+ * Reasoner agent that performs various reasoning strategies
+ */
+export class ReasonerAgent extends BaseAgent {
+  /** Reasoning strategy */
+  private strategy: ReasoningStrategy;
+  
+  /** Maximum iterations */
+  private maxIterations: number;
+  
+  /** Confidence threshold */
+  private confidenceThreshold: number;
+
+  /**
+   * Create a new reasoner agent
+   * @param config - Agent configuration
+   */
+  constructor(config: {
+    name: string;
+    strategy?: ReasoningStrategy;
+    maxIterations?: number;
+    confidenceThreshold?: number;
+    capabilities?: AgentCapability[];
+  }) {
+    const defaultCapabilities: AgentCapability[] = [
+      {
+        name: 'chain_of_thought',
+        description: 'Step-by-step reasoning',
+        confidence: 0.9,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'tree_of_thought',
+        description: 'Explore multiple reasoning paths',
+        confidence: 0.85,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'analogical_reasoning',
+        description: 'Reason by analogy',
+        confidence: 0.8,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'abductive_reasoning',
+        description: 'Inference to best explanation',
+        confidence: 0.75,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'problem_solving',
+        description: 'General problem-solving',
+        confidence: 0.8,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      }
+    ];
+
+    super({
+      name: config.name,
+      type: AgentType.REASONER,
+      subtype: config.strategy || ReasoningStrategy.CHAIN_OF_THOUGHT,
+      capabilities: config.capabilities || defaultCapabilities,
+      maxConcurrentTasks: 3,
+      confidenceThreshold: config.confidenceThreshold || 0.7
+    });
+
+    this.strategy = config.strategy || ReasoningStrategy.CHAIN_OF_THOUGHT;
+    this.maxIterations = config.maxIterations || 10;
+    this.confidenceThreshold = config.confidenceThreshold || 0.7;
+  }
+
+  /**
+   * Get agent type
+   * @returns Agent type
+   */
+  getType(): string {
+    return AgentType.REASONER;
+  }
+
+  /**
+   * Get agent capabilities
+   * @returns Array of capabilities
+   */
+  getCapabilities(): AgentCapability[] {
+    return this.config.capabilities;
+  }
+
+  /**
+   * Process a task using the configured reasoning strategy
+   * @param task - Task to process
+   * @returns Task result
+   */
+  async process(task: Task): Promise<TaskResult> {
+    const startTime = Date.now();
+
+    switch (this.strategy) {
+      case ReasoningStrategy.CHAIN_OF_THOUGHT:
+        return this.chainOfThought(task, startTime);
+      case ReasoningStrategy.TREE_OF_THOUGHT:
+        return this.treeOfThought(task, startTime);
+      case ReasoningStrategy.ANALOGICAL:
+        return this.analogicalReasoning(task, startTime);
+      case ReasoningStrategy.ABDUCTIVE:
+        return this.abductiveReasoning(task, startTime);
+      default:
+        return this.chainOfThought(task, startTime);
+    }
+  }
+
+  /**
+   * Chain of thought reasoning
+   * @param task - Task to process
+   * @param startTime - Start time
+   * @returns Task result
+   */
+  private async chainOfThought(task: Task, startTime: number): Promise<TaskResult> {
+    const steps: ReasoningStep[] = [];
+    const input = task.input as { problem?: string; question?: string };
+    const problem = input.problem || input.question || String(task.input);
+
+    let iteration = 0;
+    let currentContext = problem;
+
+    while (iteration < this.maxIterations) {
+      iteration++;
+
+      const prompt = `Based on the current context, generate the next reasoning step. 
+Current Context: ${currentContext}
+Iteration: ${iteration}
+Problem: ${problem}`;
+      
+      const response = await LLMAdapter.call(prompt, "You are a logical reasoner. Provide one clear reasoning step.");
+      const stepContent = response.content || `Error: ${response.error}`;
+      
+      const stepConfidence = this.calculateStepConfidence(stepContent, iteration);
+
+      const step: ReasoningStep = {
+        step: iteration,
+        content: stepContent,
+        confidence: stepConfidence,
+        isFinal: iteration >= this.maxIterations - 1 || stepConfidence >= this.confidenceThreshold || !!response.error
+      };
+
+      steps.push(step);
+
+      if (step.isFinal) {
+        break;
+      }
+
+      currentContext += `\n${stepContent}`;
+    }
+
+    const conclusionPrompt = `Based on these reasoning steps, provide a final conclusion for the problem: "${problem}"\n\nSteps:\n${steps.map(s => s.content).join('\n')}`;
+    const conclusionResponse = await LLMAdapter.call(conclusionPrompt);
+    const conclusion = conclusionResponse.content || "Failed to generate conclusion.";
+
+    const avgConfidence = steps.length > 0
+      ? steps.reduce((sum, s) => sum + s.confidence, 0) / steps.length
+      : 0;
+
+    return this.createTaskResult(
+      task.id,
+      {
+        conclusion,
+        reasoningChain: steps,
+        iterations: iteration,
+        strategy: 'chain_of_thought',
+        problem
+      },
+      avgConfidence,
+      Date.now() - startTime,
+      {
+        reasoningSteps: steps.length,
+        intermediateResults: steps.map(s => s.content)
+      }
+    );
+  }
+
+  /**
+   * Tree of thought reasoning
+   * @param task - Task to process
+   * @param startTime - Start time
+   * @returns Task result
+   */
+  private async treeOfThought(task: Task, startTime: number): Promise<TaskResult> {
+    const input = task.input as { problem?: string; question?: string };
+    const problem = input.problem || input.question || String(task.input);
+
+    const numPaths = 3;
+    const candidates: Array<{
+      path: ReasoningStep[];
+      confidence: number;
+    }> = [];
+
+    for (let i = 0; i < numPaths; i++) {
+      const prompt = `Solve this problem by exploring one specific reasoning path: "${problem}"\nPath #${i+1}:`;
+      const response = await LLMAdapter.call(prompt, "You are a creative reasoner. Explore an alternative path.");
+      
+      const step: ReasoningStep = {
+        step: 1,
+        content: response.content || "Failed to generate path.",
+        confidence: 0.7 + Math.random() * 0.2,
+        isFinal: true
+      };
+      
+      candidates.push({ path: [step], confidence: step.confidence });
+    }
+
+    const best = candidates.reduce((max, c) =>
+      c.confidence > max.confidence ? c : max,
+      candidates[0]
+    );
+
+    return this.createTaskResult(
+      task.id,
+      {
+        conclusion: best.path[0].content,
+        bestPath: best.path,
+        pathsExplored: candidates.length,
+        strategy: 'tree_of_thought',
+        problem
+      },
+      best.confidence,
+      Date.now() - startTime
+    );
+  }
+
+  /**
+   * Analogical reasoning
+   * @param task - Task to process
+   * @param startTime - Start time
+   * @returns Task result
+   */
+  private async analogicalReasoning(task: Task, startTime: number): Promise<TaskResult> {
+    const input = task.input as { problem?: string; question?: string; domain?: string };
+    const problem = input.problem || input.question || String(task.input);
+
+    const prompt = `Reason about this problem using analogies from other domains: "${problem}"`;
+    const response = await LLMAdapter.call(prompt, "You are an expert at analogical reasoning.");
+    const conclusion = response.content || "Failed to generate analogical reasoning.";
+
+    return this.createTaskResult(
+      task.id,
+      {
+        conclusion,
+        strategy: 'analogical',
+        problem
+      },
+      0.85,
+      Date.now() - startTime
+    );
+  }
+
+  /**
+   * Abductive reasoning
+   * @param task - Task to process
+   * @param startTime - Start time
+   * @returns Task result
+   */
+  private async abductiveReasoning(task: Task, startTime: number): Promise<TaskResult> {
+    const input = task.input as { observation?: string; problem?: string };
+    const observation = input.observation || input.problem || String(task.input);
+
+    const prompt = `Provide the best possible explanation (abductive reasoning) for this observation: "${observation}"`;
+    const response = await LLMAdapter.call(prompt, "You are an expert at abductive reasoning.");
+    const conclusion = response.content || "Failed to generate explanation.";
+
+    return this.createTaskResult(
+      task.id,
+      {
+        conclusion,
+        strategy: 'abductive',
+        observation
+      },
+      0.8,
+      Date.now() - startTime
+    );
+  }
+
+  private calculateStepConfidence(content: string, step: number): number {
+    const baseConfidence = 0.5;
+    const stepBonus = Math.min(0.3, step * 0.03);
+    const contentBonus = content.length > 50 ? 0.1 : 0;
+    return Math.min(0.95, baseConfidence + stepBonus + contentBonus);
+  }
+}