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

control_plane_api/worker/skills/builtin/context_graph_search/skill.yaml

@@ -0,0 +1,67 @@
+apiVersion: kubiya.ai/v1
+kind: Skill
+metadata:
+  name: context-graph-search
+  version: 1.2.2
+  description: Complete memory system - store/recall memories, ingest knowledge, and search organizational context graph
+  author: Kubiya
+  icon: Brain
+  icon_type: lucide
+
+spec:
+  type: context_graph_search
+
+  implementations:
+    agno:
+      module: agno_impl
+      class: ContextGraphSearchTools
+    claude_code:
+      # Claude Code will use same implementation converted to MCP server
+      module: agno_impl
+      class: ContextGraphSearchTools
+    default:
+      module: agno_impl
+      class: ContextGraphSearchTools
+
+  pythonDependencies:
+    - httpx>=0.24.0
+
+  systemRequirements:
+    supportedOS: [linux, darwin, win32]
+    minPythonVersion: "3.10"
+
+  environmentVariables:
+    - name: CONTEXT_GRAPH_API_BASE
+      required: false
+      description: Context Graph API base URL (auto-fetched from control plane)
+      default: "https://context-graph-api.dev.kubiya.ai"
+    - name: KUBIYA_API_KEY
+      required: true
+      description: Kubiya API key for authentication
+    - name: KUBIYA_ORG_ID
+      required: false
+      description: Kubiya organization ID
+    - name: MEMORY_DATASET_NAME
+      required: false
+      description: Dataset name for memory scoping (defaults to "default")
+      default: "default"
+
+  configSchema:
+    type: object
+    properties:
+      api_base:
+        type: string
+        description: Context Graph API base URL (auto-fetched from control plane)
+        default: "https://context-graph-api.dev.kubiya.ai"
+      timeout:
+        type: integer
+        description: Request timeout in seconds
+        default: 30
+        minimum: 5
+        maximum: 120
+      default_limit:
+        type: integer
+        description: Default result limit for queries
+        default: 100
+        minimum: 1
+        maximum: 1000

control_plane_api/worker/skills/builtin/contextual_awareness/__init__.py

@@ -0,0 +1,4 @@
+"""Contextual Awareness skill worker implementation."""
+from .agno_impl import ContextualAwarenessTools
+
+__all__ = ["ContextualAwarenessTools"]

control_plane_api/worker/skills/builtin/contextual_awareness/agno_impl.py

@@ -0,0 +1,62 @@
+"""Contextual Awareness skill implementation for agno runtime."""
+from control_plane_api.worker.services.contextual_awareness_tools import (
+    ContextualAwarenessTools as BaseContextualAwarenessTools
+)
+
+
+class ContextualAwarenessTools(BaseContextualAwarenessTools):
+    """
+    Contextual Awareness tools using existing ContextualAwarenessTools.
+
+    Wraps the base contextual awareness implementation.
+    """
+
+    def __init__(
+        self,
+        predefined_nodes: list = None,
+        predefined_relationships: list = None,
+        allow_dynamic_search: bool = False,
+        allow_text_search: bool = True,
+        allow_subgraph_queries: bool = False,
+        allowed_integrations: list = None,
+        max_results: int = 100,
+        default_subgraph_depth: int = 1,
+        enable_caching: bool = True,
+        cache_ttl: int = 300,
+        control_plane_base_url: str = None,
+        kubiya_api_key: str = None,
+        **kwargs
+    ):
+        """
+        Initialize contextual awareness tools.
+
+        Args:
+            predefined_nodes: List of predefined node filters
+            predefined_relationships: List of predefined relationship filters
+            allow_dynamic_search: Allow dynamic searches and custom Cypher queries
+            allow_text_search: Allow text-based searches
+            allow_subgraph_queries: Allow subgraph queries
+            allowed_integrations: List of allowed integrations (None = all)
+            max_results: Maximum results per query
+            default_subgraph_depth: Default subgraph traversal depth
+            enable_caching: Enable result caching
+            cache_ttl: Cache TTL in seconds
+            control_plane_base_url: Control Plane API base URL
+            kubiya_api_key: Kubiya API key for authentication
+            **kwargs: Additional configuration
+        """
+        super().__init__(
+            predefined_nodes=predefined_nodes,
+            predefined_relationships=predefined_relationships,
+            allow_dynamic_search=allow_dynamic_search,
+            allow_text_search=allow_text_search,
+            allow_subgraph_queries=allow_subgraph_queries,
+            allowed_integrations=allowed_integrations,
+            max_results=max_results,
+            default_subgraph_depth=default_subgraph_depth,
+            enable_caching=enable_caching,
+            cache_ttl=cache_ttl,
+            control_plane_base_url=control_plane_base_url,
+            kubiya_api_key=kubiya_api_key,
+            **kwargs
+        )

