from config.settings import get_settings

settings = get_settings()
print(f"Using model: {settings.gemini_model}")

import asyncio
from agents.agent_factory import AgentFactory
from core.agent_types import AgentInput

async def main():
    # Create research agent
    agent = AgentFactory.create_research_agent(
        agent_id="researcher",
        research_depth="medium"
    )
    
    await agent.start()
    
    # Submit research task
    research_input = AgentInput(
        content={
            "query": "What are the latest AI developments?",
            "type": "trend",
            "depth": "medium"
        }
    )
    
    task_id = await agent.submit_task(research_input)
    result = await agent.get_task_result(task_id)
    
    print(f"Research findings: {result.content}")
    
    await agent.stop()

asyncio.run(main())

import asyncio
from agents.agent_factory import AgentFactory
from communication.communication_handler import CommunicationHandler

async def collaboration_example():
    # Setup communication
    comm_handler = CommunicationHandler()
    await comm_handler.initialize()
    
    # Create agent pair
    research_agent, synthesis_agent = AgentFactory.create_agent_pair(
        base_id="collab_demo"
    )
    
    # Configure communication
    research_agent.set_communication_handler(comm_handler)
    synthesis_agent.set_communication_handler(comm_handler)
    
    await research_agent.start()
    await synthesis_agent.start()
    
    # Research phase
    research_input = AgentInput(
        content={"query": "AI ethics principles", "type": "technical"}
    )
    task_id = await research_agent.submit_task(research_input)
    research_result = await research_agent.get_task_result(task_id)
    
    # Synthesis phase
    synthesis_input = AgentInput(
        content={
            "topic": "AI Ethics Analysis",
            "sources": [research_result.content],
            "type": "analysis"
        }
    )
    task_id = await synthesis_agent.submit_task(synthesis_input)
    synthesis_result = await synthesis_agent.get_task_result(task_id)
    
    print(f"Final analysis: {synthesis_result.content}")
    
    # Cleanup
    await research_agent.stop()
    await synthesis_agent.stop()
    await comm_handler.shutdown()

asyncio.run(collaboration_example())

from memory.memory_store import MemoryStore

async def memory_example():
    memory = MemoryStore("my_agent")
    
    # Store different types of memories
    conversation_id = await memory.remember_conversation([
        {"role": "user", "content": "Explain machine learning"},
        {"role": "assistant", "content": "ML is a subset of AI..."}
    ])
    
    fact_id = await memory.remember_fact(
        "Python is a programming language",
        source="Programming guide"
    )
    
    procedure_id = await memory.remember_procedure(
        "Code Review Process",
        ["Read code", "Check logic", "Test functionality", "Approve"]
    )
    
    # Search memories
    results = await memory.search_memories(query="machine learning")
    important = await memory.get_important_memories(min_importance=0.8)
    
    print(f"Found {len(results)} relevant memories")
    print(f"Found {len(important)} important memories")

from core.base_agent import BaseAgent
from core.agent_types import AgentCapability, AgentInput, AgentOutput

class CustomAgent(BaseAgent):
    def get_capabilities(self):
        return [AgentCapability.ANALYSIS, AgentCapability.REASONING]
    
    async def process(self, input_data: AgentInput) -> AgentOutput:
        # Implement custom processing logic
        result = await self.custom_processing(input_data.content)
        
        return AgentOutput(
            content=result,
            source_agent=self.agent_id,
            confidence=0.85
        )
    
    async def custom_processing(self, content):
        # Your custom logic here
        return {"processed": content}

# Register with factory
from agents.agent_factory import AgentFactory
AgentFactory.register_agent_type("custom", CustomAgent)

# Use the custom agent
agent = AgentFactory.create_agent("custom", "my_custom_agent")

from communication.message_broker import MessageBroker

class WebSocketBroker(MessageBroker):
    async def publish(self, channel: str, message: AgentMessage):
        # Implement WebSocket publishing
        pass
    
    async def subscribe(self, channel: str, handler):
        # Implement WebSocket subscription
        pass

# Use custom broker
from communication.communication_handler import CommunicationHandler
comm_handler = CommunicationHandler(WebSocketBroker())

# Get agent performance metrics
metrics = agent.get_metrics()
print(f"Tasks processed: {metrics['tasks_processed']}")
print(f"Average time: {metrics['total_processing_time'] / metrics['tasks_processed']}")

# Get communication status
status = comm_handler.get_status()
print(f"Active agents: {status['registered_agents']}")
print(f"Message history: {status['message_history_size']}")

# Get message history
history = await comm_handler.get_message_history(limit=10)

# Get memory usage statistics
stats = await memory_store.get_memory_stats()
print(f"Total memories: {stats['total_memories']}")
print(f"Memory types: {stats['memory_types']}")

# Check Python version
python --version  # Should be 3.9+