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

control_plane_api/app/lib/planning_tools/environments.py

@@ -0,0 +1,214 @@
+"""
+Environment Context Tools - Fetch environment and infrastructure information
+"""
+
+from typing import Optional
+from control_plane_api.app.lib.planning_tools.base import BasePlanningTools
+
+
+class EnvironmentsContextTools(BasePlanningTools):
+    """
+    Tools for fetching environment and infrastructure context
+
+    Provides methods to:
+    - List available execution environments
+    - Get worker queue information
+    - Check resource availability
+    - Query runtime configurations
+    """
+
+    def __init__(self, base_url: str = "http://localhost:8000", organization_id: Optional[str] = None):
+        super().__init__(base_url=base_url, organization_id=organization_id)
+        self.name = "environment_context_tools"
+
+    async def list_environments(self, limit: int = 50) -> str:
+        """
+        List all available execution environments
+
+        Args:
+            limit: Maximum number of environments to return
+
+        Returns:
+            Formatted string with environment information including:
+            - Environment name and ID
+            - Status (active/inactive)
+            - Available resources
+            - Configuration details
+        """
+        try:
+            params = {"limit": limit}
+            if self.organization_id:
+                params["organization_id"] = self.organization_id
+
+            response = await self._make_request("GET", "/environments", params=params)
+
+            environments = response if isinstance(response, list) else response.get("environments", [])
+
+            return self._format_list_response(
+                items=environments,
+                title="Available Environments",
+                key_fields=["status", "type", "region"],
+            )
+
+        except Exception as e:
+            return f"Error listing environments: {str(e)}"
+
+    async def get_environment_details(self, environment_id: str) -> str:
+        """
+        Get detailed information about a specific environment
+
+        Args:
+            environment_id: ID of the environment to fetch
+
+        Returns:
+            Detailed environment information including:
+            - Full configuration
+            - Resource limits
+            - Network settings
+            - Security policies
+        """
+        try:
+            response = await self._make_request("GET", f"/environments/{environment_id}")
+
+            return self._format_detail_response(
+                item=response,
+                title=f"Environment Details: {response.get('name', 'Unknown')}",
+            )
+
+        except Exception as e:
+            return f"Error fetching environment {environment_id}: {str(e)}"
+
+    async def list_worker_queues(self, environment_id: Optional[str] = None) -> str:
+        """
+        List available worker queues for task execution
+
+        Args:
+            environment_id: Optional environment ID to filter queues
+
+        Returns:
+            List of worker queues with:
+            - Queue name and ID
+            - Active worker count
+            - Queue status
+            - Processing capacity
+        """
+        try:
+            if environment_id:
+                endpoint = f"/environments/{environment_id}/worker-queues"
+            else:
+                endpoint = "/worker-queues"
+
+            params = {}
+            if self.organization_id:
+                params["organization_id"] = self.organization_id
+
+            response = await self._make_request("GET", endpoint, params=params)
+
+            queues = response if isinstance(response, list) else response.get("queues", [])
+
+            return self._format_list_response(
+                items=queues,
+                title="Available Worker Queues",
+                key_fields=["status", "active_workers", "pending_tasks", "environment_id"],
+            )
+
+        except Exception as e:
+            return f"Error listing worker queues: {str(e)}"
+
+    async def get_worker_queue_details(self, queue_id: str) -> str:
+        """
+        Get detailed information about a specific worker queue
+
+        Args:
+            queue_id: ID of the worker queue
+
+        Returns:
+            Detailed queue information including:
+            - Worker capacity and utilization
+            - Queue statistics
+            - Configuration
+        """
+        try:
+            response = await self._make_request("GET", f"/worker-queues/{queue_id}")
+
+            return self._format_detail_response(
+                item=response,
+                title=f"Worker Queue Details: {response.get('name', 'Unknown')}",
+            )
+
+        except Exception as e:
+            return f"Error fetching worker queue {queue_id}: {str(e)}"
+
+    async def check_resource_availability(self, environment_id: str) -> str:
+        """
+        Check resource availability in a specific environment
+
+        Args:
+            environment_id: ID of the environment to check
+
+        Returns:
+            Resource availability status including:
+            - CPU/Memory availability
+            - Active workers
+            - Queue capacity
+        """
+        try:
+            # Get environment details
+            env_response = await self._make_request("GET", f"/environments/{environment_id}")
+
+            # Get worker queues for this environment
+            queues_response = await self._make_request(
+                "GET",
+                f"/environments/{environment_id}/worker-queues"
+            )
+
+            queues = queues_response if isinstance(queues_response, list) else queues_response.get("queues", [])
+
+            total_workers = sum(q.get("active_workers", 0) for q in queues)
+            total_pending = sum(q.get("pending_tasks", 0) for q in queues)
+
+            output = [
+                f"Resource Availability for Environment: {env_response.get('name', 'Unknown')}",
+                f"  Status: {env_response.get('status', 'unknown')}",
+                f"  Worker Queues: {len(queues)}",
+                f"  Total Active Workers: {total_workers}",
+                f"  Total Pending Tasks: {total_pending}",
+                "",
+                "Queue Details:",
+            ]
+
+            for queue in queues:
+                output.append(
+                    f"  - {queue.get('name')}: "
+                    f"{queue.get('active_workers', 0)} workers, "
+                    f"{queue.get('pending_tasks', 0)} pending"
+                )
+
+            return "\n".join(output)
+
+        except Exception as e:
+            return f"Error checking resource availability: {str(e)}"
+
+    async def list_runtime_configurations(self) -> str:
+        """
+        List available runtime configurations
+
+        Returns:
+            Available runtime configurations including:
+            - Runtime types (docker, k8s, etc.)
+            - Resource templates
+            - Default configurations
+        """
+        try:
+            response = await self._make_request("GET", "/runtimes")
+
+            runtimes = response if isinstance(response, list) else response.get("runtimes", [])
+
+            return self._format_list_response(
+                items=runtimes,
+                title="Available Runtime Configurations",
+                key_fields=["type", "version", "resource_limits"],
+            )
+
+        except Exception as e:
+            return f"Error listing runtime configurations: {str(e)}"