control_plane_api/worker/skills/builtin/data_visualization/agno_impl.py

@@ -0,0 +1,18 @@
+"""Data Visualization skill implementation for all runtimes."""
+from control_plane_api.worker.services.data_visualization import DataVisualizationTools as BaseDataVisualizationTools
+
+
+class DataVisualizationTools(BaseDataVisualizationTools):
+    """
+    Data visualization and diagramming tools using Mermaid syntax.
+
+    This wrapper imports the full implementation from services.data_visualization
+    and makes it available as a builtin skill.
+
+    For agno runtime: Used directly as agno.tools.Toolkit
+    For claude_code runtime: Automatically converted to MCP server
+
+    The class already extends agno.tools.Toolkit and has all tools registered,
+    so no additional wrapper logic is needed.
+    """
+    pass

control_plane_api/worker/skills/builtin/data_visualization/skill.yaml

@@ -0,0 +1,84 @@
+apiVersion: kubiya.ai/v1
+kind: Skill
+metadata:
+  name: data-visualization
+  version: 1.0.0
+  description: Create diagrams and visualizations using Mermaid syntax
+  author: Kubiya
+  icon: BarChart3
+  icon_type: lucide
+
+spec:
+  type: data_visualization
+
+  implementations:
+    agno:
+      module: agno_impl
+      class: DataVisualizationTools
+    claude_code:
+      # Claude Code will use same implementation converted to MCP server
+      # The agno Toolkit is automatically wrapped as an MCP server
+      module: agno_impl
+      class: DataVisualizationTools
+    default:
+      module: agno_impl
+      class: DataVisualizationTools
+
+  pythonDependencies:
+    - agno>=0.1.0
+
+  systemRequirements:
+    supportedOS: [linux, darwin, win32]
+    minPythonVersion: "3.10"
+
+  environmentVariables: []
+
+  configSchema:
+    type: object
+    properties:
+      enable_flowchart:
+        type: boolean
+        description: Enable flowchart diagrams
+        default: true
+      enable_sequence:
+        type: boolean
+        description: Enable sequence diagrams
+        default: true
+      enable_class_diagram:
+        type: boolean
+        description: Enable class diagrams
+        default: true
+      enable_er_diagram:
+        type: boolean
+        description: Enable ER diagrams
+        default: true
+      enable_gantt:
+        type: boolean
+        description: Enable Gantt charts
+        default: true
+      enable_pie_chart:
+        type: boolean
+        description: Enable pie charts
+        default: true
+      enable_state_diagram:
+        type: boolean
+        description: Enable state diagrams
+        default: true
+      enable_git_graph:
+        type: boolean
+        description: Enable git graphs
+        default: true
+      enable_user_journey:
+        type: boolean
+        description: Enable user journey diagrams
+        default: true
+      enable_quadrant_chart:
+        type: boolean
+        description: Enable quadrant charts
+        default: true
+      max_diagram_size:
+        type: integer
+        description: Maximum diagram size in characters
+        default: 50000
+        minimum: 1000
+        maximum: 100000

control_plane_api/worker/skills/builtin/docker/agno_impl.py

