kubiya-control-plane-api 0.9.15__py3-none-any.whl

control_plane_api/app/config/api_config.py

@@ -0,0 +1,469 @@
+"""
+API-specific configuration.
+
+This module contains settings specific to the Control Plane API server.
+"""
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import Field, validator, model_validator, AliasChoices
+from typing import List, Optional, Dict, Any
+import secrets
+import os
+from control_plane_api.version import get_sdk_version
+
+
+class APIConfig(BaseSettings):
+    """Configuration for Control Plane API server."""
+
+    # ==================== API Server Settings ====================
+
+    api_host: str = Field(
+        default="0.0.0.0",
+        description="API server host",
+    )
+
+    api_port: int = Field(
+        default=8000,
+        description="API server port",
+    )
+
+    api_workers: int = Field(
+        default=4,
+        description="Number of API worker processes",
+    )
+
+    api_title: str = Field(
+        default="Agent Control Plane API",
+        description="API title for documentation",
+    )
+
+    api_version: str = Field(
+        default_factory=get_sdk_version,
+        description="API version (dynamically read from package metadata)",
+    )
+    
+    api_description: str = Field(
+        default="Multi-tenant agent orchestration with Temporal workflows",
+        description="API description for documentation",
+    )
+    
+    # ==================== Environment ====================
+    
+    environment: str = Field(
+        default="development",
+        description="Environment (development, staging, production)",
+    )
+    
+    debug: bool = Field(
+        default=False,
+        description="Debug mode",
+    )
+    
+    @validator("debug", pre=True)
+    def set_debug_from_env(cls, v, values):
+        """Set debug based on environment if not explicitly set."""
+        if v is None:
+            env = values.get("environment", "development")
+            return env == "development"
+        return v
+    
+    # ==================== Database Settings ====================
+
+    database_url: Optional[str] = Field(
+        default=None,
+        description="PostgreSQL database URL",
+        validation_alias=AliasChoices("DATABASE_URL", "database_url"),
+    )
+
+    supabase_url: Optional[str] = Field(
+        default=None,
+        description="Supabase project URL",
+        validation_alias=AliasChoices("SUPABASE_URL", "supabase_url"),
+    )
+
+    supabase_service_key: Optional[str] = Field(
+        default=None,
+        description="Supabase service role key",
+        validation_alias=AliasChoices("SUPABASE_SERVICE_KEY", "supabase_service_key"),
+    )
+
+    supabase_anon_key: Optional[str] = Field(
+        default=None,
+        description="Supabase anonymous key",
+        validation_alias=AliasChoices("SUPABASE_ANON_KEY", "supabase_anon_key"),
+    )
+    
+    database_pool_size: int = Field(
+        default=20,
+        description="Database connection pool size",
+    )
+    
+    database_max_overflow: int = Field(
+        default=40,
+        description="Maximum overflow for database pool",
+    )
+    
+    database_pool_timeout: float = Field(
+        default=30.0,
+        description="Database pool timeout in seconds",
+    )
+    
+    @model_validator(mode='after')
+    def validate_database_config(self):
+        """Ensure we have either DATABASE_URL or Supabase configuration."""
+        # Always try to set database_url from Supabase env vars if not already set
+        if not self.database_url:
+            supabase_db_url = (
+                os.environ.get("SUPABASE_POSTGRES_URL") or
+                os.environ.get("SUPABASE_POSTGRES_PRISMA_URL") or
+                os.environ.get("SUPABASE_DB_URL")
+            )
+            if supabase_db_url:
+                # Fix URL format for SQLAlchemy 2.0+
+                if supabase_db_url.startswith("postgres://"):
+                    supabase_db_url = supabase_db_url.replace("postgres://", "postgresql://", 1)
+                # Remove invalid Supabase pooler parameters that SQLAlchemy doesn't understand
+                supabase_db_url = supabase_db_url.replace("&supa=base-pooler.x", "")
+                self.database_url = supabase_db_url
+            elif not (self.supabase_url and self.supabase_service_key) and self.environment != "development":
+                raise ValueError(
+                    "Either DATABASE_URL or Supabase configuration (SUPABASE_URL and SUPABASE_SERVICE_KEY) must be provided"
+                )
+
+        # Fix postgres:// to postgresql:// if needed and remove invalid params
+        if self.database_url:
+            if self.database_url.startswith("postgres://"):
+                self.database_url = self.database_url.replace("postgres://", "postgresql://", 1)
+            # Remove invalid Supabase pooler parameters from DATABASE_URL
+            self.database_url = self.database_url.replace("&supa=base-pooler.x", "")
+
+        return self
+    
+    # ==================== Redis Settings ====================
+
+    redis_url: str = Field(
+        default="redis://localhost:6379/0",
+        description="Redis connection URL",
+        validation_alias=AliasChoices("REDIS_URL", "redis_url"),
+    )
+    
+    redis_host: Optional[str] = Field(
+        default=None,
+        description="Redis host (overrides URL)",
+    )
+    
+    redis_port: int = Field(
+        default=6379,
+        description="Redis port",
+    )
+    
+    redis_password: Optional[str] = Field(
+        default=None,
+        description="Redis password",
+    )
+    
+    redis_db: int = Field(
+        default=0,
+        description="Redis database number",
+    )
+    
+    redis_pool_size: int = Field(
+        default=10,
+        description="Redis connection pool size",
+    )
+    
+    # ==================== Temporal Settings ====================
+    
+    temporal_host: str = Field(
+        default="localhost:7233",
+        description="Temporal server host:port",
+    )
+    
+    temporal_namespace: str = Field(
+        default="default",
+        description="Temporal namespace",
+    )
+    
+    temporal_client_cert_path: Optional[str] = Field(
+        default=None,
+        description="Path to Temporal client certificate",
+    )
+    
+    temporal_client_key_path: Optional[str] = Field(
+        default=None,
+        description="Path to Temporal client key",
+    )
+    
+    # ==================== Security Settings ====================
+
+    secret_key: str = Field(
+        default_factory=lambda: secrets.token_urlsafe(32),
+        description="Secret key for JWT signing",
+        validation_alias=AliasChoices("SECRET_KEY", "secret_key"),
+    )
+    
+    algorithm: str = Field(
+        default="HS256",
+        description="JWT signing algorithm",
+    )
+    
+    access_token_expire_minutes: int = Field(
+        default=30,
+        description="Access token expiration in minutes",
+    )
+    
+    refresh_token_expire_days: int = Field(
+        default=30,
+        description="Refresh token expiration in days",
+    )
+    
+    # ==================== CORS Settings ====================
+    
+    cors_origins: List[str] = Field(
+        default=["*"],
+        description="Allowed CORS origins",
+    )
+    
+    cors_allow_credentials: bool = Field(
+        default=True,
+        description="Allow credentials in CORS requests",
+    )
+    
+    cors_allow_methods: List[str] = Field(
+        default=["*"],
+        description="Allowed CORS methods",
+    )
+    
+    cors_allow_headers: List[str] = Field(
+        default=["*"],
+        description="Allowed CORS headers",
+    )
+    
+    @validator("cors_origins", pre=True)
+    def validate_cors_origins(cls, v, values):
+        """Validate CORS origins for production."""
+        # Allow environment variable to override default
+        if v is None or (isinstance(v, list) and len(v) == 1 and v[0] == "*"):
+            # Check if we're in production
+            env = values.get("environment", "development")
+            if env == "production":
+                # In production, use specific origins unless explicitly overridden
+                return [
+                    "https://agent-control-plane.vercel.app",
+                    "https://*.vercel.app",
+                    "http://localhost:3000",
+                    "http://localhost:8000",
+                ]
+        return v
+    
+    # ==================== External Services ====================
+    
+    kubiya_api_base: str = Field(
+        default="https://api.kubiya.ai",
+        description="Kubiya API base URL",
+    )
+    
+    kubiya_api_key: Optional[str] = Field(
+        default=None,
+        description="Kubiya API key",
+        validation_alias=AliasChoices("KUBIYA_API_KEY", "kubiya_api_key"),
+    )
+
+    litellm_api_base: str = Field(
+        default="https://llm-proxy.kubiya.ai",
+        description="LiteLLM proxy base URL",
+    )
+
+    litellm_api_key: Optional[str] = Field(
+        default=None,
+        description="LiteLLM API key",
+        validation_alias=AliasChoices("LITELLM_API_KEY", "litellm_api_key"),
+    )
+    
+    litellm_default_model: str = Field(
+        default="kubiya/claude-sonnet-4",
+        description="Default LLM model",
+    )
+    
+    litellm_timeout: int = Field(
+        default=300,
+        description="LiteLLM request timeout in seconds",
+    )
+
+    litellm_models_cache_ttl: int = Field(
+        default=300,
+        description="Cache TTL for LiteLLM models list in seconds (default 5 minutes)",
+    )
+
+    # ==================== Context Graph Settings ====================
+
+    context_graph_api_base: str = Field(
+        default="https://graph.kubiya.ai",
+        description="Context Graph API base URL",
+        validation_alias=AliasChoices("CONTEXT_GRAPH_API_BASE", "context_graph_api_base"),
+    )
+
+    context_graph_api_timeout: int = Field(
+        default=120,  # Increased for semantic search operations
+        description="Context Graph API request timeout in seconds",
+        validation_alias=AliasChoices("CONTEXT_GRAPH_API_TIMEOUT", "context_graph_api_timeout"),
+    )
+
+    # ==================== Logging Settings ====================
+    
+    log_level: str = Field(
+        default="INFO",
+        description="Logging level",
+    )
+    
+    log_format: str = Field(
+        default="json",
+        description="Log format (json or text)",
+    )
+    
+    # ==================== Monitoring Settings ====================
+    
+    metrics_enabled: bool = Field(
+        default=True,
+        description="Enable Prometheus metrics",
+    )
+    
+    tracing_enabled: bool = Field(
+        default=False,
+        description="Enable OpenTelemetry tracing",
+    )
+    
+    otlp_endpoint: Optional[str] = Field(
+        default=None,
+        description="OpenTelemetry collector endpoint",
+    )
+    
+    sentry_dsn: Optional[str] = Field(
+        default=None,
+        description="Sentry DSN for error reporting",
+        validation_alias=AliasChoices("SENTRY_DSN", "sentry_dsn"),
+    )
+    
+    # ==================== Rate Limiting ====================
+    
+    rate_limit_enabled: bool = Field(
+        default=True,
+        description="Enable rate limiting",
+    )
+    
+    rate_limit_requests_per_minute: int = Field(
+        default=60,
+        description="Default requests per minute limit",
+    )
+    
+    rate_limit_burst_size: int = Field(
+        default=10,
+        description="Burst size for rate limiting",
+    )
+
+    # ==================== Event Bus Settings ====================
+
+    event_bus: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Event bus configuration for multi-provider event publishing",
+    )
+
+    # ==================== OpenTelemetry (OTEL) Settings ====================
+
+    OTEL_ENABLED: bool = Field(
+        default=True,
+        description="Enable OpenTelemetry distributed tracing",
+    )
+
+    OTEL_EXPORTER_OTLP_ENDPOINT: Optional[str] = Field(
+        default=None,
+        description="OTLP exporter endpoint (e.g., http://localhost:4317 for gRPC)",
+    )
+
+    OTEL_EXPORTER_OTLP_PROTOCOL: str = Field(
+        default="grpc",
+        description="OTLP exporter protocol: 'grpc' or 'http'",
+    )
+
+    OTEL_SERVICE_NAME: str = Field(
+        default="agent-control-plane",
+        description="Service name for telemetry",
+    )
+
+    OTEL_RESOURCE_ATTRIBUTES: str = Field(
+        default="",
+        description="Additional resource attributes (format: key1=value1,key2=value2)",
+    )
+
+    OTEL_TRACES_SAMPLER: str = Field(
+        default="parentbased_always_on",
+        description="Trace sampler: parentbased_always_on, parentbased_traceidratio, etc.",
+    )
+
+    OTEL_TRACES_SAMPLER_ARG: Optional[float] = Field(
+        default=None,
+        description="Sampler argument (e.g., 0.1 for 10% sampling with traceidratio)",
+    )
+
+    # Local Trace Storage Settings (for observability UI)
+    OTEL_LOCAL_STORAGE_ENABLED: bool = Field(
+        default=True,
+        description="Store traces locally in PostgreSQL for observability UI",
+    )
+
+    OTEL_LOCAL_STORAGE_BATCH_SIZE: int = Field(
+        default=100,
+        description="Number of spans to batch before inserting to database",
+    )
+
+    OTEL_LOCAL_STORAGE_FLUSH_INTERVAL: int = Field(
+        default=1000,
+        description="Max time (ms) before flushing batch",
+    )
+
+    OTEL_LOCAL_STORAGE_RETENTION_DAYS: int = Field(
+        default=30,
+        description="Days to retain traces",
+    )
+
+    model_config = SettingsConfigDict(
+        env_file=".env.local",
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    @classmethod
+    def from_yaml_and_env(cls, config_path: Optional[str] = None) -> "APIConfig":
+        """
+        Load configuration from YAML file and merge with environment variables.
+
+        Priority: Environment variables > YAML file > Defaults
+
+        Args:
+            config_path: Optional path to YAML config file
+
+        Returns:
+            APIConfig instance with merged configuration
+
+        Example YAML:
+            event_bus:
+              http:
+                enabled: true
+                base_url: ${CONTROL_PLANE_URL}
+              websocket:
+                enabled: true
+              redis:
+                enabled: true
+                redis_url: ${REDIS_URL}
+              nats:
+                enabled: false
+        """
+        from control_plane_api.app.config.config_loader import load_config_file
+
+        # Load YAML config (empty dict if no file found)
+        yaml_config = load_config_file(config_path)
+
+        # Pydantic will merge YAML config with environment variables
+        # Environment variables take precedence
+        return cls(**yaml_config)

control_plane_api/app/config/config_loader.py

@@ -0,0 +1,224 @@
+"""YAML configuration file loader with environment variable substitution."""
+
+import os
+import re
+from pathlib import Path
+from typing import Optional, Dict, Any
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+
+class ConfigFileLoader:
+    """Load and merge YAML configuration with environment variables."""
+
+    # Pattern to match ${VAR_NAME} or ${VAR_NAME:default}
+    ENV_VAR_PATTERN = re.compile(r"\$\{([^}:]+)(?::([^}]*))?\}")
+
+    @staticmethod
+    def _substitute_env_vars(value: Any) -> Any:
+        """
+        Recursively substitute environment variables in configuration values.
+
+        Supports:
+        - ${VAR_NAME} - Required variable, fails if not set
+        - ${VAR_NAME:default} - Optional variable with default value
+
+        Args:
+            value: Configuration value (str, dict, list, or other)
+
+        Returns:
+            Value with environment variables substituted
+        """
+        if isinstance(value, str):
+            # Substitute all ${VAR} occurrences in string
+            def replacer(match):
+                var_name = match.group(1)
+                default_value = match.group(2)  # May be None
+
+                env_value = os.getenv(var_name)
+
+                if env_value is not None:
+                    return env_value
+                elif default_value is not None:
+                    return default_value
+                else:
+                    # Required variable not set
+                    raise ValueError(
+                        f"Required environment variable not set: {var_name}"
+                    )
+
+            return ConfigFileLoader.ENV_VAR_PATTERN.sub(replacer, value)
+
+        elif isinstance(value, dict):
+            # Recursively process dictionary
+            return {
+                k: ConfigFileLoader._substitute_env_vars(v)
+                for k, v in value.items()
+            }
+
+        elif isinstance(value, list):
+            # Recursively process list
+            return [ConfigFileLoader._substitute_env_vars(item) for item in value]
+
+        else:
+            # Return other types as-is (int, bool, None, etc.)
+            return value
+
+    @staticmethod
+    def _find_config_file(config_path: Optional[str] = None) -> Optional[Path]:
+        """
+        Find configuration file.
+
+        Search order:
+        1. Explicit config_path parameter
+        2. KUBIYA_CONFIG_FILE environment variable
+        3. ./config.yaml (current directory)
+        4. /etc/kubiya/config.yaml (system-wide)
+
+        Args:
+            config_path: Optional explicit path to config file
+
+        Returns:
+            Path to config file or None if not found
+        """
+        # 1. Explicit path
+        if config_path:
+            path = Path(config_path)
+            if path.exists():
+                return path
+            else:
+                logger.warning(
+                    "config_file_not_found",
+                    path=str(path),
+                    message="Explicit config path does not exist"
+                )
+                return None
+
+        # 2. Environment variable
+        env_path = os.getenv("KUBIYA_CONFIG_FILE")
+        if env_path:
+            path = Path(env_path)
+            if path.exists():
+                return path
+            else:
+                logger.warning(
+                    "config_file_not_found",
+                    path=str(path),
+                    env_var="KUBIYA_CONFIG_FILE",
+                    message="Config file from env var does not exist"
+                )
+                return None
+
+        # 3. Current directory
+        cwd_config = Path("config.yaml")
+        if cwd_config.exists():
+            return cwd_config
+
+        # 4. System-wide config
+        system_config = Path("/etc/kubiya/config.yaml")
+        if system_config.exists():
+            return system_config
+
+        # No config file found
+        return None
+
+    @staticmethod
+    def load_config(config_path: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Load configuration from YAML file with environment variable substitution.
+
+        Priority: Environment variables > YAML file > Defaults
+
+        Args:
+            config_path: Optional path to YAML config file
+
+        Returns:
+            Dict with configuration (empty dict if no config file found)
+
+        Raises:
+            ValueError: If required environment variable not set
+            yaml.YAMLError: If YAML syntax error
+        """
+        # Find config file
+        config_file = ConfigFileLoader._find_config_file(config_path)
+
+        if not config_file:
+            logger.info(
+                "no_config_file_found",
+                message="No config file found, using environment variables only",
+                checked_paths=[
+                    "config_path parameter",
+                    "KUBIYA_CONFIG_FILE env var",
+                    "./config.yaml",
+                    "/etc/kubiya/config.yaml"
+                ]
+            )
+            return {}
+
+        try:
+            # Import YAML parser
+            try:
+                import yaml
+            except ImportError:
+                raise ImportError(
+                    "PyYAML is required for YAML config files. "
+                    "Install it with: pip install PyYAML"
+                )
+
+            # Read and parse YAML
+            with open(config_file, "r", encoding="utf-8") as f:
+                raw_config = yaml.safe_load(f) or {}
+
+            # Substitute environment variables
+            config = ConfigFileLoader._substitute_env_vars(raw_config)
+
+            logger.info(
+                "config_file_loaded",
+                path=str(config_file),
+                keys=list(config.keys()) if isinstance(config, dict) else [],
+            )
+
+            return config
+
+        except ImportError as e:
+            logger.error(
+                "config_loader_dependency_missing",
+                error=str(e),
+                path=str(config_file)
+            )
+            raise
+
+        except ValueError as e:
+            # Required env var not set
+            logger.error(
+                "config_env_var_required",
+                error=str(e),
+                path=str(config_file)
+            )
+            raise
+
+        except Exception as e:
+            logger.error(
+                "config_file_load_error",
+                error=str(e),
+                path=str(config_file),
+                error_type=type(e).__name__
+            )
+            raise
+
+
+# Convenience function
+def load_config_file(config_path: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Load configuration from YAML file.
+
+    Convenience wrapper around ConfigFileLoader.load_config().
+
+    Args:
+        config_path: Optional path to YAML config file
+
+    Returns:
+        Dict with configuration (empty dict if no config file found)
+    """
+    return ConfigFileLoader.load_config(config_path)