@gotza02/seq-thinking 1.1.4 → 1.1.6

package/src/agents/meta-reasoning-agent.ts

@@ -1,314 +0,0 @@
-/**
- * Meta-Reasoning Agent Implementation
- * @module agents/meta-reasoning-agent
- * @version 1.0.0
- */
-
-import { BaseAgent } from './base-agent.js';
-import {
-  AgentType,
-  ThoughtType,
-  type Task,
-  type TaskResult,
-  type AgentCapability,
-  type Thought,
-  type ThinkingSession
-} from '../types/index.js';
-import { LLMAdapter } from '../utils/llm-adapter.js';
-
-/**
- * Meta-observation
- */
-interface MetaObservation {
-  type: 'pattern' | 'concern' | 'insight' | 'suggestion';
-  description: string;
-  severity?: 'low' | 'medium' | 'high';
-  recommendation?: string;
-  triggeredActions?: string[];
-}
-
-/**
- * Meta-reasoning agent that reflects on thinking processes using LLM
- */
-export class MetaReasoningAgent extends BaseAgent {
-  /** Observation history */
-  private observationHistory: MetaObservation[] = [];
-
-  /**
-   * Create a new meta-reasoning agent
-   * @param config - Agent configuration
-   */
-  constructor(config: {
-    name: string;
-    capabilities?: AgentCapability[];
-  }) {
-    const defaultCapabilities: AgentCapability[] = [
-      {
-        name: 'process_reflection',
-        description: 'Reflect on thinking processes using LLM',
-        confidence: 0.95,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'strategy_assessment',
-        description: 'Assess reasoning strategies using LLM',
-        confidence: 0.9,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'bias_detection',
-        description: 'Detect cognitive biases using LLM',
-        confidence: 0.85,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'pattern_analysis',
-        description: 'Analyze thinking patterns using LLM',
-        confidence: 0.9,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      }
-    ];
-
-    super({
-      name: config.name,
-      type: AgentType.META_REASONING,
-      capabilities: config.capabilities || defaultCapabilities,
-      maxConcurrentTasks: 5,
-      confidenceThreshold: 0.7
-    });
-  }
-
-  /**
-   * Get agent type
-   * @returns Agent type
-   */
-  getType(): string {
-    return AgentType.META_REASONING;
-  }
-
-  /**
-   * Get agent capabilities
-   * @returns Array of capabilities
-   */
-  getCapabilities(): AgentCapability[] {
-    return this.config.capabilities;
-  }
-
-  /**
-   * Process a task - perform meta-reasoning using LLM
-   * @param task - Task to process
-   * @returns Task result
-   */
-  async process(task: Task): Promise<TaskResult> {
-    const startTime = Date.now();
-    const input = task.input as {
-      session?: ThinkingSession;
-      thoughts?: Thought[];
-      operation: 'reflect' | 'analyze_patterns' | 'assess_strategy' | 'detect_bias';
-    };
-
-    const provider = (task.context as any)?.modelProvider;
-
-    let prompt = '';
-    let systemPrompt = 'You are a meta-reasoning agent. Your role is to analyze and reflect on the thinking processes of other agents or sessions, identifying patterns, biases, and areas for improvement.';
-
-    const sessionData = input.session ? `Session Topic: ${input.session.topic}\nSession Status: ${input.session.status}\n` : '';
-    const thoughtsData = (input.thoughts || (input.session ? Array.from(input.session.thoughts.values()) : []))
-      .map(t => `Step ${t.stepNumber} (${t.thoughtType}, Confidence: ${t.confidence?.overall ?? 'N/A'}):\n${t.content}`).join('\n\n');
-
-    switch (input.operation) {
-      case 'reflect':
-        prompt = `Perform a comprehensive reflection on this thinking session. What are the key insights? What has been achieved? What is still missing?\n\n${sessionData}${thoughtsData}`;
-        break;
-      case 'analyze_patterns':
-        prompt = `Analyze the thinking patterns in these thoughts. Are there repetitive cycles? Is there a logical progression? Are there any gaps in the reasoning chain?\n\n${thoughtsData}`;
-        break;
-      case 'assess_strategy':
-        prompt = `Assess the reasoning strategy used in this session. Is it effective for the topic? Should the strategy be adjusted (e.g., move from analysis to synthesis)?\n\n${sessionData}${thoughtsData}`;
-        break;
-      case 'detect_bias':
-        prompt = `Identify any cognitive biases present in these thoughts (e.g., confirmation bias, anchoring, overconfidence). Provide evidence from the text for each detected bias.\n\n${thoughtsData}`;
-        systemPrompt = 'You are an expert in cognitive psychology and bias detection. Your role is to identify subtle biases in reasoning processes.';
-        break;
-      default:
-        prompt = `Reflect on the following thoughts and provide meta-observations.\n\n${thoughtsData}`;
-    }
-
-    const response = await LLMAdapter.call(prompt, systemPrompt, provider);
-
-    if (response.error) {
-      // Fallback to simple reflection if LLM fails
-      return this.createTaskResult(task.id, { error: response.error, fallback: 'LLM failed' }, 0, Date.now() - startTime);
-    }
-
-    return this.createTaskResult(
-      task.id,
-      {
-        analysis: response.content,
-        operation: input.operation,
-        timestamp: new Date()
-      },
-      0.9,
-      Date.now() - startTime,
-      {
-        reasoningSteps: 1,
-        intermediateResults: []
-      }
-    );
-  }
-
-
-  // ============================================================================
-  // Helper Methods
-  // ============================================================================
-
-  /**
-   * Find similar thoughts
-   * @param thoughts - Thoughts to compare
-   * @returns Array of similar thought pairs
-   */
-  private findSimilarThoughts(thoughts: Thought[]): Array<[Thought, Thought]> {
-    const similar: Array<[Thought, Thought]> = [];
-
-    for (let i = 0; i < thoughts.length; i++) {
-      for (let j = i + 1; j < thoughts.length; j++) {
-        if (this.thoughtsAreSimilar(thoughts[i], thoughts[j])) {
-          similar.push([thoughts[i], thoughts[j]]);
-        }
-      }
-    }
-
-    return similar;
-  }
-
-  /**
-   * Check if two thoughts are similar
-   * @param a - First thought
-   * @param b - Second thought
-   * @returns True if similar
-   */
-  private thoughtsAreSimilar(a: Thought, b: Thought): boolean {
-    const wordsA = new Set(a.content.toLowerCase().split(/\s+/));
-    const wordsB = new Set(b.content.toLowerCase().split(/\s+/));
-    const intersection = [...wordsA].filter(w => wordsB.has(w));
-    const union = new Set([...wordsA, ...wordsB]);
-
-    return union.size > 0 && intersection.length / union.size > 0.7;
-  }
-
-  /**
-   * Analyze confidence trend
-   * @param thoughts - Thoughts to analyze
-   * @returns Trend analysis
-   */
-  private analyzeConfidenceTrend(thoughts: Thought[]): {
-    trend: 'improving' | 'declining' | 'stable';
-    initial: number;
-    final: number;
-  } {
-    if (thoughts.length < 3) {
-      return { trend: 'stable', initial: 0, final: 0 };
-    }
-
-    const sorted = [...thoughts].sort((a, b) =>
-      a.metadata.createdAt.getTime() - b.metadata.createdAt.getTime()
-    );
-
-    const firstThird = sorted.slice(0, Math.ceil(sorted.length / 3));
-    const lastThird = sorted.slice(-Math.ceil(sorted.length / 3));
-
-    const initial = firstThird.reduce((sum, t) => sum + (t.confidence?.overall ?? 0.5), 0) / firstThird.length;
-    const final = lastThird.reduce((sum, t) => sum + (t.confidence?.overall ?? 0.5), 0) / lastThird.length;
-
-    const diff = final - initial;
-    const threshold = 0.1;
-
-    let trend: 'improving' | 'declining' | 'stable';
-    if (diff > threshold) {
-      trend = 'improving';
-    } else if (diff < -threshold) {
-      trend = 'declining';
-    } else {
-      trend = 'stable';
-    }
-
-    return { trend, initial, final };
-  }
-
-  /**
-   * Analyze thought type distribution
-   * @param thoughts - Thoughts to analyze
-   * @returns Type distribution map
-   */
-  private analyzeThoughtTypeDistribution(thoughts: Thought[]): Map<ThoughtType, number> {
-    const distribution = new Map<ThoughtType, number>();
-
-    for (const thought of thoughts) {
-      const count = distribution.get(thought.thoughtType) || 0;
-      distribution.set(thought.thoughtType, count + 1);
-    }
-
-    return distribution;
-  }
-
-  /**
-   * Calculate confidence variance
-   * @param thoughts - Thoughts to analyze
-   * @returns Variance
-   */
-  calculateConfidenceVariance(thoughts: Thought[]): number {
-    if (thoughts.length < 2) return 0;
-
-    const values = thoughts.map(t => t.confidence?.overall ?? 0.5);
-    const mean = values.reduce((a, b) => a + b, 0) / values.length;
-    const squaredDiffs = values.map(v => Math.pow(v - mean, 2));
-
-    return squaredDiffs.reduce((a, b) => a + b, 0) / values.length;
-  }
-
-  /**
-   * Generate meta-observation for a thought
-   * @param thought - Thought to analyze
-   * @returns Meta-observation or null
-   */
-  generateMetaObservation(thought: Thought): MetaObservation | null {
-    const observations: string[] = [];
-    const triggeredActions: string[] = [];
-
-    // Check for high uncertainty
-    const confidence = thought.confidence || { overall: 0.5, uncertaintyBounds: [0.3, 0.7] };
-    const uncertaintyRange = (confidence.uncertaintyBounds?.[1] ?? 0.7) - (confidence.uncertaintyBounds?.[0] ?? 0.3);
-    if (uncertaintyRange > 0.4) {
-      observations.push('High uncertainty detected');
-      triggeredActions.push('gather_more_evidence');
-    }
-
-    // Check for low confidence
-    if (confidence.overall < 0.4) {
-      observations.push('Low confidence in this thought');
-      triggeredActions.push('review_reasoning');
-    }
-
-    // Check for missing assumptions
-    if (thought.assumptions.length === 0) {
-      observations.push('No explicit assumptions documented');
-      triggeredActions.push('document_assumptions');
-    }
-
-    if (observations.length === 0) return null;
-
-    return {
-      type: 'pattern',
-      description: observations.join('; '),
-      triggeredActions
-    };
-  }
-
-  /**
-   * Get observation history
-   * @returns Observation history
-   */
-  getObservationHistory(): MetaObservation[] {
-    return [...this.observationHistory];
-  }
-}

package/src/agents/reasoner-agent.ts

@@ -1,312 +0,0 @@
-/**
- * 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);
-  }
-}