@@ -0,0 +1,65 @@
+"""Docker skill implementation for agno runtime."""
+from agno.tools import Toolkit
+import docker
+from control_plane_api.worker.skills.builtin.schema_fix_mixin import SchemaFixMixin
+
+
+class DockerTools(SchemaFixMixin, Toolkit):
+    """
+    Docker management tools.
+
+    Provides Docker container, image, volume, and network management.
+    """
+
+    def __init__(
+        self,
+        enable_container_management: bool = True,
+        enable_image_management: bool = False,
+        enable_volume_management: bool = False,
+        enable_network_management: bool = False,
+        docker_host: str = "unix:///var/run/docker.sock",
+        **kwargs
+    ):
+        """
+        Initialize Docker tools.
+
+        Args:
+            enable_container_management: Enable container operations
+            enable_image_management: Enable image operations
+            enable_volume_management: Enable volume operations
+            enable_network_management: Enable network operations
+            docker_host: Docker daemon socket
+            **kwargs: Additional configuration
+        """
+        super().__init__(name="docker")
+        self.client = docker.DockerClient(base_url=docker_host)
+        self.enable_containers = enable_container_management
+        self.enable_images = enable_image_management
+        self.enable_volumes = enable_volume_management
+        self.enable_networks = enable_network_management
+
+        # Register functions based on enabled features
+        if self.enable_containers:
+            self.register(self.list_containers)
+            self.register(self.start_container)
+            self.register(self.stop_container)
+
+        # Fix: Rebuild function schemas with proper parameters
+        self._rebuild_function_schemas()
+
+    def list_containers(self, all: bool = False) -> str:
+        """List Docker containers."""
+        containers = self.client.containers.list(all=all)
+        return "\\n".join([f"{c.id[:12]} {c.name} {c.status}" for c in containers])
+
+    def start_container(self, container_id: str) -> str:
+        """Start a Docker container."""
+        container = self.client.containers.get(container_id)
+        container.start()
+        return f"Container {container_id} started"
+
+    def stop_container(self, container_id: str) -> str:
+        """Stop a Docker container."""
+        container = self.client.containers.get(container_id)
+        container.stop()
+        return f"Container {container_id} stopped"

control_plane_api/worker/skills/builtin/docker/skill.yaml

@@ -0,0 +1,60 @@
+apiVersion: kubiya.ai/v1
+kind: Skill
+metadata:
+  name: docker
+  version: 1.0.0
+  description: Manage Docker containers, images, volumes, and networks
+  author: Kubiya
+  icon: FaDocker
+  icon_type: react-icon
+
+spec:
+  type: docker
+
+  implementations:
+    agno:
+      module: agno_impl
+      class: DockerTools
+    claude_code:
+      # Claude Code executes Docker commands via Bash tool
+      # Docker CLI commands run through shell
+      builtin: true
+      tools: ["Bash"]
+    default:
+      module: agno_impl
+      class: DockerTools
+
+  pythonDependencies:
+    - docker>=6.0.0
+
+  systemRequirements:
+    supportedOS: [linux, darwin, win32]
+    minPythonVersion: "3.10"
+    externalDependencies:
+      - Docker daemon must be running
+
+  environmentVariables: []
+
+  configSchema:
+    type: object
+    properties:
+      enable_container_management:
+        type: boolean
+        description: Enable container operations
+        default: true
+      enable_image_management:
+        type: boolean
+        description: Enable image operations
+        default: false
+      enable_volume_management:
+        type: boolean
+        description: Enable volume operations
+        default: false
+      enable_network_management:
+        type: boolean
+        description: Enable network operations
+        default: false
+      docker_host:
+        type: string
+        description: Docker daemon socket
+        default: "unix:///var/run/docker.sock"

control_plane_api/worker/skills/builtin/file_generation/agno_impl.py

@@ -0,0 +1,47 @@
+"""File Generation skill implementation for agno runtime."""
+from agno.tools.file import FileTools
+from control_plane_api.worker.skills.builtin.schema_fix_mixin import SchemaFixMixin
+
+
+class FileGenerationTools(SchemaFixMixin, FileTools):
+    """
+    File generation tools using agno FileTools.
+
+    Provides file generation capabilities for various formats.
+    """
+
+    def __init__(
+        self,
+        enable_json_generation: bool = True,
+        enable_csv_generation: bool = True,
+        enable_pdf_generation: bool = True,
+        enable_txt_generation: bool = True,
+        output_directory: str = "",
+        max_file_size: int = 10,
+        **kwargs
+    ):
+        """
+        Initialize file generation tools.
+
+        Args:
+            enable_json_generation: Enable JSON generation
+            enable_csv_generation: Enable CSV generation
+            enable_pdf_generation: Enable PDF generation
+            enable_txt_generation: Enable TXT generation
+            output_directory: Default output directory
+            max_file_size: Maximum file size in MB
+            **kwargs: Additional configuration
+        """
+        from pathlib import Path
+        base_dir = Path(output_directory) if output_directory else Path.cwd()
+        super().__init__(base_dir=base_dir)
+        self.config = {
+            "enable_json": enable_json_generation,
+            "enable_csv": enable_csv_generation,
+            "enable_pdf": enable_pdf_generation,
+            "enable_txt": enable_txt_generation,
+            "max_size": max_file_size,
+        }
+
+        # Fix: Rebuild function schemas with proper parameters
+        self._rebuild_function_schemas()

