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

control_plane_api/worker/services/session_service.py

@@ -0,0 +1,194 @@
+"""Session management service - handles loading and persisting conversation history"""
+
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timezone
+import structlog
+import httpx
+
+from control_plane_api.worker.control_plane_client import ControlPlaneClient
+from control_plane_api.worker.utils.retry_utils import retry_with_backoff
+
+logger = structlog.get_logger()
+
+
+def _safe_timestamp_to_iso(timestamp: Any) -> str:
+    """
+    Safely convert a timestamp (int, float, datetime, or str) to ISO format string.
+
+    Args:
+        timestamp: Can be Unix timestamp (int/float), datetime object, or ISO string
+
+    Returns:
+        ISO format timestamp string
+    """
+    if isinstance(timestamp, str):
+        # Already a string, return as-is
+        return timestamp
+    elif isinstance(timestamp, datetime):
+        # datetime object, call isoformat()
+        return timestamp.isoformat()
+    elif isinstance(timestamp, (int, float)):
+        # Unix timestamp, convert to datetime first
+        return datetime.fromtimestamp(timestamp, tz=timezone.utc).isoformat()
+    else:
+        # Fallback to current time
+        return datetime.now(timezone.utc).isoformat()
+
+
+class SessionService:
+    """
+    Manages session history loading and persistence via Control Plane API.
+
+    Workers don't have database access, so all session operations go through
+    the Control Plane which provides Redis caching for hot loads.
+    """
+
+    def __init__(self, control_plane: ControlPlaneClient):
+        self.control_plane = control_plane
+
+    @retry_with_backoff(max_retries=3, initial_delay=1.0)
+    def load_session(
+        self,
+        execution_id: str,
+        session_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Load session history from Control Plane (with retry).
+
+        Returns:
+            List of message dicts with role, content, timestamp, etc.
+            Empty list if session not found or on error.
+        """
+        if not session_id:
+            return []
+
+        try:
+            session_data = self.control_plane.get_session(
+                execution_id=execution_id,
+                session_id=session_id
+            )
+
+            if session_data and session_data.get("messages"):
+                messages = session_data["messages"]
+                logger.info(
+                    "session_loaded",
+                    execution_id=execution_id[:8],
+                    message_count=len(messages)
+                )
+                return messages
+
+            return []
+
+        except httpx.TimeoutException:
+            logger.warning(
+                "session_load_timeout",
+                execution_id=execution_id[:8]
+            )
+            raise  # Let retry decorator handle it
+        except Exception as e:
+            logger.warning(
+                "session_load_error",
+                execution_id=execution_id[:8],
+                error=str(e)
+            )
+            return []  # Don't retry on non-timeout errors
+
+    @retry_with_backoff(max_retries=3, initial_delay=1.0)
+    def persist_session(
+        self,
+        execution_id: str,
+        session_id: str,
+        user_id: Optional[str],
+        messages: List[Dict[str, Any]],
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        """
+        Persist session history to Control Plane (with retry).
+
+        Returns:
+            True if successful, False otherwise
+        """
+        if not messages:
+            logger.info("session_persist_skipped_no_messages", execution_id=execution_id[:8])
+            return True
+
+        try:
+            success = self.control_plane.persist_session(
+                execution_id=execution_id,
+                session_id=session_id or execution_id,
+                user_id=user_id,
+                messages=messages,
+                metadata=metadata or {}
+            )
+
+            if success:
+                logger.info(
+                    "session_persisted",
+                    execution_id=execution_id[:8],
+                    message_count=len(messages)
+                )
+
+            return success
+
+        except Exception as e:
+            logger.error(
+                "session_persist_error",
+                execution_id=execution_id[:8],
+                error=str(e)
+            )
+            return False
+
+    def build_conversation_context(
+        self,
+        session_messages: List[Dict[str, Any]]
+    ) -> List[Dict[str, str]]:
+        """
+        Convert Control Plane session messages to Agno format.
+
+        Args:
+            session_messages: Messages from Control Plane
+
+        Returns:
+            List of dicts with 'role' and 'content' for Agno
+        """
+        context = []
+        for msg in session_messages:
+            context.append({
+                "role": msg.get("role", "user"),
+                "content": msg.get("content", ""),
+            })
+        return context
+
+    def extract_messages_from_result(
+        self,
+        result: Any,
+        user_id: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Extract messages from Agno Agent/Team result.
+
+        Args:
+            result: Agno RunResponse object
+            user_id: Optional user ID to attach
+
+        Returns:
+            List of message dicts ready for persistence
+        """
+        messages = []
+
+        if hasattr(result, "messages") and result.messages:
+            for msg in result.messages:
+                messages.append({
+                    "role": msg.role,
+                    "content": msg.content,
+                    "timestamp": (
+                        _safe_timestamp_to_iso(msg.created_at)
+                        if hasattr(msg, "created_at") and msg.created_at is not None
+                        else datetime.now(timezone.utc).isoformat()
+                    ),
+                    "user_id": getattr(msg, "user_id", user_id),
+                    "user_name": getattr(msg, "user_name", None),
+                    "user_email": getattr(msg, "user_email", None),
+                })
+
+        return messages

control_plane_api/worker/services/skill_factory.py

@@ -0,0 +1,175 @@
+"""Skill factory - instantiates skill toolkits from Control Plane configuration"""
+
+from typing import Optional, Any, List
+from pathlib import Path
+import structlog
+import os
+
+from agno.tools.shell import ShellTools
+from agno.tools.python import PythonTools
+from agno.tools.file import FileTools
+from control_plane_api.worker.services.workflow_executor_tools import WorkflowExecutorTools
+
+logger = structlog.get_logger()
+
+
+class SkillFactory:
+    """
+    Factory for creating skill toolkit instances from Control Plane skill configurations.
+
+    Centralizes skill instantiation logic that was previously duplicated
+    in agent_activities.py and team_activities.py.
+    """
+
+    @staticmethod
+    def create_skill(skill_data: dict) -> Optional[Any]:
+        """
+        Create a skill toolkit from Control Plane configuration.
+
+        Args:
+            skill_data: Skill config from Control Plane API:
+                - type: Skill type (file_system, shell, python, etc.)
+                - name: Skill name
+                - configuration: Dict with skill-specific config
+                - enabled: Whether skill is enabled
+
+        Returns:
+            Instantiated skill toolkit or None if disabled/unsupported
+        """
+        if not skill_data.get("enabled", True):
+            logger.info(
+                "skill_skipped_disabled",
+                skill_name=skill_data.get("name")
+            )
+            return None
+
+        skill_type = skill_data.get("type", "").lower()
+        config = skill_data.get("configuration", {})
+        name = skill_data.get("name", "Unknown")
+
+        try:
+            # File system tools
+            if skill_type in ["file_system", "file", "file_generation"]:
+                base_dir = config.get("base_directory", "/workspace")
+                return FileTools(base_dir=Path(base_dir))
+
+            # Shell/terminal tools
+            elif skill_type in ["shell", "terminal", "bash"]:
+                return ShellTools()
+
+            # Python tools
+            elif skill_type in ["python", "python_code"]:
+                return PythonTools()
+
+            # Workflow executor tools
+            elif skill_type in ["workflow_executor", "workflow"]:
+                logger.info(
+                    "🔍 Creating workflow_executor skill",
+                    skill_name=name,
+                    skill_type=skill_type,
+                )
+
+                # New multi-workflow format
+                workflows = config.get("workflows")
+
+                # Legacy single-workflow format
+                workflow_type = config.get("workflow_type", "json")
+                workflow_definition = config.get("workflow_definition")
+                python_dsl_code = config.get("python_dsl_code")
+
+                # Common configuration
+                validation_enabled = config.get("validation_enabled", True)
+                default_runner = config.get("default_runner")
+                timeout = config.get("timeout", 3600)
+                default_parameters = config.get("default_parameters")
+
+                # Get Kubiya API credentials from environment
+                # These are needed for remote workflow execution
+                kubiya_api_key = os.environ.get("KUBIYA_API_KEY")
+                kubiya_api_base = os.environ.get("KUBIYA_API_BASE", "https://api.kubiya.ai")
+
+                logger.info(
+                    "workflow_executor_config",
+                    skill_name=name,
+                    has_workflows=bool(workflows),
+                    workflows_count=len(workflows) if workflows else 0,
+                    has_api_key=bool(kubiya_api_key),
+                    api_base=kubiya_api_base,
+                )
+
+                if not kubiya_api_key:
+                    logger.warning(
+                        "workflow_executor_no_api_key",
+                        skill_name=name,
+                        message="KUBIYA_API_KEY not found - workflow execution will fail"
+                    )
+
+                workflow_tool = WorkflowExecutorTools(
+                    name=name,  # Pass the skill name from configuration
+                    workflows=workflows,
+                    workflow_type=workflow_type,
+                    workflow_definition=workflow_definition,
+                    python_dsl_code=python_dsl_code,
+                    validation_enabled=validation_enabled,
+                    default_runner=default_runner,
+                    timeout=timeout,
+                    default_parameters=default_parameters,
+                    kubiya_api_key=kubiya_api_key,  # Explicitly pass API key
+                    kubiya_api_base=kubiya_api_base,  # Explicitly pass API base URL
+                )
+
+                logger.info(
+                    "✅ Workflow executor skill created successfully",
+                    skill_name=name,
+                    tool_class=type(workflow_tool).__name__,
+                    has_functions=hasattr(workflow_tool, 'functions'),
+                    function_count=len(workflow_tool.functions) if hasattr(workflow_tool, 'functions') else 0,
+                )
+
+                return workflow_tool
+
+            else:
+                logger.warning(
+                    "skill_type_not_supported",
+                    skill_type=skill_type,
+                    skill_name=name
+                )
+                return None
+
+        except Exception as e:
+            logger.error(
+                "skill_instantiation_failed",
+                skill_type=skill_type,
+                skill_name=name,
+                error=str(e)
+            )
+            return None
+
+    @classmethod
+    def create_skills_from_list(
+        cls,
+        skill_configs: List[dict]
+    ) -> List[Any]:
+        """
+        Create multiple skills from a list of configurations.
+
+        Args:
+            skill_configs: List of skill config dicts
+
+        Returns:
+            List of instantiated skills (non-None)
+        """
+        skills = []
+
+        for config in skill_configs:
+            skill = cls.create_skill(config)
+            if skill:
+                skills.append(skill)
+
+        logger.info(
+            "skills_created",
+            requested_count=len(skill_configs),
+            created_count=len(skills)
+        )
+
+        return skills