kubiya-control-plane-api 0.1.0__py3-none-any.whl → 0.3.4__py3-none-any.whl

control_plane_api/app/lib/validation/runtime_validation.py

@@ -0,0 +1,287 @@
+"""
+Runtime validation logic shared between API and worker.
+
+This module provides validation without depending on worker-specific types,
+making it safe to import from both the API layer and worker layer.
+"""
+
+from typing import List, Optional, Dict, Any, Set
+from dataclasses import dataclass
+import re
+
+
+@dataclass
+class ModelRequirement:
+    """Model requirement specification for a runtime."""
+
+    # Patterns that model IDs must match (any match is valid)
+    model_id_patterns: List[str]
+
+    # Model providers that are supported (e.g., "anthropic", "openai")
+    supported_providers: Set[str]
+
+    # Specific model families supported (e.g., "claude", "gpt")
+    supported_families: Set[str]
+
+    # Human-readable description
+    description: str = ""
+
+    # Examples of valid model IDs
+    examples: List[str] = None
+
+    def __post_init__(self):
+        if self.examples is None:
+            self.examples = []
+
+    def validate(self, model_id: Optional[str]) -> tuple[bool, Optional[str]]:
+        """
+        Validate a model ID against this requirement.
+
+        Args:
+            model_id: Model ID to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        if not model_id:
+            return False, "Model ID is required for this runtime"
+
+        # Check pattern matching
+        for pattern in self.model_id_patterns:
+            if re.search(pattern, model_id, re.IGNORECASE):
+                return True, None
+
+        # Check provider/family
+        model_lower = model_id.lower()
+
+        # Check if any supported family is in the model ID
+        for family in self.supported_families:
+            if family.lower() in model_lower:
+                return True, None
+
+        # Provide helpful error message
+        examples_str = ", ".join(self.examples) if self.examples else "N/A"
+        return False, (
+            f"Model '{model_id}' is not compatible with this runtime. "
+            f"Expected models matching: {', '.join(self.model_id_patterns)}. "
+            f"Supported families: {', '.join(self.supported_families)}. "
+            f"Examples: {examples_str}"
+        )
+
+
+@dataclass
+class RuntimeRequirements:
+    """Requirements specification for a runtime."""
+
+    runtime_type: str
+
+    # Model requirements
+    model_requirement: ModelRequirement
+
+    # Required fields in agent/team config
+    required_config_fields: List[str] = None
+
+    # Optional but recommended fields
+    recommended_config_fields: List[str] = None
+
+    # Maximum conversation history length
+    max_history_length: Optional[int] = None
+
+    # Whether system prompt is required
+    requires_system_prompt: bool = False
+
+    # Whether tools/skills are required
+    requires_tools: bool = False
+
+    def __post_init__(self):
+        if self.required_config_fields is None:
+            self.required_config_fields = []
+        if self.recommended_config_fields is None:
+            self.recommended_config_fields = []
+
+    def validate_model(self, model_id: Optional[str]) -> tuple[bool, Optional[str]]:
+        """Validate model compatibility."""
+        return self.model_requirement.validate(model_id)
+
+    def validate_config(self, config: Optional[Dict[str, Any]]) -> List[str]:
+        """
+        Validate agent/team configuration.
+
+        Returns:
+            List of validation errors (empty if valid)
+        """
+        errors = []
+
+        if not config:
+            if self.required_config_fields:
+                errors.append(
+                    f"Configuration is required for this runtime. "
+                    f"Required fields: {', '.join(self.required_config_fields)}"
+                )
+            return errors
+
+        # Check required fields
+        for field in self.required_config_fields:
+            if field not in config or config[field] is None:
+                errors.append(f"Required field '{field}' is missing in configuration")
+
+        return errors
+
+
+# ==================== Runtime Requirements Definitions ====================
+
+# Agno/Default Runtime - Flexible, supports most models
+DEFAULT_RUNTIME_REQUIREMENTS = RuntimeRequirements(
+    runtime_type="default",
+    model_requirement=ModelRequirement(
+        model_id_patterns=[
+            r".*",  # Accept all models
+        ],
+        supported_providers={"openai", "anthropic", "azure", "google", "mistral", "cohere"},
+        supported_families={"gpt", "claude", "gemini", "mistral", "command"},
+        description="Default runtime supports most LiteLLM-compatible models",
+        examples=[
+            "gpt-4",
+            "gpt-4-turbo",
+            "gpt-3.5-turbo",
+            "claude-3-opus",
+            "claude-3-sonnet",
+            "claude-sonnet-4",
+            "gemini-pro",
+            "mistral-large",
+        ],
+    ),
+    max_history_length=100,  # Reasonable default
+    requires_system_prompt=False,
+    requires_tools=False,
+)
+
+# Claude Code Runtime - Requires Claude models
+CLAUDE_CODE_RUNTIME_REQUIREMENTS = RuntimeRequirements(
+    runtime_type="claude_code",
+    model_requirement=ModelRequirement(
+        model_id_patterns=[
+            r"claude",  # Must contain "claude"
+            r"kubiya/claude",  # LiteLLM proxy format
+            r"anthropic\.claude",  # Alternative format
+        ],
+        supported_providers={"anthropic"},
+        supported_families={"claude"},
+        description=(
+            "Claude Code runtime requires Anthropic Claude models. "
+            "This runtime leverages Claude's advanced capabilities including "
+            "extended context, tool use, and code understanding."
+        ),
+        examples=[
+            "claude-3-opus-20240229",
+            "claude-3-sonnet-20240229",
+            "claude-3-5-sonnet-20241022",
+            "claude-3-haiku-20240307",
+            "claude-sonnet-4",
+            "claude-opus-4",
+            "kubiya/claude-sonnet-4",
+            "kubiya/claude-opus-4",
+        ],
+    ),
+    max_history_length=200,  # Claude handles longer contexts well
+    requires_system_prompt=False,  # Optional but recommended
+    requires_tools=False,  # Claude Code adds tools automatically
+    recommended_config_fields=["timeout", "max_tokens"],
+)
+
+
+# Registry of runtime requirements
+RUNTIME_REQUIREMENTS: Dict[str, RuntimeRequirements] = {
+    "default": DEFAULT_RUNTIME_REQUIREMENTS,
+    "claude_code": CLAUDE_CODE_RUNTIME_REQUIREMENTS,
+}
+
+
+# ==================== Validation Functions ====================
+
+def validate_agent_for_runtime(
+    runtime_type: str,
+    model_id: Optional[str],
+    agent_config: Optional[Dict[str, Any]] = None,
+    system_prompt: Optional[str] = None,
+) -> tuple[bool, List[str]]:
+    """
+    Validate agent configuration for a runtime.
+
+    Args:
+        runtime_type: Runtime type string (e.g., "default", "claude_code")
+        model_id: Model ID to validate
+        agent_config: Agent configuration dict
+        system_prompt: System prompt
+
+    Returns:
+        Tuple of (is_valid, error_messages)
+    """
+    requirements = RUNTIME_REQUIREMENTS.get(runtime_type)
+    if not requirements:
+        # No requirements registered - allow by default
+        return True, []
+
+    errors = []
+
+    # Validate model
+    is_valid, error = requirements.validate_model(model_id)
+    if not is_valid:
+        errors.append(error)
+
+    # Validate config
+    config_errors = requirements.validate_config(agent_config)
+    errors.extend(config_errors)
+
+    # Validate system prompt if required
+    if requirements.requires_system_prompt and not system_prompt:
+        errors.append("System prompt is required for this runtime")
+
+    return len(errors) == 0, errors
+
+
+def get_runtime_requirements_info(runtime_type: str) -> Dict[str, Any]:
+    """
+    Get human-readable requirements info for a runtime.
+
+    Args:
+        runtime_type: Runtime type string
+
+    Returns:
+        Dict with requirements information
+    """
+    requirements = RUNTIME_REQUIREMENTS.get(runtime_type)
+    if not requirements:
+        return {
+            "runtime_type": runtime_type,
+            "model_requirement": "No specific requirements",
+            "flexible": True,
+        }
+
+    return {
+        "runtime_type": runtime_type,
+        "model_requirement": {
+            "description": requirements.model_requirement.description,
+            "supported_providers": list(requirements.model_requirement.supported_providers),
+            "supported_families": list(requirements.model_requirement.supported_families),
+            "examples": requirements.model_requirement.examples,
+        },
+        "required_config_fields": requirements.required_config_fields,
+        "recommended_config_fields": requirements.recommended_config_fields,
+        "max_history_length": requirements.max_history_length,
+        "requires_system_prompt": requirements.requires_system_prompt,
+        "requires_tools": requirements.requires_tools,
+    }
+
+
+def list_all_runtime_requirements() -> Dict[str, Dict[str, Any]]:
+    """
+    Get requirements for all registered runtimes.
+
+    Returns:
+        Dict mapping runtime type to requirements info
+    """
+    return {
+        runtime_type: get_runtime_requirements_info(runtime_type)
+        for runtime_type in RUNTIME_REQUIREMENTS.keys()
+    }

control_plane_api/app/main.py

@@ -0,0 +1,128 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+import structlog
+
+from control_plane_api.app.config import settings
+from control_plane_api.app.routers import agents, teams, workflows, health, executions, presence, runners, workers, projects, models, models_v2, task_queues, worker_queues, environment_context, team_context, context_manager, skills, skills_definitions, environments, runtimes, secrets, integrations, execution_environment, policies, task_planning, jobs, analytics
+from control_plane_api.app.routers import agents_v2  # New multi-tenant agent router
+
+# Configure structured logging
+import logging
+
+structlog.configure(
+    processors=[
+        structlog.contextvars.merge_contextvars,
+        structlog.processors.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.JSONRenderer(),
+    ],
+    wrapper_class=structlog.make_filtering_bound_logger(
+        getattr(logging, settings.log_level.upper(), logging.INFO)
+    ),
+    logger_factory=structlog.PrintLoggerFactory(),
+)
+
+logger = structlog.get_logger()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager for serverless"""
+    logger.info(
+        "agent_control_plane_starting",
+        version=settings.api_version,
+        environment=settings.environment
+    )
+    # No database initialization needed for serverless
+    # Supabase client is initialized on-demand
+    yield
+    logger.info("agent_control_plane_shutting_down")
+
+
+# Create FastAPI application
+app = FastAPI(
+    title=settings.api_title,
+    version=settings.api_version,
+    description=settings.api_description,
+    lifespan=lifespan,
+    # Disable lifespan for Vercel (will be "off" via Mangum)
+    openapi_url="/api/openapi.json" if settings.environment != "production" else None,
+    docs_url="/api/docs" if settings.environment != "production" else None,
+    redoc_url="/api/redoc" if settings.environment != "production" else None,
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.cors_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers (all routes under /api/v1)
+app.include_router(health.router, prefix="/api", tags=["Health"])
+app.include_router(models_v2.router, prefix="/api/v1/models", tags=["Models"])  # LLM models CRUD (database-backed)
+app.include_router(runtimes.router, prefix="/api/v1", tags=["Runtimes"])  # Agent runtime types
+app.include_router(secrets.router, prefix="/api/v1", tags=["Secrets"])  # Kubiya secrets proxy
+app.include_router(integrations.router, prefix="/api/v1", tags=["Integrations"])  # Kubiya integrations proxy
+app.include_router(execution_environment.router, prefix="/api/v1", tags=["Execution Environment"])  # Resolved execution environment for workers
+app.include_router(projects.router, prefix="/api/v1/projects", tags=["Projects"])  # Multi-project management
+app.include_router(environments.router, prefix="/api/v1/environments", tags=["Environments"])  # Environment management
+app.include_router(task_queues.router, prefix="/api/v1/task-queues", tags=["Task Queues"])  # Legacy endpoint (use /environments)
+app.include_router(worker_queues.router, prefix="/api/v1", tags=["Worker Queues"])  # Worker queue management per environment
+app.include_router(environment_context.router, prefix="/api/v1", tags=["Environment Context"])  # Environment context management
+app.include_router(team_context.router, prefix="/api/v1", tags=["Team Context"])  # Team context management
+app.include_router(context_manager.router, prefix="/api/v1", tags=["Context Manager"])  # Unified context management
+app.include_router(skills_definitions.router, prefix="/api/v1/skills", tags=["Tool Sets"])  # Skill definitions and templates (must be before skills.router)
+app.include_router(skills.router, prefix="/api/v1/skills", tags=["Tool Sets"])  # Tool sets management
+app.include_router(policies.router, prefix="/api/v1/policies", tags=["Policies"])  # Policy management and enforcement
+app.include_router(task_planning.router, prefix="/api/v1", tags=["Task Planning"])  # AI-powered task planning
+app.include_router(agents_v2.router, prefix="/api/v1/agents", tags=["Agents"])  # Use new multi-tenant router
+app.include_router(runners.router, prefix="/api/v1/runners", tags=["Runners"])  # Proxy to Kubiya API
+app.include_router(workers.router, prefix="/api/v1/workers", tags=["Workers"])  # Worker registration and heartbeats
+app.include_router(teams.router, prefix="/api/v1/teams", tags=["Teams"])
+app.include_router(workflows.router, prefix="/api/v1/workflows", tags=["Workflows"])
+app.include_router(executions.router, prefix="/api/v1/executions", tags=["Executions"])
+app.include_router(presence.router, prefix="/api/v1/presence", tags=["Presence"])
+app.include_router(jobs.router, prefix="/api/v1/jobs", tags=["Jobs"])  # Scheduled and webhook-triggered jobs
+app.include_router(analytics.router, prefix="/api/v1/analytics", tags=["Analytics"])  # Execution metrics and reporting
+
+
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "message": "Welcome to Agent Control Plane",
+        "version": settings.api_version,
+        "environment": settings.environment,
+        "docs": "/api/docs" if settings.environment != "production" else None,
+    }
+
+
+@app.get("/api")
+async def api_root():
+    """API root endpoint"""
+    return {
+        "message": "Agent Control Plane API",
+        "version": settings.api_version,
+        "endpoints": {
+            "projects": "/api/v1/projects",
+            "task_queues": "/api/v1/task-queues",
+            "agents": "/api/v1/agents",
+            "teams": "/api/v1/teams",
+            "skills": "/api/v1/skills",
+            "policies": "/api/v1/policies",
+            "workflows": "/api/v1/workflows",
+            "executions": "/api/v1/executions",
+            "presence": "/api/v1/presence",
+            "runners": "/api/v1/runners",
+            "workers": "/api/v1/workers",
+            "models": "/api/v1/models",
+            "runtimes": "/api/v1/runtimes",
+            "secrets": "/api/v1/secrets",
+            "integrations": "/api/v1/integrations",
+            "health": "/api/health",
+        }
+    }

control_plane_api/app/middleware/__init__.py

@@ -0,0 +1,8 @@
+"""Middleware modules"""
+
+from control_plane_api.app.middleware.auth import get_current_organization, extract_token_from_headers
+
+__all__ = [
+    "get_current_organization",
+    "extract_token_from_headers",
+]