control_plane_api/worker/skills/builtin/file_generation/skill.yaml

@@ -0,0 +1,64 @@
+apiVersion: kubiya.ai/v1
+kind: Skill
+metadata:
+  name: file-generator
+  version: 1.0.0
+  description: Generate and save files in various formats (JSON, CSV, PDF, TXT)
+  author: Kubiya
+  icon: FileOutput
+  icon_type: lucide
+
+spec:
+  type: file_generation
+
+  implementations:
+    agno:
+      module: agno_impl
+      class: FileGenerationTools
+    claude_code:
+      # Claude Code generates files via Write tool
+      # File generation handled by built-in Write tool
+      builtin: true
+      tools: ["Write"]
+    default:
+      module: agno_impl
+      class: FileGenerationTools
+
+  pythonDependencies:
+    - agno>=0.1.0
+
+  systemRequirements:
+    supportedOS: [linux, darwin, win32]
+    minPythonVersion: "3.10"
+
+  environmentVariables: []
+
+  configSchema:
+    type: object
+    properties:
+      enable_json_generation:
+        type: boolean
+        description: Enable JSON file generation
+        default: true
+      enable_csv_generation:
+        type: boolean
+        description: Enable CSV file generation
+        default: true
+      enable_pdf_generation:
+        type: boolean
+        description: Enable PDF file generation
+        default: true
+      enable_txt_generation:
+        type: boolean
+        description: Enable TXT file generation
+        default: true
+      output_directory:
+        type: string
+        description: Default output directory
+        default: ""
+      max_file_size:
+        type: integer
+        description: Maximum file size in MB
+        default: 10
+        minimum: 1
+        maximum: 100

control_plane_api/worker/skills/builtin/file_system/agno_impl.py

@@ -0,0 +1,32 @@
+"""File System skill implementation for agno runtime."""
+from pathlib import Path
+from typing import Optional
+from agno.tools.file import FileTools
+from control_plane_api.worker.skills.builtin.schema_fix_mixin import SchemaFixMixin
+
+
+class FileSystemTools(SchemaFixMixin, FileTools):
+    """
+    File system operations using agno FileTools.
+
+    Wraps agno's FileTools to provide file system access.
+    """
+
+    def __init__(self, base_directory: Optional[str] = None, **kwargs):
+        """
+        Initialize file system tools.
+
+        Args:
+            base_directory: Base directory for file operations.
+                          If None and execution_id provided, uses .kubiya/workspaces/<execution-id>
+                          If None and no execution_id, uses current working directory
+                          If set explicitly, uses provided path (user override)
+            **kwargs: Additional configuration (read_only, max_file_size, etc.)
+        """
+        # Agno's FileTools handles None as current directory
+        base_dir_path = Path(base_directory) if base_directory else None
+        super().__init__(base_dir=base_dir_path)
+        self.config = kwargs
+
+        # Fix: Rebuild function schemas with proper parameters
+        self._rebuild_function_schemas()

control_plane_api/worker/skills/builtin/file_system/skill.yaml

@@ -0,0 +1,54 @@
+apiVersion: kubiya.ai/v1
+kind: Skill
+metadata:
+  name: file-system
+  version: 1.0.0
+  description: Access and manipulate files on the local file system
+  author: Kubiya
+  icon: Folder
+  icon_type: lucide
+
+spec:
+  type: file_system
+
+  implementations:
+    agno:
+      module: agno_impl
+      class: FileSystemTools
+    claude_code:
+      # Claude Code has built-in file tools (Read, Write, Edit, Glob, Grep)
+      # No implementation needed - mapped via ClaudeCodeRuntime._map_skills_to_tools()
+      builtin: true
+      tools: ["Read", "Write", "Edit", "Glob", "Grep"]
+    default:
+      module: agno_impl
+      class: FileSystemTools
+
+  pythonDependencies:
+    - agno>=0.1.0
+
+  systemRequirements:
+    supportedOS: [linux, darwin, win32]
+    minPythonVersion: "3.10"
+
+  environmentVariables: []
+
+  configSchema:
+    type: object
+    properties:
+      base_directory:
+        type: string
+        description: Base directory for file operations
+        default: "/workspace"
+      read_only:
+        type: boolean
+        description: Restrict to read-only operations
+        default: false
+      max_file_size:
+        type: integer
+        description: Maximum file size in MB
+        default: 10
+        minimum: 1
+        maximum: 1000
+    required:
+      - base_directory

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

