@gotza02/seq-thinking 1.1.5 → 1.1.7

package/src/agents/synthesizer-agent.ts

@@ -1,641 +0,0 @@
-/**
- * Synthesizer Agent Implementation
- * @module agents/synthesizer-agent
- * @version 1.0.0
- */
-
-import { BaseAgent } from './base-agent.js';
-import {
-  AgentType,
-  SynthesizerType,
-  type Task,
-  type TaskResult,
-  type AgentCapability
-} from '../types/index.js';
-import { LLMAdapter } from '../utils/llm-adapter.js';
-
-/**
- * Synthesis input
- */
-interface SynthesisInput {
-  outputs: Array<{
-    agentId: string;
-    output: unknown;
-    confidence: number;
-  }>;
-  context?: unknown;
-}
-
-/**
- * Synthesis result
- */
-interface Synthesis {
-  synthesizedOutput: unknown;
-  confidence: number;
-  contributingAgents: string[];
-  synthesisMethod: string;
-  consensusLevel?: number;
-  dissentPoints?: unknown[];
-}
-
-/**
- * Synthesizer agent that combines multiple agent outputs
- */
-export class SynthesizerAgent extends BaseAgent {
-  /** Synthesizer type */
-  private synthesizerType: SynthesizerType;
-
-  /**
-   * Create a new synthesizer agent
-   * @param config - Agent configuration
-   */
-  constructor(config: {
-    name: string;
-    synthesizerType?: SynthesizerType;
-    capabilities?: AgentCapability[];
-  }) {
-    const defaultCapabilities: AgentCapability[] = [
-      {
-        name: 'consensus_building',
-        description: 'Build consensus from multiple outputs',
-        confidence: 0.9,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'conflict_resolution',
-        description: 'Resolve conflicts between outputs',
-        confidence: 0.85,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'creative_synthesis',
-        description: 'Create creative combinations',
-        confidence: 0.8,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'integration',
-        description: 'Integrate multiple perspectives',
-        confidence: 0.9,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      }
-    ];
-
-    super({
-      name: config.name,
-      type: AgentType.SYNTHESIZER,
-      subtype: config.synthesizerType || SynthesizerType.CONSENSUS,
-      capabilities: config.capabilities || defaultCapabilities,
-      maxConcurrentTasks: 3,
-      confidenceThreshold: 0.7
-    });
-
-    this.synthesizerType = config.synthesizerType || SynthesizerType.CONSENSUS;
-  }
-
-  /**
-   * Get agent type
-   * @returns Agent type
-   */
-  getType(): string {
-    return AgentType.SYNTHESIZER;
-  }
-
-  /**
-   * Get agent capabilities
-   * @returns Array of capabilities
-   */
-  getCapabilities(): AgentCapability[] {
-    return this.config.capabilities;
-  }
-
-  /**
-   * Process a task - synthesize inputs 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 SynthesisInput;
-
-    if (!input.outputs || input.outputs.length === 0) {
-      return this.createTaskResult(task.id, { error: 'No outputs to synthesize' }, 0, Date.now() - startTime);
-    }
-
-    const contextStr = input.context ? `Context: ${JSON.stringify(input.context)}\n` : '';
-    const outputsStr = input.outputs.map((o, i) => `Agent ${o.agentId} (Confidence: ${o.confidence}):\n${JSON.stringify(o.output)}`).join('\n\n');
-
-    const provider = (task.context as any)?.modelProvider;
-
-    let prompt = '';
-    let systemPrompt = 'You are an expert synthesizer agent in a swarm intelligence system. Your goal is to combine multiple agent outputs into a coherent, high-quality result.';
-
-    switch (this.synthesizerType) {
-      case SynthesizerType.CONSENSUS:
-        prompt = `Build a consensus from the following agent outputs. Identify common points, resolve minor discrepancies, and provide a unified conclusion.\n\n${contextStr}\n${outputsStr}`;
-        break;
-      case SynthesizerType.CREATIVE:
-        prompt = `Perform a creative synthesis of these agent outputs. Look for unexpected connections, combine ideas in novel ways, and provide a unique integrated insight.\n\n${contextStr}\n${outputsStr}`;
-        systemPrompt = 'You are a creative synthesizer agent. You excel at finding novel connections and unique perspectives by combining diverse ideas.';
-        break;
-      case SynthesizerType.CONFLICT_RESOLUTION:
-        prompt = `Resolve the conflicts between these agent outputs. Analyze the reasoning behind each conflicting point and determine the most logically sound resolution based on the evidence and confidence levels.\n\n${contextStr}\n${outputsStr}`;
-        systemPrompt = 'You are a conflict resolution specialist agent. You excel at analyzing differing perspectives and finding the most accurate resolution based on logic and evidence.';
-        break;
-      default:
-        prompt = `Integrate the following agent outputs into a comprehensive final result.\n\n${contextStr}\n${outputsStr}`;
-    }
-
-    const response = await LLMAdapter.call(prompt, systemPrompt, provider);
-    
-    if (response.error) {
-      // Fallback to heuristic if LLM fails
-      const heuristicResult = await this.heuristicSynthesis(input);
-      return this.createTaskResult(task.id, heuristicResult, heuristicResult.confidence, Date.now() - startTime, { error: response.error });
-    }
-
-    const synthesizedOutput = response.content;
-    const avgConfidence = input.outputs.reduce((sum, o) => sum + o.confidence, 0) / input.outputs.length;
-
-    const result: Synthesis = {
-      synthesizedOutput,
-      confidence: Math.min(0.95, avgConfidence + 0.1), // Boost confidence for successful synthesis
-      contributingAgents: input.outputs.map(o => o.agentId),
-      synthesisMethod: `llm_${this.synthesizerType.toLowerCase()}`
-    };
-
-    return this.createTaskResult(
-      task.id,
-      result,
-      result.confidence,
-      Date.now() - startTime,
-      {
-        reasoningSteps: input.outputs.length + 1,
-        intermediateResults: input.outputs.map(o => o.output)
-      }
-    );
-  }
-
-  /**
-   * Fallback heuristic synthesis
-   */
-  private async heuristicSynthesis(input: SynthesisInput): Promise<Synthesis> {
-    const { outputs } = input;
-    // Simplified version of the previous heuristic logic
-    return {
-      synthesizedOutput: outputs.map(o => JSON.stringify(o.output)).join('\n---\n'),
-      confidence: outputs.reduce((sum, o) => sum + o.confidence, 0) / outputs.length,
-      contributingAgents: outputs.map(o => o.agentId),
-      synthesisMethod: 'heuristic_fallback'
-    };
-  }
-
-
-  // ============================================================================
-  // Helper Methods
-  // ============================================================================
-
-  /**
-   * Extract key points from output
-   * @param output - Output to extract from
-   * @returns Array of key points
-   */
-  private extractKeyPoints(output: unknown): string[] {
-    if (typeof output === 'string') {
-      return output.split(/[.!?]+/).filter(s => s.trim().length > 10);
-    }
-
-    if (output && typeof output === 'object') {
-      const obj = output as Record<string, unknown>;
-
-      if ('conclusion' in obj && typeof obj.conclusion === 'string') {
-        return [obj.conclusion];
-      }
-
-      if ('keyPoints' in obj && Array.isArray(obj.keyPoints)) {
-        return obj.keyPoints as string[];
-      }
-
-      return [JSON.stringify(output)];
-    }
-
-    return [String(output)];
-  }
-
-  /**
-   * Find consensus points
-   * @param keyPointsArray - Array of key points arrays
-   * @returns Consensus points
-   */
-  private findConsensusPoints(keyPointsArray: string[][]): string[] {
-    if (keyPointsArray.length === 0) return [];
-    if (keyPointsArray.length === 1) return keyPointsArray[0];
-
-    const consensus: string[] = [];
-    const firstSet = keyPointsArray[0];
-
-    for (const point of firstSet) {
-      const normalizedPoint = this.normalizePoint(point);
-      let matchCount = 1;
-
-      for (let i = 1; i < keyPointsArray.length; i++) {
-        const otherSet = keyPointsArray[i];
-        const hasMatch = otherSet.some(otherPoint =>
-          this.pointsAreSimilar(normalizedPoint, this.normalizePoint(otherPoint))
-        );
-        if (hasMatch) matchCount++;
-      }
-
-      // Point is in consensus if it appears in majority
-      if (matchCount > keyPointsArray.length / 2) {
-        consensus.push(point);
-      }
-    }
-
-    return consensus;
-  }
-
-  /**
-   * Find divergence points
-   * @param keyPointsArray - Array of key points arrays
-   * @returns Divergence points
-   */
-  private findDivergencePoints(keyPointsArray: string[][]): string[] {
-    if (keyPointsArray.length <= 1) return [];
-
-    const allPoints = keyPointsArray.flat();
-    const uniquePoints = [...new Set(allPoints.map(p => this.normalizePoint(p)))];
-    const divergence: string[] = [];
-
-    for (const point of uniquePoints) {
-      let matchCount = 0;
-
-      for (const pointSet of keyPointsArray) {
-        const hasMatch = pointSet.some(p =>
-          this.pointsAreSimilar(point, this.normalizePoint(p))
-        );
-        if (hasMatch) matchCount++;
-      }
-
-      // Point diverges if not in majority
-      if (matchCount <= keyPointsArray.length / 2) {
-        const original = allPoints.find(p => this.normalizePoint(p) === point);
-        if (original) divergence.push(original);
-      }
-    }
-
-    return divergence;
-  }
-
-  /**
-   * Normalize a point for comparison
-   * @param point - Point to normalize
-   * @returns Normalized point
-   */
-  private normalizePoint(point: string): string {
-    return point.toLowerCase().trim().replace(/\s+/g, ' ');
-  }
-
-  /**
-   * Check if two points are similar
-   * @param a - First point
-   * @param b - Second point
-   * @returns True if similar
-   */
-  private pointsAreSimilar(a: string, b: string): boolean {
-    // Simple similarity check
-    if (a === b) return true;
-
-    const wordsA = new Set(a.split(' '));
-    const wordsB = new Set(b.split(' '));
-    const intersection = [...wordsA].filter(w => wordsB.has(w));
-    const union = new Set([...wordsA, ...wordsB]);
-
-    return union.size > 0 && intersection.length / union.size > 0.6;
-  }
-
-  /**
-   * Apply confidence weights to points
-   * @param points - Points to weight
-   * @param outputs - Outputs with confidence
-   * @returns Weighted points
-   */
-  private applyConfidenceWeights(
-    points: string[],
-    outputs: Array<{ confidence: number }>
-  ): Array<{ point: string; weight: number }> {
-    const avgConfidence = outputs.reduce((sum, o) => sum + o.confidence, 0) / outputs.length;
-
-    return points.map(point => ({
-      point,
-      weight: avgConfidence
-    }));
-  }
-
-  /**
-   * Generate unified output
-   * @param weightedPoints - Weighted points
-   * @param divergencePoints - Divergence points
-   * @returns Unified output
-   */
-  private generateUnifiedOutput(
-    weightedPoints: Array<{ point: string; weight: number }>,
-    divergencePoints: string[]
-  ): Record<string, unknown> {
-    return {
-      consensus: weightedPoints.map(wp => wp.point),
-      consensusWeights: weightedPoints.map(wp => wp.weight),
-      pointsOfDivergence: divergencePoints,
-      summary: `Consensus reached on ${weightedPoints.length} points with ${divergencePoints.length} points of divergence`
-    };
-  }
-
-  /**
-   * Extract creative elements
-   * @param output - Output to extract from
-   * @returns Creative elements
-   */
-  private extractCreativeElements(output: unknown): string[] {
-    if (typeof output === 'string') {
-      // Extract novel phrases, metaphors, etc.
-      return output.split(/[.!?]+/).filter(s => s.trim().length > 5);
-    }
-
-    if (output && typeof output === 'object') {
-      const obj = output as Record<string, unknown>;
-
-      if ('creativeElements' in obj && Array.isArray(obj.creativeElements)) {
-        return obj.creativeElements as string[];
-      }
-
-      if ('ideas' in obj && Array.isArray(obj.ideas)) {
-        return obj.ideas as string[];
-      }
-    }
-
-    return [String(output)];
-  }
-
-  /**
-   * Find unexpected connections
-   * @param elementsArray - Array of element arrays
-   * @returns Connections
-   */
-  private findUnexpectedConnections(elementsArray: string[][]): Array<{
-    elements: [string, string];
-    connection: string;
-  }> {
-    const connections: Array<{ elements: [string, string]; connection: string }> = [];
-
-    // Compare elements from different sources
-    for (let i = 0; i < elementsArray.length; i++) {
-      for (let j = i + 1; j < elementsArray.length; j++) {
-        const setA = elementsArray[i];
-        const setB = elementsArray[j];
-
-        for (const elemA of setA) {
-          for (const elemB of setB) {
-            const connection = this.findConnection(elemA, elemB);
-            if (connection) {
-              connections.push({
-                elements: [elemA, elemB],
-                connection
-              });
-            }
-          }
-        }
-      }
-    }
-
-    return connections;
-  }
-
-  /**
-   * Find connection between two elements
-   * @param a - First element
-   * @param b - Second element
-   * @returns Connection description or null
-   */
-  private findConnection(a: string, b: string): string | null {
-    const wordsA = new Set(a.toLowerCase().split(/\s+/));
-    const wordsB = new Set(b.toLowerCase().split(/\s+/));
-    const common = [...wordsA].filter(w => wordsB.has(w) && w.length > 3);
-
-    if (common.length > 0) {
-      return `Connected through: ${common.join(', ')}`;
-    }
-
-    return null;
-  }
-
-  /**
-   * Generate novel combinations
-   * @param elementsArray - Array of element arrays
-   * @param connections - Connections
-   * @returns Combinations
-   */
-  private generateNovelCombinations(
-    elementsArray: string[][],
-    connections: Array<{ elements: [string, string]; connection: string }>
-  ): string[] {
-    const combinations: string[] = [];
-
-    for (const connection of connections) {
-      const [elemA, elemB] = connection.elements;
-      combinations.push(`Combining "${elemA.substring(0, 30)}..." with "${elemB.substring(0, 30)}..."`);
-    }
-
-    // Cross-pollinate ideas
-    for (let i = 0; i < elementsArray.length && i < 3; i++) {
-      for (let j = i + 1; j < elementsArray.length && j < 3; j++) {
-        const elemA = elementsArray[i][0];
-        const elemB = elementsArray[j][0];
-        if (elemA && elemB) {
-          combinations.push(`Cross: ${elemA.substring(0, 20)}... + ${elemB.substring(0, 20)}...`);
-        }
-      }
-    }
-
-    return combinations;
-  }
-
-  /**
-   * Generate novel insights
-   * @param combinations - Combinations
-   * @returns Insights
-   */
-  private generateNovelInsights(combinations: string[]): string[] {
-    return combinations.map((combo, i) =>
-      `Insight ${i + 1}: ${combo} suggests a new approach`
-    );
-  }
-
-  /**
-   * Calculate diversity score
-   * @param elementsArray - Array of element arrays
-   * @returns Diversity score (0-1)
-   */
-  private calculateDiversity(elementsArray: string[][]): number {
-    const allElements = elementsArray.flat();
-    const uniqueElements = new Set(allElements);
-
-    if (allElements.length === 0) return 0;
-
-    return uniqueElements.size / allElements.length;
-  }
-
-  /**
-   * Identify conflicts
-   * @param outputs - Outputs to analyze
-   * @returns Conflicts
-   */
-  private identifyConflicts(outputs: Array<{ agentId: string; output: unknown }>): Array<{
-    type: string;
-    description: string;
-    involvedAgents: string[];
-  }> {
-    const conflicts: Array<{
-      type: string;
-      description: string;
-      involvedAgents: string[];
-    }> = [];
-
-    // Check for contradictory conclusions
-    const conclusions: Array<{ agentId: string; conclusion: string }> = [];
-
-    for (const output of outputs) {
-      const conclusion = this.extractConclusion(output.output);
-      if (conclusion) {
-        conclusions.push({ agentId: output.agentId, conclusion });
-      }
-    }
-
-    // Find contradictions
-    for (let i = 0; i < conclusions.length; i++) {
-      for (let j = i + 1; j < conclusions.length; j++) {
-        const a = conclusions[i];
-        const b = conclusions[j];
-
-        if (this.areContradictory(a.conclusion, b.conclusion)) {
-          conflicts.push({
-            type: 'contradiction',
-            description: `Contradictory conclusions: "${a.conclusion.substring(0, 30)}..." vs "${b.conclusion.substring(0, 30)}..."`,
-            involvedAgents: [a.agentId, b.agentId]
-          });
-        }
-      }
-    }
-
-    return conflicts;
-  }
-
-  /**
-   * Extract conclusion from output
-   * @param output - Output to extract from
-   * @returns Conclusion string or null
-   */
-  private extractConclusion(output: unknown): string | null {
-    if (typeof output === 'string') return output;
-
-    if (output && typeof output === 'object') {
-      const obj = output as Record<string, unknown>;
-
-      if ('conclusion' in obj && typeof obj.conclusion === 'string') {
-        return obj.conclusion;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Check if two conclusions are contradictory
-   * @param a - First conclusion
-   * @param b - Second conclusion
-   * @returns True if contradictory
-   */
-  private areContradictory(a: string, b: string): boolean {
-    const lowerA = a.toLowerCase();
-    const lowerB = b.toLowerCase();
-
-    // Check for direct opposites
-    const oppositePatterns = [
-      { pos: /\b(is|are|was|were)\b/gi, neg: /\b(is not|are not|was not|were not)\b/gi },
-      { pos: /\bshould\b/gi, neg: /\bshould not\b/gi },
-      { pos: /\bcan\b/gi, neg: /\bcannot\b/gi }
-    ];
-
-    for (const { pos, neg } of oppositePatterns) {
-      const aHasPos = pos.test(lowerA);
-      const aHasNeg = neg.test(lowerA);
-      const bHasPos = pos.test(lowerB);
-      const bHasNeg = neg.test(lowerB);
-
-      if ((aHasPos && bHasNeg) || (aHasNeg && bHasPos)) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Resolve a conflict
-   * @param conflict - Conflict to resolve
-   * @param outputs - All outputs
-   * @returns Resolution
-   */
-  private resolveConflict(
-    conflict: { type: string; involvedAgents: string[] },
-    outputs: Array<{ agentId: string; output: unknown; confidence: number }>
-  ): { resolution: unknown; confidence: number } {
-    // Get conflicting outputs
-    const conflictingOutputs = outputs.filter(o =>
-      conflict.involvedAgents.includes(o.agentId)
-    );
-
-    // Select based on confidence
-    const best = conflictingOutputs.reduce((max, o) =>
-      o.confidence > max.confidence ? o : max,
-      conflictingOutputs[0]
-    );
-
-    if (!best) {
-      return { resolution: null, confidence: 0 };
-    }
-
-    return {
-      resolution: best.output,
-      confidence: best.confidence
-    };
-  }
-
-  /**
-   * Merge resolutions with non-conflicting content
-   * @param outputs - All outputs
-   * @param resolutions - Resolutions
-   * @returns Merged output
-   */
-  private mergeResolutions(
-    outputs: Array<{ agentId: string; output: unknown }>,
-    resolutions: Array<{ conflict: { involvedAgents: string[] }; resolution: { resolution: unknown } }>
-  ): Record<string, unknown> {
-    const merged: Record<string, unknown> = {
-      resolvedConflicts: resolutions.length,
-      agentOutputs: {}
-    };
-
-    // Add all outputs
-    for (const output of outputs) {
-      (merged.agentOutputs as Record<string, unknown>)[output.agentId] = output.output;
-    }
-
-    // Add resolutions
-    merged.resolutions = resolutions.map(r => ({
-      conflict: r.conflict,
-      selectedResolution: r.resolution.resolution
-    }));
-
-    return merged;
-  }
-}