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

control_plane_api/worker/runtimes/factory.py

@@ -0,0 +1,173 @@
+"""
+Runtime factory using the registry system.
+
+This module provides a simplified factory that delegates to RuntimeRegistry.
+"""
+
+from typing import TYPE_CHECKING, List
+import structlog
+
+from .base import RuntimeType, BaseRuntime, RuntimeRegistry
+
+if TYPE_CHECKING:
+    from control_plane_client import ControlPlaneClient
+    from services.cancellation_manager import CancellationManager
+
+logger = structlog.get_logger(__name__)
+
+
+class RuntimeFactory:
+    """
+    Factory for creating runtime instances.
+
+    This is a thin wrapper around RuntimeRegistry that provides
+    backward compatibility and convenience methods.
+    """
+
+    @staticmethod
+    def create_runtime(
+        runtime_type: RuntimeType,
+        control_plane_client: "ControlPlaneClient",
+        cancellation_manager: "CancellationManager",
+        **kwargs,
+    ) -> BaseRuntime:
+        """
+        Create a runtime instance using the registry.
+
+        Args:
+            runtime_type: Type of runtime to create
+            control_plane_client: Client for Control Plane API
+            cancellation_manager: Manager for execution cancellation
+            **kwargs: Additional runtime-specific configuration
+
+        Returns:
+            BaseRuntime instance
+
+        Raises:
+            ValueError: If runtime_type is not supported
+
+        Example:
+            >>> factory = RuntimeFactory()
+            >>> runtime = factory.create_runtime(
+            ...     RuntimeType.CLAUDE_CODE,
+            ...     control_plane_client,
+            ...     cancellation_manager
+            ... )
+        """
+        logger.info(
+            "creating_runtime",
+            runtime_type=runtime_type.value,
+            has_kwargs=bool(kwargs),
+        )
+
+        return RuntimeRegistry.create(
+            runtime_type=runtime_type,
+            control_plane_client=control_plane_client,
+            cancellation_manager=cancellation_manager,
+            **kwargs,
+        )
+
+    @staticmethod
+    def get_default_runtime_type() -> RuntimeType:
+        """
+        Get the default runtime type.
+
+        This is used when no runtime is explicitly specified in agent config.
+
+        Returns:
+            Default RuntimeType (RuntimeType.DEFAULT)
+        """
+        return RuntimeType.DEFAULT
+
+    @staticmethod
+    def get_supported_runtimes() -> List[RuntimeType]:
+        """
+        Get list of supported runtimes from registry.
+
+        Returns:
+            List of RuntimeType enum values
+        """
+        return RuntimeRegistry.list_available()
+
+    @staticmethod
+    def parse_runtime_type(runtime_str: str) -> RuntimeType:
+        """
+        Parse runtime type from string with fallback to default.
+
+        Args:
+            runtime_str: Runtime type as string
+
+        Returns:
+            RuntimeType enum value, defaults to DEFAULT if invalid
+
+        Example:
+            >>> RuntimeFactory.parse_runtime_type("claude_code")
+            RuntimeType.CLAUDE_CODE
+            >>> RuntimeFactory.parse_runtime_type("invalid")
+            RuntimeType.DEFAULT
+        """
+        try:
+            return RuntimeType(runtime_str)
+        except ValueError:
+            logger.warning(
+                "invalid_runtime_type_fallback",
+                runtime_str=runtime_str,
+                default=RuntimeType.DEFAULT.value,
+            )
+            return RuntimeType.DEFAULT
+
+    @staticmethod
+    def get_runtime_info_all() -> dict:
+        """
+        Get information about all available runtimes.
+
+        Returns:
+            Dict mapping runtime type to info dict
+        """
+        return RuntimeRegistry.get_runtime_info_all()
+
+    @staticmethod
+    def validate_runtime_config(
+        runtime_type: RuntimeType, config: dict
+    ) -> tuple[bool, str]:
+        """
+        Validate runtime-specific configuration.
+
+        Args:
+            runtime_type: Type of runtime
+            config: Configuration dict to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+
+        Example:
+            >>> is_valid, error = RuntimeFactory.validate_runtime_config(
+            ...     RuntimeType.CLAUDE_CODE,
+            ...     {"allowed_tools": ["Bash"]}
+            ... )
+        """
+        # Get runtime class from registry
+        try:
+            runtime_class = RuntimeRegistry.get(runtime_type)
+
+            # Create temporary instance to validate (with mocks)
+            from unittest.mock import MagicMock
+            temp_runtime = runtime_class(
+                control_plane_client=MagicMock(),
+                cancellation_manager=MagicMock(),
+            )
+
+            # Use runtime's validation if available
+            if hasattr(temp_runtime, 'validate_config'):
+                try:
+                    temp_runtime.validate_config(config)
+                    return True, ""
+                except ValueError as e:
+                    return False, str(e)
+
+            return True, ""
+
+        except ValueError as e:
+            return False, f"Unknown runtime type: {str(e)}"
+        except Exception as e:
+            return False, f"Validation error: {str(e)}"