control_plane_api/app/lib/planning_tools/resources.py

@@ -0,0 +1,240 @@
+"""
+Resources Context Tools - Fetch general resource and capability information
+"""
+
+from typing import Optional
+from control_plane_api.app.lib.planning_tools.base import BasePlanningTools
+
+
+class ResourcesContextTools(BasePlanningTools):
+    """
+    Tools for fetching general resource and capability context
+
+    Provides methods to:
+    - List available tools and skills
+    - Query project information
+    - Get integration capabilities
+    - Check system-wide resources
+    """
+
+    def __init__(self, base_url: str = "http://localhost:8000", organization_id: Optional[str] = None):
+        super().__init__(base_url=base_url, organization_id=organization_id)
+        self.name = "resources_context_tools"
+
+    async def list_available_skills(self) -> str:
+        """
+        List all available skills that agents can use
+
+        Returns:
+            Formatted list of skills including:
+            - Skill name and category
+            - Available tools within each skill
+            - Usage descriptions
+            - Cost implications
+        """
+        try:
+            response = await self._make_request("GET", "/skills")
+
+            skills = response if isinstance(response, list) else response.get("skills", [])
+
+            output = [f"Available Skills ({len(skills)} total):"]
+
+            for idx, skill in enumerate(skills, 1):
+                name = skill.get("name", "Unknown")
+                category = skill.get("category", "General")
+                tools = skill.get("tools", [])
+
+                output.append(f"\n{idx}. {name} (Category: {category})")
+                output.append(f"   Description: {skill.get('description', 'No description')}")
+
+                if tools:
+                    output.append(f"   Tools ({len(tools)}):")
+                    for tool in tools[:5]:  # Show first 5 tools
+                        tool_name = tool.get("name", "unknown")
+                        output.append(f"     - {tool_name}")
+                    if len(tools) > 5:
+                        output.append(f"     ... and {len(tools) - 5} more")
+
+            return "\n".join(output)
+
+        except Exception as e:
+            return f"Error listing skills: {str(e)}"
+
+    async def get_skill_details(self, skill_name: str) -> str:
+        """
+        Get detailed information about a specific skill
+
+        Args:
+            skill_name: Name of the skill to fetch
+
+        Returns:
+            Detailed skill information including all available tools
+        """
+        try:
+            response = await self._make_request("GET", f"/skills/{skill_name}")
+
+            return self._format_detail_response(
+                item=response,
+                title=f"Skill Details: {skill_name}",
+            )
+
+        except Exception as e:
+            return f"Error fetching skill {skill_name}: {str(e)}"
+
+    async def list_projects(self, limit: int = 50) -> str:
+        """
+        List all available projects
+
+        Args:
+            limit: Maximum number of projects to return
+
+        Returns:
+            List of projects with basic information
+        """
+        try:
+            params = {"limit": limit}
+            if self.organization_id:
+                params["organization_id"] = self.organization_id
+
+            response = await self._make_request("GET", "/projects", params=params)
+
+            projects = response if isinstance(response, list) else response.get("projects", [])
+
+            return self._format_list_response(
+                items=projects,
+                title="Available Projects",
+                key_fields=["description", "status", "owner"],
+            )
+
+        except Exception as e:
+            return f"Error listing projects: {str(e)}"
+
+    async def get_project_details(self, project_id: str) -> str:
+        """
+        Get detailed information about a specific project
+
+        Args:
+            project_id: ID of the project
+
+        Returns:
+            Detailed project information
+        """
+        try:
+            response = await self._make_request("GET", f"/projects/{project_id}")
+
+            return self._format_detail_response(
+                item=response,
+                title=f"Project Details: {response.get('name', 'Unknown')}",
+            )
+
+        except Exception as e:
+            return f"Error fetching project {project_id}: {str(e)}"
+
+    async def list_integrations(self) -> str:
+        """
+        List all available integrations
+
+        Returns:
+            List of available integrations (Slack, Jira, GitHub, AWS, etc.)
+        """
+        try:
+            response = await self._make_request("GET", "/integrations")
+
+            integrations = response if isinstance(response, list) else response.get("integrations", [])
+
+            return self._format_list_response(
+                items=integrations,
+                title="Available Integrations",
+                key_fields=["type", "status", "capabilities"],
+            )
+
+        except Exception as e:
+            return f"Error listing integrations: {str(e)}"
+
+    async def get_organization_info(self) -> str:
+        """
+        Get information about the current organization
+
+        Returns:
+            Organization information including:
+            - Resource limits
+            - Active agents/teams count
+            - Usage statistics
+        """
+        try:
+            if not self.organization_id:
+                return "Organization ID not provided"
+
+            response = await self._make_request("GET", f"/organizations/{self.organization_id}")
+
+            # Get additional statistics
+            agents = await self._make_request("GET", "/agents", params={"organization_id": self.organization_id})
+            teams = await self._make_request("GET", "/teams", params={"organization_id": self.organization_id})
+
+            agent_count = len(agents) if isinstance(agents, list) else agents.get("count", 0)
+            team_count = len(teams) if isinstance(teams, list) else teams.get("count", 0)
+
+            output = [
+                f"Organization: {response.get('name', 'Unknown')}",
+                f"  ID: {self.organization_id}",
+                f"  Status: {response.get('status', 'unknown')}",
+                f"  Active Agents: {agent_count}",
+                f"  Active Teams: {team_count}",
+            ]
+
+            if "resource_limits" in response:
+                output.append("\n  Resource Limits:")
+                for key, value in response["resource_limits"].items():
+                    output.append(f"    {key}: {value}")
+
+            return "\n".join(output)
+
+        except Exception as e:
+            return f"Error fetching organization info: {str(e)}"
+
+    async def search_tools_by_capability(self, capability: str) -> str:
+        """
+        Search for tools that provide a specific capability
+
+        Args:
+            capability: Capability to search for (e.g., "aws", "kubernetes", "database")
+
+        Returns:
+            List of tools/skills that provide the capability
+        """
+        try:
+            response = await self._make_request("GET", "/skills")
+            skills = response if isinstance(response, list) else response.get("skills", [])
+
+            matching_tools = []
+            for skill in skills:
+                skill_text = f"{skill.get('name', '')} {skill.get('description', '')}".lower()
+                tools = skill.get("tools", [])
+
+                if capability.lower() in skill_text:
+                    matching_tools.append({
+                        "name": skill.get("name"),
+                        "category": skill.get("category"),
+                        "description": skill.get("description"),
+                        "tool_count": len(tools),
+                    })
+                else:
+                    # Check individual tools
+                    for tool in tools:
+                        tool_text = f"{tool.get('name', '')} {tool.get('description', '')}".lower()
+                        if capability.lower() in tool_text:
+                            matching_tools.append({
+                                "name": f"{skill.get('name')}/{tool.get('name')}",
+                                "category": skill.get("category"),
+                                "description": tool.get("description"),
+                                "tool_count": 1,
+                            })
+
+            return self._format_list_response(
+                items=matching_tools,
+                title=f"Tools/Skills with '{capability}' capability",
+                key_fields=["category", "description"],
+            )
+
+        except Exception as e:
+            return f"Error searching tools: {str(e)}"