@@ -0,0 +1,4 @@
+"""Knowledge API skill - opt-in semantic search for organization knowledge base."""
+from .agno_impl import KnowledgeAPITools
+
+__all__ = ['KnowledgeAPITools']

control_plane_api/worker/skills/builtin/knowledge_api/agno_impl.py

@@ -0,0 +1,50 @@
+"""
+Knowledge API skill implementation for all runtimes.
+
+This skill imports the KnowledgeAPITools implementation from the kubiya SDK package.
+It provides semantic search capabilities across the organization's knowledge base.
+
+NOTE: This is an opt-in skill that must be explicitly associated with agents/teams.
+It is NOT auto-included like context_graph_search.
+"""
+
+try:
+    from kubiya.tools import KnowledgeAPITools as SDKKnowledgeAPITools
+
+    class KnowledgeAPITools(SDKKnowledgeAPITools):
+        """
+        Knowledge API tools for semantic search.
+
+        This wrapper imports the implementation from kubiya SDK and makes it
+        available as a builtin skill that can be associated with agents/teams.
+
+        For agno runtime: Used directly as agno.tools.Toolkit
+        For claude_code runtime: Automatically converted to MCP server
+
+        The SDK class already extends agno.tools.Toolkit and has all tools registered.
+        """
+        pass
+
+except ImportError as e:
+    # If kubiya SDK is not installed, provide a fallback that explains the issue
+    import structlog
+    from agno.tools import Toolkit
+
+    logger = structlog.get_logger()
+
+    class KnowledgeAPITools(Toolkit):
+        """
+        Fallback implementation when kubiya SDK is not available.
+
+        This will raise an error during instantiation to guide users.
+        """
+
+        def __init__(self, **kwargs):
+            super().__init__(name="knowledge_api")
+            error_msg = (
+                "KnowledgeAPITools requires kubiya SDK (kubiya>=2.0.3). "
+                f"Import error: {str(e)}. "
+                "Please ensure the kubiya SDK package is installed: pip install 'kubiya>=2.0.3'"
+            )
+            logger.error("knowledge_api_sdk_missing", error=error_msg, import_error=str(e))
+            raise ImportError(error_msg)

control_plane_api/worker/skills/builtin/knowledge_api/skill.yaml

@@ -0,0 +1,66 @@
+apiVersion: kubiya.ai/v1
+kind: Skill
+metadata:
+  name: knowledge-api
+  version: 1.0.0
+  description: Semantic search across organization's knowledge base
+  author: Kubiya
+  icon: Database
+  icon_type: lucide
+
+spec:
+  type: knowledge_api
+
+  implementations:
+    agno:
+      module: agno_impl
+      class: KnowledgeAPITools
+    claude_code:
+      # Claude Code will use same implementation converted to MCP server
+      module: agno_impl
+      class: KnowledgeAPITools
+    default:
+      module: agno_impl
+      class: KnowledgeAPITools
+
+  pythonDependencies:
+    - kubiya>=2.0.3
+
+  systemRequirements:
+    supportedOS: [linux, darwin, win32]
+    minPythonVersion: "3.10"
+
+  environmentVariables:
+    - name: KUBIYA_API_KEY
+      required: true
+      description: Kubiya API key for authentication
+    - name: KUBIYA_ORCHESTRATOR_URL
+      required: false
+      description: Custom orchestrator URL
+    - name: KUBIYA_ORG_ID
+      required: false
+      description: Kubiya organization ID
+    - name: KUBIYA_USER_ID
+      required: false
+      description: Kubiya user ID
+
+  configSchema:
+    type: object
+    properties:
+      stream:
+        type: boolean
+        description: Use streaming mode for queries
+        default: true
+      auto_inject_user_context:
+        type: boolean
+        description: Automatically inject user_id and org_id
+        default: true
+      timeout:
+        type: integer
+        description: Request timeout in seconds
+        default: 60
+        minimum: 10
+        maximum: 300
+      orchestrator_url:
+        type: string
+        description: Custom orchestrator URL (optional)