cc-codeconductor 0.2.9 → 0.2.10

package/presets/claude/skills/multi-agent-orchestration/examples/orchestration_patterns.py

@@ -0,0 +1,411 @@
+"""
+Multi-Agent Orchestration Patterns
+
+Implements sequential, parallel, hierarchical, and consensus orchestration.
+"""
+
+from typing import List, Dict, Any, Optional
+import asyncio
+from abc import ABC, abstractmethod
+
+
+class Agent(ABC):
+    """Base agent class."""
+
+    def __init__(self, name: str, role: str, goal: str):
+        """Initialize agent."""
+        self.name = name
+        self.role = role
+        self.goal = goal
+
+    @abstractmethod
+    def work(self, task: str) -> str:
+        """Execute task."""
+        pass
+
+    async def work_async(self, task: str) -> str:
+        """Execute task asynchronously."""
+        return self.work(task)
+
+
+class SimpleAgent(Agent):
+    """Simple agent implementation."""
+
+    def __init__(self, name: str, role: str, goal: str):
+        """Initialize simple agent."""
+        super().__init__(name, role, goal)
+
+    def work(self, task: str) -> str:
+        """Simulate agent work."""
+        return f"{self.name}: Completed task - {task[:50]}..."
+
+
+class SequentialOrchestrator:
+    """Orchestrate agents to work sequentially."""
+
+    def __init__(self, agents: List[Agent]):
+        """
+        Initialize orchestrator with agents.
+
+        Args:
+            agents: List of agents to orchestrate
+        """
+        self.agents = agents
+        self.execution_log = []
+
+    def execute(self, initial_task: str) -> Dict[str, Any]:
+        """
+        Execute agents sequentially.
+
+        Args:
+            initial_task: Initial task description
+
+        Returns:
+            Execution results dictionary
+        """
+        current_input = initial_task
+        results = {}
+
+        for agent in self.agents:
+            result = agent.work(current_input)
+            results[agent.name] = result
+            self.execution_log.append({
+                "agent": agent.name,
+                "role": agent.role,
+                "task": current_input,
+                "result": result,
+            })
+            # Next agent uses this agent's output
+            current_input = result
+
+        return {
+            "type": "sequential",
+            "results": results,
+            "final_output": current_input,
+            "execution_log": self.execution_log,
+        }
+
+
+class ParallelOrchestrator:
+    """Orchestrate agents to work in parallel."""
+
+    def __init__(self, agents: List[Agent]):
+        """Initialize parallel orchestrator."""
+        self.agents = agents
+        self.execution_log = []
+
+    async def execute_async(self, task: str) -> Dict[str, Any]:
+        """
+        Execute agents in parallel.
+
+        Args:
+            task: Task description
+
+        Returns:
+            Execution results dictionary
+        """
+        # Create async tasks for all agents
+        tasks = [agent.work_async(task) for agent in self.agents]
+
+        # Execute all in parallel
+        results_list = await asyncio.gather(*tasks)
+
+        results = {
+            agent.name: result
+            for agent, result in zip(self.agents, results_list)
+        }
+
+        self.execution_log.append({
+            "type": "parallel",
+            "task": task,
+            "agents": [a.name for a in self.agents],
+            "results": results,
+        })
+
+        return {
+            "type": "parallel",
+            "results": results,
+            "execution_log": self.execution_log,
+        }
+
+    def execute(self, task: str) -> Dict[str, Any]:
+        """Execute agents synchronously (sequential fallback)."""
+        return asyncio.run(self.execute_async(task))
+
+
+class HierarchicalOrchestrator:
+    """Orchestrate agents in hierarchical structure."""
+
+    def __init__(self, manager_agent: Agent, specialist_teams: Dict[str, List[Agent]]):
+        """
+        Initialize hierarchical orchestrator.
+
+        Args:
+            manager_agent: Manager agent
+            specialist_teams: Dict of team names to lists of agents
+        """
+        self.manager = manager_agent
+        self.specialist_teams = specialist_teams
+        self.execution_log = []
+
+    def execute(self, main_task: str) -> Dict[str, Any]:
+        """
+        Execute with hierarchical structure.
+
+        Args:
+            main_task: Main task for manager
+
+        Returns:
+            Execution results
+        """
+        team_results = {}
+
+        # Manager assigns tasks to teams
+        for team_name, agents in self.specialist_teams.items():
+            # Each team works on their aspect
+            team_task = f"{main_task} - Team: {team_name}"
+            team_result = {}
+
+            for agent in agents:
+                result = agent.work(team_task)
+                team_result[agent.name] = result
+
+            team_results[team_name] = team_result
+
+            self.execution_log.append({
+                "team": team_name,
+                "agents": [a.name for a in agents],
+                "results": team_result,
+            })
+
+        # Manager synthesizes results
+        manager_result = self.manager.work(
+            f"Synthesize findings from: {list(team_results.keys())}"
+        )
+
+        return {
+            "type": "hierarchical",
+            "team_results": team_results,
+            "manager_synthesis": manager_result,
+            "execution_log": self.execution_log,
+        }
+
+
+class ConsensusOrchestrator:
+    """Orchestrate agent debate and consensus."""
+
+    def __init__(self, agents: List[Agent], mediator_agent: Agent):
+        """Initialize consensus orchestrator."""
+        self.agents = agents
+        self.mediator = mediator_agent
+        self.debate_history = []
+
+    def execute(self, question: str, rounds: int = 2) -> Dict[str, Any]:
+        """
+        Execute debate and reach consensus.
+
+        Args:
+            question: Question for debate
+            rounds: Number of debate rounds
+
+        Returns:
+            Consensus results
+        """
+        # Round 1: Initial positions
+        positions = {}
+        for agent in self.agents:
+            position = agent.work(f"Argue your position on: {question}")
+            positions[agent.name] = position
+            self.debate_history.append({
+                "round": 1,
+                "agent": agent.name,
+                "position": position,
+            })
+
+        # Additional rounds: Response to others
+        for round_num in range(2, rounds + 1):
+            for agent in self.agents:
+                other_positions = {
+                    name: pos
+                    for name, pos in positions.items()
+                    if name != agent.name
+                }
+                response = agent.work(
+                    f"Respond to these positions: {str(other_positions)}"
+                )
+                self.debate_history.append({
+                    "round": round_num,
+                    "agent": agent.name,
+                    "response": response,
+                })
+
+        # Mediator reaches consensus
+        consensus = self.mediator.work(
+            f"Synthesize consensus from debate on: {question}"
+        )
+
+        return {
+            "type": "consensus",
+            "question": question,
+            "initial_positions": positions,
+            "debate_rounds": rounds,
+            "consensus": consensus,
+            "debate_history": self.debate_history,
+        }
+
+
+class AdaptiveOrchestrator:
+    """Adapt orchestration based on progress."""
+
+    def __init__(self, agents: List[Agent]):
+        """Initialize adaptive orchestrator."""
+        self.agents = agents
+        self.execution_log = []
+
+    def execute_with_adaptation(
+        self,
+        initial_task: str,
+        progress_threshold: float = 0.7,
+        quality_threshold: float = 0.6,
+    ) -> Dict[str, Any]:
+        """
+        Execute with adaptive workflow changes.
+
+        Args:
+            initial_task: Initial task
+            progress_threshold: Threshold for adding resources
+            quality_threshold: Threshold for adding validation
+
+        Returns:
+            Adaptive execution results
+        """
+        results = {}
+        current_task = initial_task
+        active_agents = self.agents.copy()
+
+        for iteration in range(3):
+            # Execute with current agents
+            iteration_results = {}
+            for agent in active_agents:
+                result = agent.work(current_task)
+                iteration_results[agent.name] = result
+
+            results[f"iteration_{iteration}"] = iteration_results
+
+            # Assess progress
+            progress = self._calculate_progress(iteration_results)
+            quality = self._calculate_quality(iteration_results)
+
+            log_entry = {
+                "iteration": iteration,
+                "agents": [a.name for a in active_agents],
+                "progress": progress,
+                "quality": quality,
+            }
+
+            # Adapt based on progress
+            if progress < progress_threshold and iteration < 2:
+                # Add more agents
+                log_entry["adaptation"] = "Added specialist agent"
+                self.execution_log.append(log_entry)
+            elif quality < quality_threshold and iteration < 2:
+                # Add validation step
+                log_entry["adaptation"] = "Added validation agent"
+                self.execution_log.append(log_entry)
+            else:
+                self.execution_log.append(log_entry)
+
+        return {
+            "type": "adaptive",
+            "results": results,
+            "adaptations": self.execution_log,
+        }
+
+    @staticmethod
+    def _calculate_progress(results: Dict) -> float:
+        """Calculate progress score."""
+        # Simple heuristic based on results
+        return min(len(results) / 3.0, 1.0)
+
+    @staticmethod
+    def _calculate_quality(results: Dict) -> float:
+        """Calculate quality score."""
+        # Simple heuristic
+        return 0.7  # Placeholder
+
+
+class WorkflowGraph:
+    """Define workflow as directed acyclic graph (DAG)."""
+
+    def __init__(self):
+        """Initialize workflow graph."""
+        self.nodes = {}
+        self.edges = []
+
+    def add_node(self, node_id: str, agent: Agent) -> None:
+        """Add agent node."""
+        self.nodes[node_id] = agent
+
+    def add_edge(self, from_node: str, to_node: str) -> None:
+        """Add dependency edge."""
+        self.edges.append((from_node, to_node))
+
+    def execute_dag(self, initial_task: str) -> Dict[str, Any]:
+        """
+        Execute workflow as DAG.
+
+        Args:
+            initial_task: Initial task
+
+        Returns:
+            Execution results
+        """
+        results = {}
+        ready_nodes = self._find_ready_nodes()
+
+        while ready_nodes:
+            for node_id in ready_nodes:
+                agent = self.nodes[node_id]
+                # Get input from dependencies
+                task_input = self._get_node_input(node_id, results, initial_task)
+                result = agent.work(task_input)
+                results[node_id] = result
+
+            ready_nodes = self._find_ready_nodes(completed=set(results.keys()))
+
+        return {
+            "type": "dag",
+            "results": results,
+            "nodes": list(self.nodes.keys()),
+            "edges": self.edges,
+        }
+
+    def _find_ready_nodes(self, completed: Optional[set] = None) -> List[str]:
+        """Find nodes with all dependencies completed."""
+        if completed is None:
+            completed = set()
+
+        ready = []
+        for node_id in self.nodes:
+            if node_id not in completed:
+                dependencies = [
+                    from_node
+                    for from_node, to_node in self.edges
+                    if to_node == node_id
+                ]
+                if all(dep in completed for dep in dependencies):
+                    ready.append(node_id)
+
+        return ready
+
+    def _get_node_input(
+        self, node_id: str, results: Dict, initial_task: str
+    ) -> str:
+        """Get input for node from dependencies."""
+        dependencies = [
+            from_node for from_node, to_node in self.edges if to_node == node_id
+        ]
+        if not dependencies:
+            return initial_task
+        # Combine outputs from dependencies
+        return " + ".join(results.get(dep, "") for dep in dependencies)