class AgentState(str, Enum):
    INITIALIZING = "initializing"  # Agent is being created
    IDLE = "idle"                  # Ready for new tasks
    BUSY = "busy"                  # Processing a task
    PAUSED = "paused"             # Temporarily suspended
    STOPPED = "stopped"           # No longer accepting tasks
    ERROR = "error"               # Encountered an error

class AgentRole(str, Enum):
    USER = "user"               # Human user role
    ASSISTANT = "assistant"     # General assistant
    SYSTEM = "system"          # System-level operations
    FUNCTION = "function"      # Function execution
    CRITIC = "critic"          # Review and feedback
    EXECUTOR = "executor"      # Task execution

from agentic_fleet.agent.specialized.code import (
    ArchitectAgent,
    DeveloperAgent,
    ReviewerAgent
)

# Create a code architect
architect = ArchitectAgent(
    name="architect",
    expertise=["system_design", "architecture"],
    capabilities=["design", "planning"]
)

# Create a developer
developer = DeveloperAgent(
    name="developer",
    expertise=["python", "javascript"],
    capabilities=["implementation", "testing"]
)

from agentic_fleet.agent.specialized.research import (
    ResearcherAgent,
    AnalystAgent
)

# Create a researcher
researcher = ResearcherAgent(
    name="researcher",
    expertise=["literature_review", "data_analysis"],
    capabilities=["search", "summarize"]
)

class MessageType(str, Enum):
    TEXT = "text"               # Plain text messages
    CODE = "code"              # Code snippets
    FUNCTION_CALL = "function_call"  # Function invocations
    TOOL_CALL = "tool_call"    # Tool usage
    ERROR = "error"            # Error messages
    RESULT = "result"          # Task results

message = AgentMessage(
    source="developer",
    target="reviewer",
    content="Code review request for feature X",
    type=MessageType.TEXT,
    metadata={
        "priority": 5,
        "task_id": "task_123",
        "context": {
            "file": "main.py",
            "changes": ["function_a", "function_b"]
        }
    }
)

async def process_task(self, task: Task) -> TaskResult:
    """Process a task and return results."""
    try:
        # Validate task
        self.validate_task(task)
        
        # Update state
        self.state = AgentState.BUSY
        
        # Process based on capabilities
        if "code_review" in self.capabilities:
            result = await self.review_code(task)
        elif "implementation" in self.capabilities:
            result = await self.implement_feature(task)
            
        return TaskResult(
            status="success",
            output=result,
            metadata={"agent": self.name}
        )
    except Exception as e:
        self.state = AgentState.ERROR
        raise AgentError(f"Task processing failed: {str(e)}")

class FleetIntegratedAgent(BaseAgent):
    def __init__(
        self,
        name: str,
        fleet: Fleet,
        role: AgentRole,
        **kwargs
    ):
        super().__init__(name=name, role=role, **kwargs)
        self.fleet = fleet
        self.message_queue = asyncio.Queue()
        
    async def handle_fleet_message(
        self,
        message: AgentMessage
    ) -> Optional[AgentMessage]:
        """Handle messages from the fleet."""
        if message.type == MessageType.TASK:
            result = await self.process_task(message.content)
            return AgentMessage(
                source=self.name,
                target=message.source,
                content=result,
                type=MessageType.RESULT
            )
        return None

from agentic_fleet import Agent, AgentCapabilities

agent = Agent.create(
    name="code_reviewer",
    capabilities=[
        AgentCapabilities.CODE_REVIEW,
        AgentCapabilities.DOCUMENTATION
    ],
    model="gpt-4",
    temperature=0.7
)

{
  "name": "code_reviewer",
  "capabilities": ["code_review", "documentation"],
  "model": "gpt-4",
  "temperature": 0.7,
  "system_message": "You are a skilled code reviewer..."
}

{
  "agent_id": "agt_123abc",
  "name": "code_reviewer",
  "capabilities": ["code_review", "documentation"],
  "status": "active",
  "created_at": "2025-02-24T15:30:00Z"
}

agents = Agent.list(limit=10, offset=0)

{
  "agents": [
    {
      "agent_id": "agt_123abc",
      "name": "code_reviewer",
      "capabilities": ["code_review", "documentation"],
      "status": "active"
    }
  ],
  "total": 1,
  "has_more": false
}

agent = Agent.get("agt_123abc")

{
  "agent_id": "agt_123abc",
  "name": "code_reviewer",
  "capabilities": ["code_review", "documentation"],
  "model": "gpt-4",
  "temperature": 0.7,
  "status": "active",
  "created_at": "2025-02-24T15:30:00Z",
  "last_active": "2025-02-24T16:00:00Z"
}

agent = Agent.update(
    "agt_123abc",
    name="senior_reviewer",
    temperature=0.8
)

{
  "name": "senior_reviewer",
  "temperature": 0.8
}

{
  "agent_id": "agt_123abc",
  "name": "senior_reviewer",
  "capabilities": ["code_review", "documentation"],
  "temperature": 0.8,
  "status": "active",
  "updated_at": "2025-02-24T16:05:00Z"
}

Agent.delete("agt_123abc")

{
  "deleted": true,
  "agent_id": "agt_123abc"
}

class AgentError(Exception):
    def __init__(
        self,
        message: str,
        agent_name: str = None,
        task_id: str = None
    ):
        self.agent_name = agent_name
        self.task_id = task_id
        super().__init__(message)

try:
    result = await agent.process_task(task)
except AgentError as e:
    logger.error(f"Agent {e.agent_name} failed task {e.task_id}: {str(e)}")
    # Handle error appropriately