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

control_plane_api/app/skills/builtin/file_generation/skill.py

@@ -0,0 +1,94 @@
+"""
+File Generation Skill
+
+Provides file generation capabilities for various formats (JSON, CSV, PDF, TXT).
+"""
+from typing import Dict, Any, List
+from control_plane_api.app.skills.base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from control_plane_api.app.skills.registry import register_skill
+
+
+class FileGenerationSkill(SkillDefinition):
+    """File generation skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.FILE_GENERATION
+
+    @property
+    def name(self) -> str:
+        return "File Generator"
+
+    @property
+    def description(self) -> str:
+        return "Generate and save files in various formats (JSON, CSV, PDF, TXT)"
+
+    @property
+    def icon(self) -> str:
+        return "FileOutput"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="file_generator",
+                name="File Generator",
+                description="Generate and save files locally: JSON, CSV, PDF, and TXT formats",
+                category=SkillCategory.COMMON,
+                badge="Recommended",
+                icon="FileOutput",
+                configuration={
+                    "enable_json_generation": True,
+                    "enable_csv_generation": True,
+                    "enable_pdf_generation": True,
+                    "enable_txt_generation": True,
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="file_generator_data_only",
+                name="File Generator - Data Only",
+                description="Generate data files only (JSON, CSV) without document formats",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="FileText",
+                configuration={
+                    "enable_json_generation": True,
+                    "enable_csv_generation": True,
+                    "enable_pdf_generation": False,
+                    "enable_txt_generation": True,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate file generation configuration"""
+        validated = {
+            "enable_json_generation": config.get("enable_json_generation", True),
+            "enable_csv_generation": config.get("enable_csv_generation", True),
+            "enable_pdf_generation": config.get("enable_pdf_generation", True),
+            "enable_txt_generation": config.get("enable_txt_generation", True),
+        }
+
+        # Add output_directory if specified
+        if "output_directory" in config:
+            validated["output_directory"] = str(config["output_directory"])
+
+        # Add max_file_size if specified (in MB)
+        if "max_file_size" in config:
+            validated["max_file_size"] = min(config.get("max_file_size", 10), 100)  # Max 100MB
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: all formats enabled"""
+        return {
+            "enable_json_generation": True,
+            "enable_csv_generation": True,
+            "enable_pdf_generation": True,
+            "enable_txt_generation": True,
+        }
+
+
+# Auto-register this skill
+register_skill(FileGenerationSkill())

control_plane_api/app/skills/builtin/file_system/__init__.py

@@ -0,0 +1,4 @@
+"""File System Skill - Provides file system access capabilities."""
+from .skill import FileSystemSkill
+
+__all__ = ["FileSystemSkill"]

control_plane_api/app/skills/builtin/file_system/skill.py

@@ -0,0 +1,110 @@
+"""
+File System Skill
+
+Provides file system access capabilities (read, write, list, search files).
+"""
+from typing import Dict, Any, List
+from control_plane_api.app.skills.base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from control_plane_api.app.skills.registry import register_skill
+
+
+class FileSystemSkill(SkillDefinition):
+    """File system access skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.FILE_SYSTEM
+
+    @property
+    def name(self) -> str:
+        return "File System"
+
+    @property
+    def description(self) -> str:
+        return "Access and manipulate files and directories on the local file system"
+
+    @property
+    def icon(self) -> str:
+        return "FolderOpen"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="file_system_read_only",
+                name="File System - Read Only",
+                description="Access local file system for reading, listing, and searching files safely",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="FolderOpen",
+                configuration={
+                    "enable_save_file": False,
+                    "enable_read_file": True,
+                    "enable_list_files": True,
+                    "enable_search_files": True,
+                },
+                is_default=False,
+            ),
+            SkillVariant(
+                id="file_system_full_access",
+                name="File System - Full Access",
+                description="Complete file system access: read, write, create, and modify local files",
+                category=SkillCategory.COMMON,
+                badge="Recommended",
+                icon="HardDrive",
+                configuration={
+                    "enable_save_file": True,
+                    "enable_read_file": True,
+                    "enable_list_files": True,
+                    "enable_search_files": True,
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="file_system_sandboxed",
+                name="File System - Sandboxed",
+                description="Isolated file access limited to /sandbox directory only",
+                category=SkillCategory.SECURITY,
+                badge="Secure",
+                icon="Shield",
+                configuration={
+                    "base_dir": "/sandbox",
+                    "enable_save_file": True,
+                    "enable_read_file": True,
+                    "enable_list_files": True,
+                    "enable_search_files": False,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate file system configuration"""
+        validated = {
+            "enable_save_file": config.get("enable_save_file", False),
+            "enable_read_file": config.get("enable_read_file", True),
+            "enable_list_files": config.get("enable_list_files", True),
+            "enable_search_files": config.get("enable_search_files", True),
+        }
+
+        # Add base_dir if specified
+        if "base_dir" in config:
+            validated["base_dir"] = str(config["base_dir"])
+
+        # Add allowed_extensions if specified
+        if "allowed_extensions" in config:
+            validated["allowed_extensions"] = list(config["allowed_extensions"])
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: full access"""
+        return {
+            "enable_save_file": True,
+            "enable_read_file": True,
+            "enable_list_files": True,
+            "enable_search_files": True,
+        }
+
+
+# Auto-register this skill
+register_skill(FileSystemSkill())

control_plane_api/app/skills/builtin/knowledge_api/__init__.py

@@ -0,0 +1,5 @@
+"""Knowledge API Skill Definition"""
+
+from .skill import KnowledgeAPISkill
+
+__all__ = ['KnowledgeAPISkill']

control_plane_api/app/skills/builtin/knowledge_api/skill.py

@@ -0,0 +1,124 @@
+"""
+Knowledge API Skill
+
+Provides semantic search capabilities across the organization's central knowledge base.
+"""
+from typing import Dict, Any, List
+from control_plane_api.app.skills.base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from control_plane_api.app.skills.registry import register_skill
+
+
+class KnowledgeAPISkill(SkillDefinition):
+    """Knowledge API semantic search skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.KNOWLEDGE_API
+
+    @property
+    def name(self) -> str:
+        return "Knowledge API"
+
+    @property
+    def description(self) -> str:
+        return "Semantic search across your organization's central knowledge base including documentation, code, conversations, and integration data"
+
+    @property
+    def icon(self) -> str:
+        return "Database"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="knowledge_api_standard",
+                name="Knowledge API - Standard",
+                description="Semantic search with automatic user context injection for scoped queries",
+                category=SkillCategory.COMMON,
+                badge="Recommended",
+                icon="Database",
+                configuration={
+                    "stream": True,
+                    "auto_inject_user_context": True,
+                    "timeout": 60,
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="knowledge_api_fast",
+                name="Knowledge API - Fast",
+                description="Quick semantic search with reduced timeout for faster responses",
+                category=SkillCategory.COMMON,
+                badge="Fast",
+                icon="Zap",
+                configuration={
+                    "stream": False,
+                    "auto_inject_user_context": True,
+                    "timeout": 30,
+                },
+                is_default=False,
+            ),
+            SkillVariant(
+                id="knowledge_api_thorough",
+                name="Knowledge API - Thorough",
+                description="Extended search timeout for comprehensive knowledge base queries",
+                category=SkillCategory.ADVANCED,
+                badge="Thorough",
+                icon="Search",
+                configuration={
+                    "stream": True,
+                    "auto_inject_user_context": True,
+                    "timeout": 120,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate knowledge API configuration"""
+        validated = {
+            "stream": config.get("stream", True),
+            "auto_inject_user_context": config.get("auto_inject_user_context", True),
+            "timeout": config.get("timeout", 60),
+        }
+
+        # Validate timeout range
+        if not (10 <= validated["timeout"] <= 300):
+            raise ValueError("Timeout must be between 10 and 300 seconds")
+
+        # Add orchestrator_url if specified
+        if "orchestrator_url" in config:
+            validated["orchestrator_url"] = str(config["orchestrator_url"])
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: streaming with auto-context"""
+        return {
+            "stream": True,
+            "auto_inject_user_context": True,
+            "timeout": 60,
+        }
+
+    def get_framework_class_name(self) -> str:
+        """
+        Get the underlying framework tool class name.
+
+        The implementation should be provided by the kubiya SDK package.
+        """
+        return "KnowledgeAPITools"
+
+    def get_requirements(self) -> "SkillRequirements":
+        """Get runtime requirements for this skill."""
+        from control_plane_api.app.skills.base import SkillRequirements
+
+        return SkillRequirements(
+            python_packages=["kubiya>=2.0.3"],
+            external_dependencies=["Kubiya Knowledge API"],
+            required_env_vars=["KUBIYA_API_KEY"],
+            notes="Knowledge API skill implementation is provided by the kubiya SDK package. "
+                  "This skill must be explicitly associated with agents/teams - it is not built-in by default."
+        )
+
+
+# Auto-register this skill
+register_skill(KnowledgeAPISkill())

control_plane_api/app/skills/builtin/python/__init__.py

@@ -0,0 +1,4 @@
+"""Python Skill - Provides Python code execution capabilities."""
+from .skill import PythonSkill
+
+__all__ = ["PythonSkill"]

control_plane_api/app/skills/builtin/python/skill.py

@@ -0,0 +1,92 @@
+"""
+Python Skill
+
+Provides Python code execution capabilities with configurable restrictions.
+"""
+from typing import Dict, Any, List
+from control_plane_api.app.skills.base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from control_plane_api.app.skills.registry import register_skill
+
+
+class PythonSkill(SkillDefinition):
+    """Python code execution skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.PYTHON
+
+    @property
+    def name(self) -> str:
+        return "Python"
+
+    @property
+    def description(self) -> str:
+        return "Execute Python code locally with configurable import restrictions"
+
+    @property
+    def icon(self) -> str:
+        return "FaPython"
+
+    @property
+    def icon_type(self) -> str:
+        return "react-icon"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="python_runtime",
+                name="Python Runtime",
+                description="Execute Python code locally with restricted imports for security",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="FaPython",
+                configuration={
+                    "enable_code_execution": True,
+                    "blocked_imports": ["os", "subprocess", "sys", "socket", "shutil"],
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="python_unrestricted",
+                name="Python - Unrestricted",
+                description="Execute Python code without import restrictions or sandboxing",
+                category=SkillCategory.ADVANCED,
+                badge="Advanced",
+                icon="FaPython",
+                configuration={
+                    "enable_code_execution": True,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate Python configuration"""
+        validated = {
+            "enable_code_execution": config.get("enable_code_execution", True),
+        }
+
+        # Add blocked_imports if specified
+        if "blocked_imports" in config:
+            validated["blocked_imports"] = list(config["blocked_imports"])
+
+        # Add allowed_imports if specified (whitelist mode)
+        if "allowed_imports" in config:
+            validated["allowed_imports"] = list(config["allowed_imports"])
+
+        # Add timeout if specified
+        if "timeout" in config:
+            validated["timeout"] = min(config.get("timeout", 30), 300)  # Max 5 minutes
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: restricted imports"""
+        return {
+            "enable_code_execution": True,
+            "blocked_imports": ["os", "subprocess", "sys", "socket", "shutil"],
+        }
+
+
+# Auto-register this skill
+register_skill(PythonSkill())

control_plane_api/app/skills/builtin/remote_filesystem/__init__.py

@@ -0,0 +1,5 @@
+"""Remote Filesystem skill for cloud storage operations."""
+
+from .skill import RemoteFilesystemSkill
+
+__all__ = ["RemoteFilesystemSkill"]

control_plane_api/app/skills/builtin/remote_filesystem/skill.py

@@ -0,0 +1,170 @@
+"""
+Remote Filesystem Skill
+
+Provides cloud storage capabilities for uploading, downloading, and managing files
+with multi-provider support (Vercel Blob, S3, Azure Blob, GCS).
+"""
+
+from typing import Dict, Any, List
+from control_plane_api.app.skills.base import (
+    SkillDefinition,
+    SkillType,
+    SkillCategory,
+    SkillVariant,
+    SkillRequirements
+)
+from control_plane_api.app.skills.registry import register_skill
+
+
+class RemoteFilesystemSkill(SkillDefinition):
+    """Remote filesystem skill with cloud storage provider support."""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.REMOTE_FILESYSTEM
+
+    @property
+    def name(self) -> str:
+        return "Remote Filesystem"
+
+    @property
+    def description(self) -> str:
+        return "Cloud storage for uploading, downloading, and managing files with multi-provider support"
+
+    @property
+    def icon(self) -> str:
+        return "Cloud"
+
+    @property
+    def icon_type(self) -> str:
+        return "lucide"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="remote_filesystem_read_only",
+                name="Remote Filesystem - Read Only",
+                description="Download and list files from cloud storage safely",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="CloudDownload",
+                configuration={
+                    "enable_upload": False,
+                    "enable_download": True,
+                    "enable_list": True,
+                    "enable_delete": False,
+                    "enable_search": True,
+                    "enable_metadata": True,
+                    "enable_move": False,
+                    "enable_copy": False,
+                    "enable_folders": False,
+                    "enable_batch_download": False,
+                },
+                is_default=False,
+            ),
+            SkillVariant(
+                id="remote_filesystem_write_enabled",
+                name="Remote Filesystem - Write Enabled",
+                description="Upload and download files with read/write access",
+                category=SkillCategory.COMMON,
+                badge="Recommended",
+                icon="Cloud",
+                configuration={
+                    "enable_upload": True,
+                    "enable_download": True,
+                    "enable_list": True,
+                    "enable_delete": False,
+                    "enable_search": True,
+                    "enable_metadata": True,
+                    "enable_move": True,
+                    "enable_copy": True,
+                    "enable_folders": False,
+                    "enable_batch_download": False,
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="remote_filesystem_full_access",
+                name="Remote Filesystem - Full Access",
+                description="Complete cloud storage access including file deletion",
+                category=SkillCategory.ADVANCED,
+                badge="Advanced",
+                icon="CloudCog",
+                configuration={
+                    "enable_upload": True,
+                    "enable_download": True,
+                    "enable_list": True,
+                    "enable_delete": True,
+                    "enable_search": True,
+                    "enable_metadata": True,
+                    "enable_move": True,
+                    "enable_copy": True,
+                    "enable_folders": True,
+                    "enable_batch_download": True,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate remote filesystem configuration."""
+        validated = {
+            "enable_upload": config.get("enable_upload", False),
+            "enable_download": config.get("enable_download", True),
+            "enable_list": config.get("enable_list", True),
+            "enable_delete": config.get("enable_delete", False),
+            "enable_search": config.get("enable_search", True),
+            "enable_metadata": config.get("enable_metadata", True),
+            "enable_move": config.get("enable_move", False),
+            "enable_copy": config.get("enable_copy", False),
+            "enable_folders": config.get("enable_folders", False),
+            "enable_batch_download": config.get("enable_batch_download", False),
+        }
+
+        # Optional: path restrictions
+        if "allowed_paths" in config:
+            validated["allowed_paths"] = list(config["allowed_paths"])
+
+        # Optional: file size limit
+        if "max_file_size_mb" in config:
+            validated["max_file_size_mb"] = int(config["max_file_size_mb"])
+
+        # Optional: allowed file extensions
+        if "allowed_extensions" in config:
+            validated["allowed_extensions"] = list(config["allowed_extensions"])
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: write-enabled without delete."""
+        return {
+            "enable_upload": True,
+            "enable_download": True,
+            "enable_list": True,
+            "enable_delete": False,
+            "enable_search": True,
+            "enable_metadata": True,
+            "enable_move": True,
+            "enable_copy": True,
+            "enable_folders": False,
+            "enable_batch_download": False,
+        }
+
+    def get_requirements(self) -> SkillRequirements:
+        return SkillRequirements(
+            python_packages=["httpx>=0.24.0", "PyYAML>=6.0"],
+            required_env_vars=["STORAGE_PROVIDER"],
+            external_dependencies=[
+                "Storage provider configuration required:",
+                "  - Vercel Blob: VERCEL_BLOB_TOKEN",
+                "  - S3: AWS credentials (future)",
+                "  - Azure Blob: Azure credentials (future)",
+                "  - GCS: GCP credentials (future)"
+            ],
+            notes="Requires storage provider to be configured via STORAGE_PROVIDER environment variable. "
+                  "No default provider - must be explicitly enabled."
+        )
+
+
+# Auto-register this skill
+register_skill(RemoteFilesystemSkill())

control_plane_api/app/skills/builtin/shell/__init__.py

@@ -0,0 +1,4 @@
+"""Shell Skill - Provides shell command execution capabilities."""
+from .skill import ShellSkill
+
+__all__ = ["ShellSkill"]