control_plane_api/worker/runtimes/model_utils.py

@@ -0,0 +1,107 @@
+"""
+Model selection utilities for runtime execution.
+
+This module provides centralized model selection logic that respects:
+1. KUBIYA_MODEL_OVERRIDE (highest priority - from CLI --model flag)
+2. RuntimeExecutionContext.model_id (from agent/execution configuration)
+3. LITELLM_DEFAULT_MODEL (default fallback)
+
+Usage:
+    from control_plane_api.worker.runtimes.model_utils import get_effective_model
+
+    model = get_effective_model(context.model_id)
+"""
+
+import os
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+# Default model to use if no other configuration is provided
+DEFAULT_MODEL = "kubiya/claude-sonnet-4"
+
+
+def get_effective_model(
+    context_model_id: str = None,
+    log_context: dict = None,
+) -> str:
+    """
+    Get the effective model ID to use for execution.
+
+    Priority order (highest to lowest):
+    1. KUBIYA_MODEL_OVERRIDE environment variable (from CLI --model flag)
+    2. context_model_id (from RuntimeExecutionContext.model_id or agent config)
+    3. LITELLM_DEFAULT_MODEL environment variable
+    4. DEFAULT_MODEL constant ("kubiya/claude-sonnet-4")
+
+    Args:
+        context_model_id: Model ID from execution context (optional)
+        log_context: Additional context for logging (execution_id, etc.)
+
+    Returns:
+        The effective model ID to use
+    """
+    log_ctx = log_context or {}
+
+    # Priority 1: Environment override (from CLI --model flag)
+    model_override = os.environ.get("KUBIYA_MODEL_OVERRIDE")
+    if model_override:
+        logger.info(
+            "model_override_active",
+            effective_model=model_override,
+            source="KUBIYA_MODEL_OVERRIDE",
+            overridden_context_model=context_model_id,
+            note="Explicit model override from CLI --model flag or KUBIYA_MODEL env var",
+            **log_ctx,
+        )
+        return model_override
+
+    # Priority 2: Context model_id (from agent/execution configuration)
+    if context_model_id:
+        logger.debug(
+            "using_context_model",
+            effective_model=context_model_id,
+            source="context.model_id",
+            **log_ctx,
+        )
+        return context_model_id
+
+    # Priority 3: Environment default
+    env_default = os.environ.get("LITELLM_DEFAULT_MODEL")
+    if env_default:
+        logger.debug(
+            "using_env_default_model",
+            effective_model=env_default,
+            source="LITELLM_DEFAULT_MODEL",
+            **log_ctx,
+        )
+        return env_default
+
+    # Priority 4: Hardcoded default
+    logger.debug(
+        "using_hardcoded_default_model",
+        effective_model=DEFAULT_MODEL,
+        source="DEFAULT_MODEL",
+        **log_ctx,
+    )
+    return DEFAULT_MODEL
+
+
+def is_model_override_active() -> bool:
+    """
+    Check if an explicit model override is active.
+
+    Returns:
+        True if KUBIYA_MODEL_OVERRIDE is set
+    """
+    return bool(os.environ.get("KUBIYA_MODEL_OVERRIDE"))
+
+
+def get_model_override() -> str:
+    """
+    Get the model override value if set.
+
+    Returns:
+        The override model ID or None if not set
+    """
+    return os.environ.get("KUBIYA_MODEL_OVERRIDE")

