@gotza02/seq-thinking 1.1.0

package/src/agents/synthesizer-agent.ts

@@ -0,0 +1,758 @@
+/**
+ * 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';
+
+/**
+ * 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.85,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'conflict_resolution',
+        description: 'Resolve conflicts between outputs',
+        confidence: 0.8,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'creative_synthesis',
+        description: 'Create creative combinations',
+        confidence: 0.75,
+        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
+      },
+      {
+        name: 'integration',
+        description: 'Integrate multiple perspectives',
+        confidence: 0.85,
+        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
+   * @param task - Task to process
+   * @returns Task result
+   */
+  async process(task: Task): Promise<TaskResult> {
+    const startTime = Date.now();
+    const input = task.input as SynthesisInput;
+
+    let result: Synthesis;
+
+    switch (this.synthesizerType) {
+      case SynthesizerType.CONSENSUS:
+        result = await this.buildConsensus(input);
+        break;
+      case SynthesizerType.CREATIVE:
+        result = await this.creativeSynthesis(input);
+        break;
+      case SynthesizerType.CONFLICT_RESOLUTION:
+        result = await this.resolveConflicts(input);
+        break;
+      default:
+        result = await this.buildConsensus(input);
+    }
+
+    return this.createTaskResult(
+      task.id,
+      result,
+      result.confidence,
+      Date.now() - startTime,
+      {
+        reasoningSteps: input.outputs.length,
+        intermediateResults: input.outputs.map(o => o.output)
+      }
+    );
+  }
+
+  /**
+   * Build consensus from multiple outputs
+   * @param input - Synthesis input
+   * @returns Synthesis result
+   */
+  private async buildConsensus(input: SynthesisInput): Promise<Synthesis> {
+    const { outputs } = input;
+
+    if (outputs.length === 0) {
+      return {
+        synthesizedOutput: null,
+        confidence: 0,
+        contributingAgents: [],
+        synthesisMethod: 'consensus'
+      };
+    }
+
+    if (outputs.length === 1) {
+      return {
+        synthesizedOutput: outputs[0].output,
+        confidence: outputs[0].confidence,
+        contributingAgents: [outputs[0].agentId],
+        synthesisMethod: 'consensus'
+      };
+    }
+
+    // Extract key points from each output
+    const keyPoints = outputs.map(o => this.extractKeyPoints(o.output));
+
+    // Find consensus points (common across multiple outputs)
+    const consensusPoints = this.findConsensusPoints(keyPoints);
+
+    // Find points of divergence
+    const divergencePoints = this.findDivergencePoints(keyPoints);
+
+    // Weight by confidence
+    const weightedConsensus = this.applyConfidenceWeights(consensusPoints, outputs);
+
+    // Calculate consensus level
+    const consensusLevel = consensusPoints.length / Math.max(...keyPoints.map(kp => kp.length));
+
+    // Generate unified output
+    const unified = this.generateUnifiedOutput(weightedConsensus, divergencePoints);
+
+    // Calculate overall confidence
+    const avgConfidence = outputs.reduce((sum, o) => sum + o.confidence, 0) / outputs.length;
+    const consensusBoost = consensusLevel * 0.1;
+
+    return {
+      synthesizedOutput: unified,
+      confidence: Math.min(1, avgConfidence + consensusBoost),
+      contributingAgents: outputs.map(o => o.agentId),
+      synthesisMethod: 'consensus',
+      consensusLevel,
+      dissentPoints: divergencePoints
+    };
+  }
+
+  /**
+   * Creative synthesis
+   * @param input - Synthesis input
+   * @returns Synthesis result
+   */
+  private async creativeSynthesis(input: SynthesisInput): Promise<Synthesis> {
+    const { outputs } = input;
+
+    if (outputs.length === 0) {
+      return {
+        synthesizedOutput: null,
+        confidence: 0,
+        contributingAgents: [],
+        synthesisMethod: 'creative_combination'
+      };
+    }
+
+    // Extract creative elements
+    const creativeElements = outputs.map(o => this.extractCreativeElements(o.output));
+
+    // Find unexpected connections
+    const connections = this.findUnexpectedConnections(creativeElements);
+
+    // Generate novel combinations
+    const combinations = this.generateNovelCombinations(creativeElements, connections);
+
+    // Create creative output
+    const creativeOutput = {
+      combinations,
+      connections,
+      originalElements: creativeElements,
+      novelInsights: this.generateNovelInsights(combinations)
+    };
+
+    // Calculate confidence based on diversity and novelty
+    const diversityScore = this.calculateDiversity(creativeElements);
+    const noveltyScore = connections.length > 0 ? 0.8 : 0.5;
+    const confidence = (diversityScore + noveltyScore) / 2;
+
+    return {
+      synthesizedOutput: creativeOutput,
+      confidence,
+      contributingAgents: outputs.map(o => o.agentId),
+      synthesisMethod: 'creative_combination'
+    };
+  }
+
+  /**
+   * Resolve conflicts between outputs
+   * @param input - Synthesis input
+   * @returns Synthesis result
+   */
+  private async resolveConflicts(input: SynthesisInput): Promise<Synthesis> {
+    const { outputs } = input;
+
+    if (outputs.length === 0) {
+      return {
+        synthesizedOutput: null,
+        confidence: 0,
+        contributingAgents: [],
+        synthesisMethod: 'conflict_resolution'
+      };
+    }
+
+    if (outputs.length === 1) {
+      return {
+        synthesizedOutput: outputs[0].output,
+        confidence: outputs[0].confidence,
+        contributingAgents: [outputs[0].agentId],
+        synthesisMethod: 'conflict_resolution'
+      };
+    }
+
+    // Identify conflicts
+    const conflicts = this.identifyConflicts(outputs);
+
+    if (conflicts.length === 0) {
+      // No conflicts, use consensus
+      return this.buildConsensus(input);
+    }
+
+    // Resolve each conflict
+    const resolutions = conflicts.map(conflict => ({
+      conflict,
+      resolution: this.resolveConflict(conflict, outputs)
+    }));
+
+    // Merge resolved conflicts with non-conflicting content
+    const finalOutput = this.mergeResolutions(outputs, resolutions);
+
+    // Calculate confidence
+    const avgConfidence = outputs.reduce((sum, o) => sum + o.confidence, 0) / outputs.length;
+    const resolutionQuality = resolutions.length > 0
+      ? resolutions.reduce((sum, r) => sum + r.resolution.confidence, 0) / resolutions.length
+      : 1;
+
+    return {
+      synthesizedOutput: finalOutput,
+      confidence: (avgConfidence + resolutionQuality) / 2,
+      contributingAgents: outputs.map(o => o.agentId),
+      synthesisMethod: 'conflict_resolution',
+      dissentPoints: conflicts.map(c => c.description)
+    };
+  }
+
+  // ============================================================================
+  // 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;
+  }
+}