from praisonaiagents import RouterAgent

# Create a router agent with multiple models
router = RouterAgent(
    role="Intelligent Assistant",
    goal="Provide optimal responses using the best model for each task",
    backstory="You are an adaptive AI that selects the perfect model for every situation.",
    models=["gpt-4o", "gpt-4o-mini", "claude-3-5-sonnet-20241022", "deepseek-chat"],
    routing_strategy="auto"  # Automatic model selection
)

# The agent will automatically choose the best model
result = router.chat("Explain quantum computing")  # Might use GPT-4 for complex topics
result = router.chat("What's 2+2?")  # Might use GPT-4-mini for simple queries

# Automatic routing based on task complexity
router = RouterAgent(
    role="Smart Assistant",
    models=["gpt-4o", "gpt-4o-mini", "claude-3-5-sonnet-20241022"],
    routing_strategy="auto"
)

# Complex task - likely routes to GPT-4 or Claude
complex_result = router.chat(
    "Analyze this code for security vulnerabilities and suggest improvements"
)

# Simple task - likely routes to GPT-4-mini
simple_result = router.chat("Format this date: 2024-01-15")

# Prioritize cost-effective models
budget_router = RouterAgent(
    role="Cost-Conscious Assistant",
    models=["gpt-4o-mini", "deepseek-chat", "gpt-4o"],
    routing_strategy="cost-optimized",
    cost_threshold=0.01  # Maximum $0.01 per request
)

# Will use the cheapest model that can handle the task
result = budget_router.chat("Summarize this article: ...")

# Always use the best model
performance_router = RouterAgent(
    role="High-Performance Assistant",
    models=["gpt-4o", "claude-3-5-sonnet-20241022", "gpt-4o-mini"],
    routing_strategy="performance-optimized"
)

# Will use the highest-performing model regardless of cost
result = performance_router.chat("Generate a complex business strategy")

# User controls model selection
manual_router = RouterAgent(
    role="Configurable Assistant",
    models=["gpt-4o", "claude-3-5-sonnet-20241022", "deepseek-chat"],
    routing_strategy="manual"
)

# Specify model explicitly
# Note: Manual model selection is handled through routing_strategy
# The actual model selection happens based on task analysis
result = manual_router.chat(
    "Translate this to French"
    # Model will be selected based on manual routing logic
)

# Define custom capabilities for routing decisions
router = RouterAgent(
    role="Capability-Aware Assistant",
    models=["gpt-4o", "gpt-4-vision-preview", "deepseek-chat"],
    model_capabilities={
        "gpt-4o": ["reasoning", "coding", "general"],
        "gpt-4-vision-preview": ["vision", "image-analysis"],
        "deepseek-chat": ["coding", "technical"]
    }
)

# Router will select based on required capabilities
code_result = router.chat("Debug this Python code")  # Might choose deepseek-chat
image_result = router.chat("Analyze this image", images=["photo.jpg"])  # Will choose gpt-4-vision-preview

# Track model usage and costs
router = RouterAgent(
    role="Tracked Assistant",
    models=["gpt-4o", "gpt-4o-mini", "claude-3-5-sonnet-20241022"]
    # Usage tracking is built-in, no need for a parameter
)

# Use the router
for i in range(10):
    router.chat(f"Task {i}")

# Get usage report
usage_report = router.get_usage_report()
print(f"Total cost: ${usage_report['total_cost']}")
print(f"Model usage: {usage_report['model_usage']}")

# Configure fallback behavior
router = RouterAgent(
    role="Resilient Assistant",
    models=["gpt-4o", "claude-3-5-sonnet-20241022"],
    fallback_model="gpt-4o-mini"
    # Retry behavior is handled by the base Agent class
)

# If primary models fail, falls back to gpt-4o-mini
result = router.chat("Process this request")

from praisonaiagents import Agent, RouterAgent, Task, AgentTeam

# Create specialized router
router = RouterAgent(
    role="Task Router",
    goal="Route tasks to the optimal model",
    models=["gpt-4o", "gpt-4o-mini", "claude-3-5-sonnet-20241022"]
)

# Create task handler
handler = Agent(
    role="Task Handler",
    goal="Process routed tasks"
)

# Create workflow
task1 = Task(
    description="Analyze complexity and route appropriately",
    agent=router
)

task2 = Task(
    description="Process the routed result",
    agent=handler,
    context=[task1]
)

# Execute workflow
agents = AgentTeam(
    agents=[router, handler],
    tasks=[task1, task2]
)
agents.start()