agi-framework 0.2.0__py3-none-any.whl

agents/__init__.py

@@ -0,0 +1,19 @@
+"""Agent framework modules"""
+from base_agent import BaseAgent, SpecializedAgent, ResearcherAgent, PlannerAgent, ExecutorAgent, CriticAgent, MonitorAgent, AgentConfig, AgentMessage
+from crew import Crew, CrewBuilder, CommunicationPattern, CrewConfig
+
+__all__ = [
+    "BaseAgent",
+    "SpecializedAgent",
+    "ResearcherAgent",
+    "PlannerAgent",
+    "ExecutorAgent",
+    "CriticAgent",
+    "MonitorAgent",
+    "AgentConfig",
+    "AgentMessage",
+    "Crew",
+    "CrewBuilder",
+    "CommunicationPattern",
+    "CrewConfig"
+]

agents/base_agent.py

@@ -0,0 +1,311 @@
+"""
+Agent Framework: Base Agent and Agent Execution
+"""
+
+from typing import Dict, List, Any, Optional, Callable
+from dataclasses import dataclass, field
+from datetime import datetime
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AgentConfig:
+    """Agent configuration"""
+    name: str
+    role: str = "general"
+    reasoning_pattern: str = "cot"  # cot, react, tot, got
+    memory_enabled: bool = True
+    self_improvement_enabled: bool = True
+    max_iterations: int = 10
+    timeout: int = 300  # seconds
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class AgentMessage:
+    """Message in agent communication"""
+    sender: str
+    recipient: str
+    content: str
+    message_type: str = "task"  # task, result, feedback, query
+    timestamp: datetime = field(default_factory=datetime.now)
+    parent_id: Optional[str] = None
+
+
+class BaseAgent:
+    """Base Agent class with reasoning and memory"""
+    
+    def __init__(self, config: AgentConfig):
+        self.config = config
+        self.name = config.name
+        self.role = config.role
+        self.reasoning_pattern = config.reasoning_pattern
+        
+        self.memory = {}
+        self.execution_history: List[Dict[str, Any]] = []
+        self.task_queue: List[Dict[str, Any]] = []
+        self.message_history: List[AgentMessage] = []
+        
+        logger.info(f"Initialized agent: {self.name} (role: {self.role})")
+    
+    def process_task(self, task: Dict[str, Any]) -> Dict[str, Any]:
+        """Process a task"""
+        logger.info(f"[{self.name}] Processing task: {task.get('description', 'Unknown')}")
+        
+        execution_log = {
+            'agent': self.name,
+            'task': task,
+            'start_time': datetime.now(),
+            'steps': []
+        }
+        
+        # Step 1: Reason
+        reasoning_step = {
+            'phase': 'reasoning',
+            'pattern': self.reasoning_pattern,
+            'input': task.get('input', '')
+        }
+        
+        if self.reasoning_pattern == 'cot':
+            reasoning_step['output'] = f"Reasoning through: {task.get('description')}"
+        elif self.reasoning_pattern == 'react':
+            reasoning_step['output'] = f"Plan and act on: {task.get('description')}"
+        else:
+            reasoning_step['output'] = f"Analyzing: {task.get('description')}"
+        
+        execution_log['steps'].append(reasoning_step)
+        
+        # Step 2: Act
+        action_step = {
+            'phase': 'action',
+            'action_type': task.get('action', 'generic'),
+            'result': f"Executed {task.get('action', 'action')}"
+        }
+        execution_log['steps'].append(action_step)
+        
+        # Step 3: Reflect (if enabled)
+        if self.config.self_improvement_enabled:
+            reflection_step = {
+                'phase': 'reflection',
+                'feedback': f"Task progress: {action_step['result']}"
+            }
+            execution_log['steps'].append(reflection_step)
+        
+        execution_log['end_time'] = datetime.now()
+        execution_log['success'] = True
+        
+        self.execution_history.append(execution_log)
+        
+        result = {
+            'agent': self.name,
+            'success': True,
+            'result': action_step['result'],
+            'execution_log': execution_log
+        }
+        
+        logger.info(f"[{self.name}] Task completed successfully")
+        return result
+    
+    def send_message(self, recipient: str, content: str, message_type: str = "task") -> AgentMessage:
+        """Send message to another agent"""
+        message = AgentMessage(
+            sender=self.name,
+            recipient=recipient,
+            content=content,
+            message_type=message_type
+        )
+        self.message_history.append(message)
+        logger.debug(f"[{self.name}] Message sent to {recipient}: {message_type}")
+        return message
+    
+    def receive_message(self, message: AgentMessage):
+        """Receive message from another agent"""
+        self.message_history.append(message)
+        logger.debug(f"[{self.name}] Message received from {message.sender}")
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Get agent status"""
+        return {
+            'name': self.name,
+            'role': self.role,
+            'reasoning_pattern': self.reasoning_pattern,
+            'tasks_executed': len(self.execution_history),
+            'messages_sent': len([m for m in self.message_history if m.sender == self.name]),
+            'messages_received': len([m for m in self.message_history if m.recipient == self.name]),
+            'timestamp': datetime.now()
+        }
+
+
+class SpecializedAgent(BaseAgent):
+    """Specialized agent with specific role"""
+    
+    def __init__(self, config: AgentConfig, specialization: str):
+        super().__init__(config)
+        self.specialization = specialization
+        logger.info(f"[{self.name}] Specialized as: {specialization}")
+    
+    def process_task(self, task: Dict[str, Any]) -> Dict[str, Any]:
+        """Process task with specialization"""
+        logger.info(f"[{self.name}:{self.specialization}] Processing task")
+        
+        # Add specialization context
+        task_with_spec = {**task, 'specialization_context': self.specialization}
+        
+        result = super().process_task(task_with_spec)
+        result['specialization'] = self.specialization
+        
+        return result
+
+
+class ResearcherAgent(SpecializedAgent):
+    """Agent specialized in research"""
+    
+    def __init__(self, name: str = "Researcher"):
+        config = AgentConfig(
+            name=name,
+            role="research",
+            reasoning_pattern="cot"
+        )
+        super().__init__(config, "research")
+    
+    def research(self, topic: str) -> Dict[str, Any]:
+        """Conduct research on a topic"""
+        task = {
+            'description': f'Research topic: {topic}',
+            'action': 'research',
+            'input': topic
+        }
+        return self.process_task(task)
+
+
+class PlannerAgent(SpecializedAgent):
+    """Agent specialized in planning"""
+    
+    def __init__(self, name: str = "Planner"):
+        config = AgentConfig(
+            name=name,
+            role="planning",
+            reasoning_pattern="tot"
+        )
+        super().__init__(config, "planning")
+    
+    def plan(self, objective: str) -> Dict[str, Any]:
+        """Create a plan"""
+        task = {
+            'description': f'Create plan for: {objective}',
+            'action': 'plan',
+            'input': objective
+        }
+        return self.process_task(task)
+
+
+class ExecutorAgent(SpecializedAgent):
+    """Agent specialized in execution"""
+    
+    def __init__(self, name: str = "Executor"):
+        config = AgentConfig(
+            name=name,
+            role="execution",
+            reasoning_pattern="react"
+        )
+        super().__init__(config, "execution")
+    
+    def execute(self, plan: str) -> Dict[str, Any]:
+        """Execute a plan"""
+        task = {
+            'description': f'Execute plan: {plan}',
+            'action': 'execute',
+            'input': plan
+        }
+        return self.process_task(task)
+
+
+class CriticAgent(SpecializedAgent):
+    """Agent specialized in critique and feedback"""
+    
+    def __init__(self, name: str = "Critic"):
+        config = AgentConfig(
+            name=name,
+            role="critique",
+            reasoning_pattern="cot"
+        )
+        super().__init__(config, "critique")
+    
+    def critique(self, work: str) -> Dict[str, Any]:
+        """Critique work"""
+        task = {
+            'description': f'Critique: {work}',
+            'action': 'critique',
+            'input': work
+        }
+        result = self.process_task(task)
+        
+        # Add critique feedback
+        result['critique_feedback'] = {
+            'strengths': ['Well-structured', 'Clear reasoning'],
+            'weaknesses': ['Could be more detailed'],
+            'suggestions': ['Add more context', 'Consider edge cases']
+        }
+        
+        return result
+
+
+class MonitorAgent(SpecializedAgent):
+    """Agent specialized in monitoring and oversight"""
+    
+    def __init__(self, name: str = "Monitor"):
+        config = AgentConfig(
+            name=name,
+            role="monitoring",
+            reasoning_pattern="cot"
+        )
+        super().__init__(config, "monitoring")
+    
+    def monitor(self, agents: List[BaseAgent]) -> Dict[str, Any]:
+        """Monitor team of agents"""
+        monitoring_report = {
+            'timestamp': datetime.now(),
+            'agents_monitored': len(agents),
+            'agent_statuses': []
+        }
+        
+        for agent in agents:
+            status = agent.get_status()
+            monitoring_report['agent_statuses'].append(status)
+        
+        return monitoring_report
+
+
+if __name__ == "__main__":
+    # Example: Create different agents
+    researcher = ResearcherAgent("Dr. Smith")
+    planner = PlannerAgent("Strategic Planner")
+    executor = ExecutorAgent("Action Taker")
+    critic = CriticAgent("Quality Assurance")
+    
+    print("=== Agent Communication Example ===\n")
+    
+    # Research phase
+    research_result = researcher.research("Advanced AI techniques")
+    print(f"[Research] {researcher.name}: {research_result['result']}")
+    
+    # Planning phase
+    plan_result = planner.plan(research_result['result'])
+    print(f"[Planning] {planner.name}: {plan_result['result']}")
+    
+    # Execution phase
+    exec_result = executor.execute(plan_result['result'])
+    print(f"[Execution] {executor.name}: {exec_result['result']}")
+    
+    # Critique phase
+    critique_result = critic.critique(exec_result['result'])
+    print(f"[Critique] {critic.name}: {critique_result['result']}")
+    
+    # Get statuses
+    print("\n=== Agent Statuses ===")
+    for agent in [researcher, planner, executor, critic]:
+        status = agent.get_status()
+        print(f"{agent.name}: executed {status['tasks_executed']} tasks")

agents/crew.py

@@ -0,0 +1,362 @@
+"""
+Multi-Agent Crew Orchestration
+Supervisor-based team coordination
+"""
+
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field
+from enum import Enum
+from datetime import datetime
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class CommunicationPattern(Enum):
+    """Communication patterns for agent cooperation"""
+    SEQUENTIAL = "sequential"
+    PARALLEL = "parallel"
+    HIERARCHICAL = "hierarchical"
+    DEBATE = "debate"  # Multi-agent critique
+
+
+@dataclass
+class CrewConfig:
+    """Configuration for agent crew"""
+    name: str
+    communication_pattern: CommunicationPattern = CommunicationPattern.HIERARCHICAL
+    max_iterations: int = 3
+    enable_reflection: bool = True
+    enable_tool_sharing: bool = True
+
+
+class Crew:
+    """Team of cooperative agents supervised by a central controller"""
+    
+    def __init__(self, config: CrewConfig):
+        self.config = config
+        self.name = config.name
+        self.agents: Dict[str, Any] = {}
+        self.supervisor = None
+        self.message_queue: List[Dict[str, Any]] = []
+        self.execution_log: List[Dict[str, Any]] = []
+        self.state: Dict[str, Any] = {}
+        
+        logger.info(f"Initialized Crew: {self.name} (pattern: {config.communication_pattern.value})")
+    
+    def add_agent(self, agent_name: str, agent: Any, role: Optional[str] = None):
+        """Add agent to crew"""
+        self.agents[agent_name] = {
+            'agent': agent,
+            'role': role or agent.role,
+            'status': 'idle',
+            'assigned_tasks': []
+        }
+        logger.info(f"Added agent: {agent_name} (role: {role})")
+    
+    def set_supervisor(self, supervisor_agent: Any):
+        """Set supervisor agent"""
+        self.supervisor = supervisor_agent
+        logger.info(f"Supervisor set: {supervisor_agent.name}")
+    
+    def execute_task(self, task: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute task with crew"""
+        logger.info(f"[Crew:{self.name}] Executing task: {task.get('description', 'Unknown')}")
+        
+        execution = {
+            'task': task,
+            'start_time': datetime.now(),
+            'crew_name': self.name,
+            'communication_pattern': self.config.communication_pattern.value,
+            'phases': []
+        }
+        
+        if self.config.communication_pattern == CommunicationPattern.SEQUENTIAL:
+            execution['phases'] = self._execute_sequential(task)
+        
+        elif self.config.communication_pattern == CommunicationPattern.HIERARCHICAL:
+            execution['phases'] = self._execute_hierarchical(task)
+        
+        elif self.config.communication_pattern == CommunicationPattern.PARALLEL:
+            execution['phases'] = self._execute_parallel(task)
+        
+        elif self.config.communication_pattern == CommunicationPattern.DEBATE:
+            execution['phases'] = self._execute_debate(task)
+        
+        execution['end_time'] = datetime.now()
+        execution['success'] = True
+        
+        self.execution_log.append(execution)
+        logger.info(f"[Crew:{self.name}] Task completed")
+        
+        return execution
+    
+    def _execute_sequential(self, task: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute sequentially: each agent passes result to next"""
+        phases = []
+        current_input = task.get('input', '')
+        
+        for agent_name, agent_info in self.agents.items():
+            phase = {
+                'agent': agent_name,
+                'role': agent_info['role'],
+                'input': current_input,
+                'position': len(phases)
+            }
+            
+            # Simulate execution
+            result = f"Output from {agent_name} on: {current_input[:30]}"
+            phase['output'] = result
+            phase['success'] = True
+            
+            phases.append(phase)
+            current_input = result  # Chain result to next agent
+            
+            logger.debug(f"Sequential phase: {agent_name} completed")
+        
+        return phases
+    
+    def _execute_hierarchical(self, task: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute hierarchically: supervisor delegates to agents"""
+        phases = []
+        
+        if not self.supervisor:
+            logger.warning("No supervisor available for hierarchical execution")
+            return phases
+        
+        # Phase 1: Supervisor analysis
+        supervisor_phase = {
+            'agent': self.supervisor.name,
+            'phase_type': 'analysis',
+            'action': 'Analyze task and create plan'
+        }
+        phases.append(supervisor_phase)
+        
+        # Phase 2: Distribute to agents
+        num_agents = len(self.agents)
+        for idx, (agent_name, agent_info) in enumerate(self.agents.items()):
+            agent_phase = {
+                'agent': agent_name,
+                'role': agent_info['role'],
+                'phase_type': 'execution',
+                'subtask': f"Subtask {idx+1}/{num_agents}",
+                'result': f"Completed by {agent_name}"
+            }
+            phases.append(agent_phase)
+            logger.debug(f"Hierarchical delegation: {agent_name}")
+        
+        # Phase 3: Supervisor synthesis
+        synthesis_phase = {
+            'agent': self.supervisor.name,
+            'phase_type': 'synthesis',
+            'action': 'Aggregate results and finalize'
+        }
+        phases.append(synthesis_phase)
+        
+        return phases
+    
+    def _execute_parallel(self, task: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute in parallel: all agents work independently"""
+        phases = []
+        
+        parallel_phase = {
+            'type': 'parallel_execution',
+            'agents': [],
+            'start_time': datetime.now()
+        }
+        
+        for agent_name, agent_info in self.agents.items():
+            agent_task = {
+                'agent': agent_name,
+                'role': agent_info['role'],
+                'assigned_task': f"{agent_name}'s subtask"
+            }
+            parallel_phase['agents'].append(agent_task)
+            logger.debug(f"Parallel task: {agent_name}")
+        
+        parallel_phase['end_time'] = datetime.now()
+        phases.append(parallel_phase)
+        
+        return phases
+    
+    def _execute_debate(self, task: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Execute with debate: agents critique each other's outputs"""
+        phases = []
+        
+        # Round 1: Initial proposals
+        round1 = {
+            'round': 1,
+            'type': 'initial_proposals',
+            'proposals': []
+        }
+        
+        for agent_name, agent_info in self.agents.items():
+            proposal = {
+                'agent': agent_name,
+                'proposal': f"Proposal from {agent_name}",
+                'confidence': 0.6 + (len(round1['proposals']) * 0.1)
+            }
+            round1['proposals'].append(proposal)
+        
+        phases.append(round1)
+        
+        # Round 2: Critique
+        round2 = {
+            'round': 2,
+            'type': 'critique',
+            'critiques': []
+        }
+        
+        for i, proposal in enumerate(round1['proposals']):
+            critique = {
+                'proposal_author': proposal['agent'],
+                'critique_by': list(self.agents.keys())[(i+1) % len(self.agents)],
+                'feedback': f"Feedback on {proposal['agent']}'s proposal"
+            }
+            round2['critiques'].append(critique)
+        
+        phases.append(round2)
+        
+        # Round 3: Final agreement
+        round3 = {
+            'round': 3,
+            'type': 'agreement',
+            'consensus': f"Consensus reached after debate"
+        }
+        phases.append(round3)
+        
+        logger.debug("Debate execution completed")
+        return phases
+    
+    def get_crew_status(self) -> Dict[str, Any]:
+        """Get overall crew status"""
+        status = {
+            'crew_name': self.name,
+            'num_agents': len(self.agents),
+            'communication_pattern': self.config.communication_pattern.value,
+            'agents': {},
+            'total_tasks_executed': len(self.execution_log),
+            'has_supervisor': self.supervisor is not None,
+            'timestamp': datetime.now()
+        }
+        
+        for agent_name, agent_info in self.agents.items():
+            status['agents'][agent_name] = {
+                'role': agent_info['role'],
+                'status': agent_info['status'],
+                'tasks_assigned': len(agent_info['assigned_tasks'])
+            }
+        
+        return status
+    
+    def save_execution_log(self, filepath: str):
+        """Save crew execution log"""
+        with open(filepath, 'w') as f:
+            json.dump(self.execution_log, f, indent=2, default=str)
+        logger.info(f"Execution log saved to {filepath}")
+
+
+class CrewBuilder:
+    """Builder for constructing crews"""
+    
+    def __init__(self, crew_name: str, pattern: CommunicationPattern = CommunicationPattern.HIERARCHICAL):
+        self.config = CrewConfig(
+            name=crew_name,
+            communication_pattern=pattern
+        )
+        self.agents_to_add: List[tuple] = []
+        self.supervisor_agent = None
+    
+    def add_agent(self, agent: Any, role: Optional[str] = None):
+        """Add agent to builder"""
+        self.agents_to_add.append((agent.name, agent, role))
+        return self
+    
+    def set_supervisor(self, supervisor_agent: Any):
+        """Set supervisor"""
+        self.supervisor_agent = supervisor_agent
+        return self
+    
+    def build(self) -> Crew:
+        """Build crew"""
+        crew = Crew(self.config)
+        
+        for agent_name, agent, role in self.agents_to_add:
+            crew.add_agent(agent_name, agent, role)
+        
+        if self.supervisor_agent:
+            crew.set_supervisor(self.supervisor_agent)
+        
+        logger.info(f"Crew built: {self.config.name} with {len(self.agents_to_add)} agents")
+        return crew
+
+
+# Example crew configurations
+def create_research_crew() -> Crew:
+    """Create a research crew"""
+    from agents.base_agent import ResearcherAgent, CriticAgent, PlannerAgent
+    
+    builder = CrewBuilder(
+        "Research Team",
+        CommunicationPattern.HIERARCHICAL
+    )
+    
+    researcher = ResearcherAgent("Senior Researcher")
+    critic = CriticAgent("Quality Advisor")
+    planner = PlannerAgent("Research Planner")
+    
+    builder.add_agent(researcher, "research")
+    builder.add_agent(planner, "planning")
+    builder.add_agent(critic, "critique")
+    builder.set_supervisor(planner)
+    
+    return builder.build()
+
+
+def create_execution_crew() -> Crew:
+    """Create an execution crew"""
+    from agents.base_agent import PlannerAgent, ExecutorAgent, MonitorAgent
+    
+    builder = CrewBuilder(
+        "Execution Team",
+        CommunicationPattern.SEQUENTIAL
+    )
+    
+    planner = PlannerAgent("Execution Planner")
+    executor = ExecutorAgent("Task Executor")
+    monitor = MonitorAgent("Execution Monitor")
+    
+    builder.add_agent(planner, "planning")
+    builder.add_agent(executor, "execution")
+    builder.add_agent(monitor, "monitoring")
+    builder.set_supervisor(planner)
+    
+    return builder.build()
+
+
+if __name__ == "__main__":
+    # Test different crew patterns
+    print("=== Hierarchical Crew ===")
+    
+    from agents.base_agent import ResearcherAgent, PlannerAgent, ExecutorAgent, CriticAgent
+    
+    builder = CrewBuilder("Test Crew", CommunicationPattern.HIERARCHICAL)
+    builder.add_agent(ResearcherAgent("R1"), "research")
+    builder.add_agent(PlannerAgent("P1"), "planning")
+    builder.add_agent(ExecutorAgent("E1"), "execution")
+    builder.add_agent(CriticAgent("C1"), "critique")
+    
+    supervisor = PlannerAgent("Supervisor")
+    builder.set_supervisor(supervisor)
+    
+    crew = builder.build()
+    
+    task = {
+        'description': 'Solve complex problem',
+        'input': 'Given problem statement'
+    }
+    
+    result = crew.execute_task(task)
+    print(f"Crew Status: {crew.get_crew_status()['num_agents']} agents")
+    print(f"Execution Phases: {len(result['phases'])} phases")