control_plane_api/worker/runtimes/validation.py

@@ -0,0 +1,93 @@
+"""
+Runtime validation system with model compatibility and requirements checking.
+
+This module re-exports validation functions from the shared validation module
+and provides worker-specific validation helpers for RuntimeExecutionContext.
+"""
+
+from typing import List, Optional, Dict, Any
+from control_plane_api.worker.runtimes.base import RuntimeType, RuntimeExecutionContext
+
+# Import shared validation logic that both API and worker can use
+from control_plane_api.app.lib.validation import (
+    validate_agent_for_runtime as _validate_agent_for_runtime,
+    get_runtime_requirements_info as _get_runtime_requirements_info,
+    list_all_runtime_requirements as _list_all_runtime_requirements,
+    RUNTIME_REQUIREMENTS as _RUNTIME_REQUIREMENTS,
+)
+
+
+# Re-export for backward compatibility
+validate_agent_for_runtime = _validate_agent_for_runtime
+get_runtime_requirements_info = _get_runtime_requirements_info
+list_all_runtime_requirements = _list_all_runtime_requirements
+
+
+class ValidationError(Exception):
+    """Raised when validation fails."""
+
+    def __init__(self, message: str, field: Optional[str] = None, details: Optional[Dict[str, Any]] = None):
+        self.message = message
+        self.field = field
+        self.details = details or {}
+        super().__init__(message)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dict for API responses."""
+        result = {"error": self.message}
+        if self.field:
+            result["field"] = self.field
+        if self.details:
+            result["details"] = self.details
+        return result
+
+
+def validate_execution_context(context: RuntimeExecutionContext) -> tuple[bool, List[str]]:
+    """
+    Validate RuntimeExecutionContext for worker execution.
+
+    This is a worker-specific helper that validates the full execution context
+    including conversation history, skills, and runtime-specific requirements.
+
+    Args:
+        context: Runtime execution context
+
+    Returns:
+        Tuple of (is_valid, error_messages)
+    """
+    errors = []
+
+    # Get runtime requirements from shared module
+    runtime_type_str = context.runtime_type.value if isinstance(context.runtime_type, RuntimeType) else str(context.runtime_type)
+    requirements = _RUNTIME_REQUIREMENTS.get(runtime_type_str)
+
+    if not requirements:
+        # No requirements registered - allow by default
+        return True, []
+
+    # Validate model
+    is_valid, error = requirements.validate_model(context.model_id)
+    if not is_valid:
+        errors.append(error)
+
+    # Validate config
+    config_errors = requirements.validate_config(context.agent_config)
+    errors.extend(config_errors)
+
+    # Validate system prompt if required
+    if requirements.requires_system_prompt and not context.system_prompt:
+        errors.append("System prompt is required for this runtime")
+
+    # Validate tools if required
+    if requirements.requires_tools and not context.skills:
+        errors.append("At least one skill is required for this runtime")
+
+    # Validate history length
+    if requirements.max_history_length and context.conversation_history:
+        if len(context.conversation_history) > requirements.max_history_length:
+            errors.append(
+                f"Conversation history too long ({len(context.conversation_history)} messages). "
+                f"Maximum: {requirements.max_history_length}"
+            )
+
+    return len(errors) == 0, errors

control_plane_api/worker/services/__init__.py

@@ -0,0 +1 @@
+"""Business logic services for worker operations"""