control_plane_api/app/lib/planning_tools/teams.py

@@ -0,0 +1,198 @@
+"""
+Team Context Tools - Fetch team information for task planning
+"""
+
+from typing import Optional
+from control_plane_api.app.lib.planning_tools.base import BasePlanningTools
+
+
+class TeamsContextTools(BasePlanningTools):
+    """
+    Tools for fetching team context and composition
+
+    Provides methods to:
+    - List all available teams
+    - Get detailed team information
+    - Query team member capabilities
+    - Check team availability
+    """
+
+    def __init__(self, base_url: str = "http://localhost:8000", organization_id: Optional[str] = None):
+        super().__init__(base_url=base_url, organization_id=organization_id)
+        self.name = "team_context_tools"
+
+    async def list_teams(self, limit: int = 50) -> str:
+        """
+        List all available teams with their basic information
+
+        Args:
+            limit: Maximum number of teams to return
+
+        Returns:
+            Formatted string with team information including:
+            - Team name and ID
+            - Number of agents
+            - Team description
+            - Agent composition
+        """
+        try:
+            params = {"limit": limit}
+            if self.organization_id:
+                params["organization_id"] = self.organization_id
+
+            response = await self._make_request("GET", "/teams", params=params)
+
+            teams = response if isinstance(response, list) else response.get("teams", [])
+
+            return self._format_list_response(
+                items=teams,
+                title="Available Teams",
+                key_fields=["description", "agent_count", "status"],
+            )
+
+        except Exception as e:
+            return f"Error listing teams: {str(e)}"
+
+    async def get_team_details(self, team_id: str) -> str:
+        """
+        Get detailed information about a specific team
+
+        Args:
+            team_id: ID of the team to fetch
+
+        Returns:
+            Detailed team information including:
+            - Full team configuration
+            - List of all team members with their roles
+            - Team capabilities (aggregate of member capabilities)
+            - Coordination strategy
+        """
+        try:
+            response = await self._make_request("GET", f"/teams/{team_id}")
+
+            team_name = response.get("name", "Unknown")
+            agents = response.get("agents", [])
+
+            output = [
+                f"Team Details: {team_name}",
+                f"  ID: {response.get('id')}",
+                f"  Description: {response.get('description', 'No description')}",
+                f"  Agent Count: {len(agents)}",
+                "",
+                "Team Members:",
+            ]
+
+            for idx, agent in enumerate(agents, 1):
+                output.append(f"  {idx}. {agent.get('name', 'Unnamed')} (ID: {agent.get('id')})")
+                if "model_id" in agent:
+                    output.append(f"     Model: {agent['model_id']}")
+                if "description" in agent:
+                    output.append(f"     Capabilities: {agent['description'][:100]}")
+
+            return "\n".join(output)
+
+        except Exception as e:
+            return f"Error fetching team {team_id}: {str(e)}"
+
+    async def get_team_members(self, team_id: str) -> str:
+        """
+        Get list of agents in a specific team
+
+        Args:
+            team_id: ID of the team
+
+        Returns:
+            List of team members with their capabilities
+        """
+        try:
+            response = await self._make_request("GET", f"/teams/{team_id}")
+
+            agents = response.get("agents", [])
+
+            if not agents:
+                return f"Team {team_id} has no members"
+
+            return self._format_list_response(
+                items=agents,
+                title=f"Team Members ({len(agents)} total)",
+                key_fields=["model_id", "description", "runner_name"],
+            )
+
+        except Exception as e:
+            return f"Error fetching team members: {str(e)}"
+
+    async def search_teams_by_capability(self, capability: str) -> str:
+        """
+        Search for teams that have agents with a specific capability
+
+        Args:
+            capability: Capability to search for (e.g., "devops", "security", "data")
+
+        Returns:
+            List of teams with members having the capability
+        """
+        try:
+            params = {}
+            if self.organization_id:
+                params["organization_id"] = self.organization_id
+
+            response = await self._make_request("GET", "/teams", params=params)
+            teams = response if isinstance(response, list) else response.get("teams", [])
+
+            matching_teams = []
+            for team in teams:
+                team_text = f"{team.get('name', '')} {team.get('description', '')}".lower()
+                agents = team.get("agents", [])
+                agent_text = " ".join([a.get("description", "") for a in agents]).lower()
+
+                if capability.lower() in team_text or capability.lower() in agent_text:
+                    matching_teams.append(team)
+
+            return self._format_list_response(
+                items=matching_teams,
+                title=f"Teams with '{capability}' capability",
+                key_fields=["description", "agent_count"],
+            )
+
+        except Exception as e:
+            return f"Error searching teams: {str(e)}"
+
+    async def get_team_execution_history(self, team_id: str, limit: int = 10) -> str:
+        """
+        Get recent execution history for a team
+
+        Args:
+            team_id: ID of the team
+            limit: Number of recent executions to fetch
+
+        Returns:
+            Recent execution history with success rates
+        """
+        try:
+            params = {"limit": limit, "entity_id": team_id, "execution_type": "team"}
+            response = await self._make_request("GET", "/executions", params=params)
+
+            executions = response if isinstance(response, list) else response.get("executions", [])
+
+            if not executions:
+                return f"No execution history found for team {team_id}"
+
+            completed = sum(1 for e in executions if e.get("status") == "completed")
+            total = len(executions)
+            success_rate = (completed / total * 100) if total > 0 else 0
+
+            output = [
+                f"Execution History for Team (Last {total} runs):",
+                f"Success Rate: {success_rate:.1f}% ({completed}/{total})",
+                "\nRecent Executions:",
+            ]
+
+            for idx, execution in enumerate(executions[:5], 1):
+                status = execution.get("status", "unknown")
+                prompt = execution.get("prompt", "No description")[:50]
+                output.append(f"{idx}. Status: {status} | Task: {prompt}...")
+
+            return "\n".join(output)
+
+        except Exception as e:
+            return f"Error fetching execution history: {str(e)}"