Configuration API

from marsys.coordination.config import ExecutionConfig, StatusConfig, ErrorHandlingConfig

ExecutionConfig(
    # Timeouts
    convergence_timeout: float = 300.0,
    branch_timeout: float = 600.0,
    agent_acquisition_timeout: float = 240.0,
    step_timeout: float = 600.0,
    tool_execution_timeout: float = 120.0,
    user_interaction_timeout: float = 300.0,

    # Convergence behavior
    dynamic_convergence_enabled: bool = True,
    parent_completes_on_spawn: bool = True,
    auto_detect_convergence: bool = True,

    # Steering
    steering_mode: Literal["auto", "always", "error"] = "error",

    # User interaction
    user_first: bool = False,
    initial_user_msg: Optional[str] = None,
    user_interaction: str = "terminal",

    # Agent lifecycle management
    auto_cleanup_agents: bool = True,
    cleanup_scope: Literal["topology_nodes", "used_agents"] = "topology_nodes",

    # Sub-configurations
    status: StatusConfig = field(default_factory=StatusConfig),
    error_handling: Optional[ErrorHandlingConfig] = None
)

# Production configuration
config = ExecutionConfig(
    convergence_timeout=600.0,
    step_timeout=300.0,
    steering_mode="auto",
    status=StatusConfig.from_verbosity(1)
)

# Development configuration
dev_config = ExecutionConfig(
    step_timeout=30.0,
    steering_mode="always",
    status=StatusConfig.from_verbosity(2)
)

# Interactive configuration
interactive_config = ExecutionConfig(
    user_first=True,
    initial_user_msg="Hello! How can I help?",
    user_interaction_timeout=300.0
)

from marsys.coordination.config import StatusConfig, VerbosityLevel

StatusConfig(
    enabled: bool = False,
    verbosity: Optional[VerbosityLevel] = None,
    cli_output: bool = True,
    cli_colors: bool = True,
    show_thoughts: bool = True,
    show_tool_calls: bool = True,
    show_timings: bool = True,
    aggregation_window_ms: int = 500,
    aggregate_parallel: bool = True,
    show_agent_prefixes: bool = True,
    prefix_width: int = 20,
    prefix_alignment: str = "left"
)

class VerbosityLevel(IntEnum):
    QUIET = 0     # Minimal output
    NORMAL = 1    # Standard output
    VERBOSE = 2   # Detailed output

# Create from verbosity level (recommended)
status = StatusConfig.from_verbosity(1)

# Custom configuration
custom_status = StatusConfig(
    enabled=True,
    verbosity=VerbosityLevel.NORMAL,
    show_thoughts=True,
    show_tool_calls=True,
    cli_colors=False  # Disable colors for logs
)

from marsys.coordination.config import ErrorHandlingConfig

ErrorHandlingConfig(
    use_error_classification: bool = True,
    notify_on_critical_errors: bool = True,
    enable_error_routing: bool = True,
    preserve_error_context: bool = True,
    auto_retry_on_rate_limits: bool = True,
    max_rate_limit_retries: int = 3,
    pool_retry_attempts: int = 2,
    pool_retry_delay: float = 5.0,
    timeout_seconds: float = 300.0,
    timeout_retry_enabled: bool = False,
    provider_settings: Dict[str, Dict[str, Any]] = field(default_factory=dict)
)

# Aggressive retry strategy
aggressive = ErrorHandlingConfig(
    auto_retry_on_rate_limits=True,
    max_rate_limit_retries=10,
    timeout_retry_enabled=True,
    pool_retry_attempts=5
)

# Conservative strategy
conservative = ErrorHandlingConfig(
    auto_retry_on_rate_limits=False,
    max_rate_limit_retries=0,
    timeout_retry_enabled=False,
    enable_error_routing=True  # Route to user
)

# Custom provider settings
custom = ErrorHandlingConfig(
    provider_settings={
        "openai": {"max_retries": 5, "base_retry_delay": 30},
        "anthropic": {"max_retries": 3, "base_retry_delay": 60}
    }
)

from marsys.coordination.config import CommunicationConfig

CommunicationConfig(
    use_rich_formatting: bool = True,
    theme_name: str = "modern",
    prefix_width: int = 20,
    show_timestamps: bool = True,
    enable_history: bool = True,
    history_size: int = 1000,
    enable_tab_completion: bool = True,
    use_colors: bool = True,
    color_depth: str = "truecolor",
    input_timeout: Optional[float] = None,
    use_enhanced_terminal: bool = True,
    fallback_on_error: bool = True
)

def create_dev_config() -> ExecutionConfig:
    """Development configuration with verbose output."""
    return ExecutionConfig(
        status=StatusConfig(
            enabled=True,
            verbosity=VerbosityLevel.VERBOSE,
            show_thoughts=True,
            show_tool_calls=True
        ),
        step_timeout=30.0,
        steering_mode="always"
    )

def create_prod_config() -> ExecutionConfig:
    """Production configuration with minimal output."""
    return ExecutionConfig(
        status=StatusConfig.from_verbosity(0),
        step_timeout=600.0,
        convergence_timeout=1200.0,
        steering_mode="auto",
        error_handling=ErrorHandlingConfig(
            auto_retry_on_rate_limits=True,
            max_rate_limit_retries=5
        )
    )

import os
from dotenv import load_dotenv

load_dotenv()

config = ExecutionConfig(
    step_timeout=float(os.getenv("MARSYS_TIMEOUT", "300")),
    status=StatusConfig(
        verbosity=int(os.getenv("MARSYS_VERBOSITY", "1"))
    )
)

# Default behavior - auto-cleanup enabled
result = await Orchestra.run(
    task="Analyze data",
    topology=topology,
    execution_config=ExecutionConfig(
        auto_cleanup_agents=True  # Default
    )
)
# After run completes:
# 1. Closes model resources (aiohttp sessions, etc.)
# 2. Closes agent-specific resources (browsers, playwright, etc.)
# 3. Unregisters agents from registry (frees names for reuse)