@gotza02/seq-thinking 1.1.2 → 1.1.4

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

@@ -14,6 +14,7 @@ import {
   type Thought,
   type ThinkingSession
 } from '../types/index.js';
+import { LLMAdapter } from '../utils/llm-adapter.js';
 
 /**
  * Meta-observation
@@ -27,17 +28,7 @@ interface MetaObservation {
 }
 
 /**
- * Thinking pattern
- */
-interface ThinkingPattern {
-  pattern: string;
-  frequency: number;
-  impact: 'positive' | 'negative' | 'neutral';
-  suggestion?: string;
-}
-
-/**
- * Meta-reasoning agent that reflects on thinking processes
+ * Meta-reasoning agent that reflects on thinking processes using LLM
  */
 export class MetaReasoningAgent extends BaseAgent {
   /** Observation history */
@@ -54,26 +45,26 @@ export class MetaReasoningAgent extends BaseAgent {
     const defaultCapabilities: AgentCapability[] = [
       {
         name: 'process_reflection',
-        description: 'Reflect on thinking processes',
-        confidence: 0.9,
+        description: 'Reflect on thinking processes using LLM',
+        confidence: 0.95,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'strategy_assessment',
-        description: 'Assess reasoning strategies',
-        confidence: 0.85,
+        description: 'Assess reasoning strategies using LLM',
+        confidence: 0.9,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'bias_detection',
-        description: 'Detect cognitive biases',
-        confidence: 0.8,
+        description: 'Detect cognitive biases using LLM',
+        confidence: 0.85,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       },
       {
         name: 'pattern_analysis',
-        description: 'Analyze thinking patterns',
-        confidence: 0.85,
+        description: 'Analyze thinking patterns using LLM',
+        confidence: 0.9,
         performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
       }
     ];
@@ -104,7 +95,7 @@ export class MetaReasoningAgent extends BaseAgent {
   }
 
   /**
-   * Process a task - perform meta-reasoning
+   * Process a task - perform meta-reasoning using LLM
    * @param task - Task to process
    * @returns Task result
    */
@@ -116,30 +107,48 @@ export class MetaReasoningAgent extends BaseAgent {
       operation: 'reflect' | 'analyze_patterns' | 'assess_strategy' | 'detect_bias';
     };
 
-    let result: unknown;
-    let confidence = 0.8;
+    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':
-        result = this.reflect(input.session);
+        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':
-        result = this.analyzeThinkingPatterns(input.thoughts || []);
+        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':
-        result = this.assessStrategy(input.session);
+        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':
-        result = this.detectBias(input.thoughts || []);
+        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:
-        result = this.reflect(input.session);
+        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,
-      result,
-      confidence,
+      {
+        analysis: response.content,
+        operation: input.operation,
+        timestamp: new Date()
+      },
+      0.9,
       Date.now() - startTime,
       {
         reasoningSteps: 1,
@@ -148,374 +157,6 @@ export class MetaReasoningAgent extends BaseAgent {
     );
   }
 
-  /**
-   * Reflect on a thinking session
-   * @param session - Session to reflect on
-   * @returns Reflection result
-   */
-  reflect(session?: ThinkingSession): {
-    reflection: string;
-    insights: string[];
-    recommendations: string[];
-    observations: MetaObservation[];
-  } {
-    if (!session) {
-      return {
-        reflection: 'No session provided for reflection',
-        insights: [],
-        recommendations: [],
-        observations: []
-      };
-    }
-
-    const thoughts = Array.from(session.thoughts.values());
-    const insights: string[] = [];
-    const recommendations: string[] = [];
-    const observations: MetaObservation[] = [];
-
-    // Analyze thinking patterns
-    const patterns = this.analyzeThinkingPatterns(thoughts);
-
-    for (const pattern of patterns) {
-      if (pattern.impact === 'negative') {
-        observations.push({
-          type: 'concern',
-          description: pattern.pattern,
-          severity: pattern.frequency > 3 ? 'high' : 'medium',
-          recommendation: pattern.suggestion
-        });
-        recommendations.push(pattern.suggestion || 'Review and adjust thinking pattern');
-      } else if (pattern.impact === 'positive') {
-        observations.push({
-          type: 'insight',
-          description: pattern.pattern
-        });
-        insights.push(pattern.pattern);
-      }
-    }
-
-    // Check confidence trends
-    const confidenceTrend = this.analyzeConfidenceTrend(thoughts);
-    if (confidenceTrend.trend === 'declining') {
-      observations.push({
-        type: 'concern',
-        description: 'Confidence is declining over time',
-        severity: 'medium',
-        recommendation: 'Review assumptions and gather more evidence'
-      });
-      recommendations.push('Strengthen reasoning with additional evidence');
-    } else if (confidenceTrend.trend === 'improving') {
-      insights.push('Confidence is improving, indicating solid reasoning progress');
-    }
-
-    // Check thought type distribution
-    const typeDistribution = this.analyzeThoughtTypeDistribution(thoughts);
-    const analysisCount = typeDistribution.get(ThoughtType.ANALYSIS) || 0;
-    const hypothesisCount = typeDistribution.get(ThoughtType.HYPOTHESIS) || 0;
-    
-    if (analysisCount > hypothesisCount * 3) {
-      observations.push({
-        type: 'suggestion',
-        description: 'Heavy focus on analysis with limited hypothesis generation',
-        recommendation: 'Consider exploring more alternative hypotheses'
-      });
-      recommendations.push('Generate more diverse hypotheses');
-    }
-
-    // Check for meta-reasoning gaps
-    const metaThoughtCount = thoughts.filter(t => t.thoughtType === ThoughtType.META_REASONING).length;
-    if (metaThoughtCount < thoughts.length * 0.1) {
-      observations.push({
-        type: 'suggestion',
-        description: 'Limited meta-reasoning detected',
-        recommendation: 'Increase reflection on the thinking process itself'
-      });
-      recommendations.push('Add more meta-reasoning steps');
-    }
-
-    const reflection = `Analyzed ${thoughts.length} thoughts across ${session.branches.size} branches. ` +
-      `Found ${insights.length} positive insights and ${recommendations.length} areas for improvement.`;
-
-    return {
-      reflection,
-      insights,
-      recommendations,
-      observations
-    };
-  }
-
-  /**
-   * Analyze thinking patterns
-   * @param thoughts - Thoughts to analyze
-   * @returns Array of patterns
-   */
-  analyzeThinkingPatterns(thoughts: Thought[]): ThinkingPattern[] {
-    const patterns: ThinkingPattern[] = [];
-
-    if (thoughts.length === 0) return patterns;
-
-    // Pattern: Repetitive thinking
-    const contentSimilarities = this.findSimilarThoughts(thoughts);
-    if (contentSimilarities.length > thoughts.length * 0.3) {
-      patterns.push({
-        pattern: 'Repetitive thinking detected - similar thoughts being generated',
-        frequency: contentSimilarities.length,
-        impact: 'negative',
-        suggestion: 'Focus on generating novel insights rather than restating'
-      });
-    }
-
-    // Pattern: Confidence progression
-    const confidenceValues = thoughts.map(t => t.confidence.overall);
-    const avgConfidence = confidenceValues.reduce((a, b) => a + b, 0) / confidenceValues.length;
-
-    if (avgConfidence < 0.5) {
-      patterns.push({
-        pattern: 'Low average confidence across thoughts',
-        frequency: thoughts.length,
-        impact: 'negative',
-        suggestion: 'Strengthen evidence and reasoning for key claims'
-      });
-    } else if (avgConfidence > 0.8) {
-      patterns.push({
-        pattern: 'High confidence maintained throughout',
-        frequency: thoughts.length,
-        impact: 'positive'
-      });
-    }
-
-    // Pattern: Branch exploration
-    const branchIds = new Set(thoughts.map(t => t.branchId));
-    if (branchIds.size === 1 && thoughts.length > 5) {
-      patterns.push({
-        pattern: 'Single branch exploration - no parallel hypotheses',
-        frequency: 1,
-        impact: 'negative',
-        suggestion: 'Consider branching to explore alternative approaches'
-      });
-    } else if (branchIds.size > 2) {
-      patterns.push({
-        pattern: 'Active branch exploration with parallel hypotheses',
-        frequency: branchIds.size,
-        impact: 'positive'
-      });
-    }
-
-    // Pattern: Assumption documentation
-    const thoughtsWithAssumptions = thoughts.filter(t => t.assumptions.length > 0).length;
-    if (thoughtsWithAssumptions < thoughts.length * 0.3) {
-      patterns.push({
-        pattern: 'Limited explicit assumption documentation',
-        frequency: thoughts.length - thoughtsWithAssumptions,
-        impact: 'negative',
-        suggestion: 'Document assumptions explicitly for each major claim'
-      });
-    }
-
-    // Pattern: Revision activity
-    const revisedThoughts = thoughts.filter(t => t.revisionHistory.length > 0).length;
-    if (revisedThoughts > thoughts.length * 0.5) {
-      patterns.push({
-        pattern: 'High revision rate - thoughts being frequently corrected',
-        frequency: revisedThoughts,
-        impact: 'neutral',
-        suggestion: 'Consider more careful initial analysis to reduce revisions'
-      });
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Assess reasoning strategy
-   * @param session - Session to assess
-   * @returns Strategy assessment
-   */
-  assessStrategy(session?: ThinkingSession): {
-    assessment: string;
-    strengths: string[];
-    weaknesses: string[];
-    suggestions: string[];
-  } {
-    if (!session) {
-      return {
-        assessment: 'No session provided',
-        strengths: [],
-        weaknesses: [],
-        suggestions: []
-      };
-    }
-
-    const thoughts = Array.from(session.thoughts.values());
-    const strengths: string[] = [];
-    const weaknesses: string[] = [];
-    const suggestions: string[] = [];
-
-    // Assess hypothesis generation
-    const hypothesisCount = thoughts.filter(t => t.thoughtType === ThoughtType.HYPOTHESIS).length;
-    if (hypothesisCount >= 3) {
-      strengths.push('Good hypothesis generation with multiple alternatives');
-    } else if (hypothesisCount < 2 && thoughts.length > 5) {
-      weaknesses.push('Limited hypothesis generation');
-      suggestions.push('Generate at least 3 alternative hypotheses early in the process');
-    }
-
-    // Assess evidence gathering
-    const evidenceCount = thoughts.filter(t => t.thoughtType === ThoughtType.EVIDENCE).length;
-    if (evidenceCount >= thoughts.length * 0.2) {
-      strengths.push('Strong evidence-based reasoning');
-    } else {
-      weaknesses.push('Insufficient evidence gathering');
-      suggestions.push('Support claims with more evidence and citations');
-    }
-
-    // Assess counterargument consideration
-    const counterCount = thoughts.filter(t => t.thoughtType === ThoughtType.COUNTERARGUMENT).length;
-    if (counterCount >= 2) {
-      strengths.push('Good consideration of counterarguments');
-    } else if (thoughts.length > 8) {
-      weaknesses.push('Limited counterargument analysis');
-      suggestions.push('Actively seek and address counterarguments');
-    }
-
-    // Assess synthesis
-    const synthesisCount = thoughts.filter(t => t.thoughtType === ThoughtType.SYNTHESIS).length;
-    if (synthesisCount >= 2) {
-      strengths.push('Regular synthesis of findings');
-    } else if (thoughts.length > 10) {
-      suggestions.push('Periodically synthesize findings to maintain coherence');
-    }
-
-    // Assess self-correction
-    const correctionCount = thoughts.filter(t => t.thoughtType === ThoughtType.SELF_CORRECTION).length;
-    if (correctionCount >= 1) {
-      strengths.push('Active self-correction detected');
-    }
-
-    const assessment = strengths.length > weaknesses.length
-      ? 'Overall effective reasoning strategy'
-      : weaknesses.length > strengths.length
-        ? 'Strategy needs improvement'
-        : 'Balanced strategy with room for improvement';
-
-    return {
-      assessment,
-      strengths,
-      weaknesses,
-      suggestions
-    };
-  }
-
-  /**
-   * Detect cognitive biases
-   * @param thoughts - Thoughts to analyze
-   * @returns Bias detection results
-   */
-  detectBias(thoughts: Thought[]): {
-    detectedBiases: Array<{
-      bias: string;
-      evidence: string;
-      severity: 'low' | 'medium' | 'high';
-      mitigation: string;
-    }>;
-    overallRisk: 'low' | 'medium' | 'high';
-  } {
-    const detectedBiases: Array<{
-      bias: string;
-      evidence: string;
-      severity: 'low' | 'medium' | 'high';
-      mitigation: string;
-    }> = [];
-
-    if (thoughts.length === 0) {
-      return { detectedBiases, overallRisk: 'low' };
-    }
-
-    // Check for confirmation bias
-    const confirmingThoughts = thoughts.filter(t =>
-      t.content.toLowerCase().includes('confirms') ||
-      t.content.toLowerCase().includes('proves') ||
-      t.content.toLowerCase().includes('supports')
-    ).length;
-
-    const disconfirmingThoughts = thoughts.filter(t =>
-      t.content.toLowerCase().includes('contradicts') ||
-      t.content.toLowerCase().includes('challenges') ||
-      t.content.toLowerCase().includes('refutes')
-    ).length;
-
-    if (confirmingThoughts > disconfirmingThoughts * 3 && confirmingThoughts > 2) {
-      detectedBiases.push({
-        bias: 'Confirmation Bias',
-        evidence: `${confirmingThoughts} confirming vs ${disconfirmingThoughts} disconfirming thoughts`,
-        severity: 'medium',
-        mitigation: 'Actively seek disconfirming evidence for each claim'
-      });
-    }
-
-    // Check for anchoring bias
-    const firstThoughtConfidence = thoughts[0]?.confidence.overall || 0.5;
-    const confidenceVariance = this.calculateConfidenceVariance(thoughts);
-
-    if (confidenceVariance < 0.1 && thoughts.length > 5) {
-      detectedBiases.push({
-        bias: 'Anchoring Bias',
-        evidence: 'Low confidence variance suggests anchoring to initial estimates',
-        severity: 'low',
-        mitigation: 'Re-evaluate confidence independently for each thought'
-      });
-    }
-
-    // Check for availability bias
-    const recentThoughts = thoughts.slice(-3);
-    const recentReferences = recentThoughts.filter(t =>
-      t.dependencies.some(d => thoughts.slice(0, -3).some(pt => pt.id === d))
-    ).length;
-
-    if (recentReferences === 0 && thoughts.length > 5) {
-      detectedBiases.push({
-        bias: 'Availability Bias',
-        evidence: 'Recent thoughts do not reference earlier work',
-        severity: 'low',
-        mitigation: 'Actively reference and build upon earlier insights'
-      });
-    }
-
-    // Check for overconfidence
-    const highConfidenceCount = thoughts.filter(t => t.confidence.overall > 0.9).length;
-    if (highConfidenceCount > thoughts.length * 0.5) {
-      detectedBiases.push({
-        bias: 'Overconfidence Bias',
-        evidence: `${highConfidenceCount}/${thoughts.length} thoughts have >90% confidence`,
-        severity: 'medium',
-        mitigation: 'Calibrate confidence more conservatively'
-      });
-    }
-
-    // Check for sunk cost fallacy
-    const revisionCount = thoughts.filter(t => t.revisionHistory.length > 0).length;
-    if (revisionCount > thoughts.length * 0.7 && thoughts.length > 5) {
-      detectedBiases.push({
-        bias: 'Sunk Cost Fallacy',
-        evidence: 'High revision rate may indicate reluctance to abandon initial approach',
-        severity: 'low',
-        mitigation: 'Be willing to start fresh if current approach is not working'
-      });
-    }
-
-    // Determine overall risk
-    const highSeverityCount = detectedBiases.filter(b => b.severity === 'high').length;
-    const mediumSeverityCount = detectedBiases.filter(b => b.severity === 'medium').length;
-
-    let overallRisk: 'low' | 'medium' | 'high' = 'low';
-    if (highSeverityCount > 0 || mediumSeverityCount > 2) {
-      overallRisk = 'high';
-    } else if (mediumSeverityCount > 0) {
-      overallRisk = 'medium';
-    }
-
-    return { detectedBiases, overallRisk };
-  }
 
   // ============================================================================
   // Helper Methods
@@ -576,8 +217,8 @@ export class MetaReasoningAgent extends BaseAgent {
     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) / firstThird.length;
-    const final = lastThird.reduce((sum, t) => sum + t.confidence.overall, 0) / lastThird.length;
+    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;
@@ -615,10 +256,10 @@ export class MetaReasoningAgent extends BaseAgent {
    * @param thoughts - Thoughts to analyze
    * @returns Variance
    */
-  private calculateConfidenceVariance(thoughts: Thought[]): number {
+  calculateConfidenceVariance(thoughts: Thought[]): number {
     if (thoughts.length < 2) return 0;
 
-    const values = thoughts.map(t => t.confidence.overall);
+    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));
 
@@ -635,14 +276,15 @@ export class MetaReasoningAgent extends BaseAgent {
     const triggeredActions: string[] = [];
 
     // Check for high uncertainty
-    const uncertaintyRange = thought.confidence.uncertaintyBounds[1] - thought.confidence.uncertaintyBounds[0];
+    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 (thought.confidence.overall < 0.4) {
+    if (confidence.overall < 0.4) {
       observations.push('Low confidence in this thought');
       triggeredActions.push('review_reasoning');
     }