agentpool 2.1.9__py3-none-any.whl

agentpool_commands/__init__.py

@@ -0,0 +1,180 @@
+"""Built-in commands for AgentPool."""
+
+from __future__ import annotations
+
+from agentpool_commands.base import NodeCommand
+from agentpool_commands.agents import (
+    CreateAgentCommand,
+    ListAgentsCommand,
+    ShowAgentCommand,
+    # SwitchAgentCommand,
+)
+from agentpool_commands.connections import (
+    ConnectCommand,
+    DisconnectCommand,
+    ListConnectionsCommand,
+    DisconnectAllCommand,
+)
+from agentpool_commands.models import SetModelCommand
+from agentpool_commands.prompts import ListPromptsCommand, ShowPromptCommand
+from agentpool_commands.resources import (
+    ListResourcesCommand,
+    ShowResourceCommand,
+    AddResourceCommand,
+)
+from agentpool_commands.session import ClearCommand, ResetCommand
+from agentpool_commands.read import ReadCommand
+from agentpool_commands.tools import (
+    DisableToolCommand,
+    EnableToolCommand,
+    ListToolsCommand,
+    RegisterToolCommand,
+    ShowToolCommand,
+)
+from agentpool_commands.workers import (
+    AddWorkerCommand,
+    RemoveWorkerCommand,
+    ListWorkersCommand,
+)
+from agentpool_commands.utils import (
+    CopyClipboardCommand,
+    EditAgentFileCommand,
+    ShareHistoryCommand,
+)
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from slashed import BaseCommand, SlashedCommand
+
+    from agentpool.messaging import MessageNode
+
+
+def get_agent_commands(**kwargs: Any) -> Sequence[BaseCommand | type[SlashedCommand]]:
+    """Get commands that operate primarily on a single agent."""
+    command_map = {
+        "enable_clear": ClearCommand,
+        "enable_reset": ResetCommand,
+        "enable_copy_clipboard": CopyClipboardCommand,
+        "enable_share_history": ShareHistoryCommand,
+        "enable_set_model": SetModelCommand,
+        "enable_list_tools": ListToolsCommand,
+        "enable_show_tool": ShowToolCommand,
+        "enable_enable_tool": EnableToolCommand,
+        "enable_disable_tool": DisableToolCommand,
+        "enable_register_tool": RegisterToolCommand,
+        "enable_list_resources": ListResourcesCommand,
+        "enable_show_resource": ShowResourceCommand,
+        "enable_add_resource": AddResourceCommand,
+        "enable_list_prompts": ListPromptsCommand,
+        "enable_show_prompt": ShowPromptCommand,
+        "enable_add_worker": AddWorkerCommand,
+        "enable_remove_worker": RemoveWorkerCommand,
+        "enable_list_workers": ListWorkersCommand,
+        "enable_connect": ConnectCommand,
+        "enable_disconnect": DisconnectCommand,
+        "enable_list_connections": ListConnectionsCommand,
+        "enable_disconnect_all": DisconnectAllCommand,
+        "enable_read": ReadCommand,
+    }
+    return [command for flag, command in command_map.items() if kwargs.get(flag, True)]
+
+
+def get_pool_commands(**kwargs: Any) -> Sequence[BaseCommand | type[SlashedCommand]]:
+    """Get commands that operate on multiple agents or the pool itself."""
+    command_map = {
+        "enable_create_agent": CreateAgentCommand,
+        "enable_list_agents": ListAgentsCommand,
+        "enable_show_agent": ShowAgentCommand,
+        "enable_edit_agent_file": EditAgentFileCommand,
+    }
+    return [command for flag, command in command_map.items() if kwargs.get(flag, True)]
+
+
+def filter_commands_for_node(
+    commands: Sequence[BaseCommand | type[SlashedCommand]],
+    node: MessageNode[Any, Any],
+) -> list[BaseCommand | type[SlashedCommand]]:
+    """Filter commands to those supporting the given node type.
+
+    Args:
+        commands: Commands to filter
+        node: The node to check compatibility with
+    """
+    result: list[BaseCommand | type[SlashedCommand]] = []
+    for cmd in commands:
+        cmd_cls = cmd if isinstance(cmd, type) else type(cmd)
+        if issubclass(cmd_cls, NodeCommand) and not cmd_cls.supports_node(node):
+            continue
+        result.append(cmd)
+    return result
+
+
+def get_commands(
+    *,
+    enable_clear: bool = True,
+    enable_reset: bool = True,
+    enable_copy_clipboard: bool = True,
+    enable_share_history: bool = True,
+    enable_set_model: bool = True,
+    enable_list_tools: bool = True,
+    enable_show_tool: bool = True,
+    enable_enable_tool: bool = True,
+    enable_disable_tool: bool = True,
+    enable_register_tool: bool = True,
+    enable_list_resources: bool = True,
+    enable_show_resource: bool = True,
+    enable_add_resource: bool = True,
+    enable_list_prompts: bool = True,
+    enable_show_prompt: bool = True,
+    enable_add_worker: bool = True,
+    enable_remove_worker: bool = True,
+    enable_list_workers: bool = True,
+    enable_connect: bool = True,
+    enable_disconnect: bool = True,
+    enable_list_connections: bool = True,
+    enable_disconnect_all: bool = True,
+    enable_read: bool = True,
+    enable_create_agent: bool = True,
+    enable_list_agents: bool = True,
+    enable_show_agent: bool = True,
+    enable_edit_agent_file: bool = True,
+) -> list[BaseCommand | type[SlashedCommand]]:
+    """Get all built-in commands."""
+    agent_kwargs = {
+        "enable_clear": enable_clear,
+        "enable_reset": enable_reset,
+        "enable_copy_clipboard": enable_copy_clipboard,
+        "enable_share_history": enable_share_history,
+        "enable_set_model": enable_set_model,
+        "enable_list_tools": enable_list_tools,
+        "enable_show_tool": enable_show_tool,
+        "enable_enable_tool": enable_enable_tool,
+        "enable_disable_tool": enable_disable_tool,
+        "enable_register_tool": enable_register_tool,
+        "enable_list_resources": enable_list_resources,
+        "enable_show_resource": enable_show_resource,
+        "enable_add_resource": enable_add_resource,
+        "enable_list_prompts": enable_list_prompts,
+        "enable_show_prompt": enable_show_prompt,
+        "enable_add_worker": enable_add_worker,
+        "enable_remove_worker": enable_remove_worker,
+        "enable_list_workers": enable_list_workers,
+        "enable_connect": enable_connect,
+        "enable_disconnect": enable_disconnect,
+        "enable_list_connections": enable_list_connections,
+        "enable_disconnect_all": enable_disconnect_all,
+        "enable_read": enable_read,
+    }
+    pool_kwargs = {
+        "enable_create_agent": enable_create_agent,
+        "enable_list_agents": enable_list_agents,
+        "enable_show_agent": enable_show_agent,
+        "enable_edit_agent_file": enable_edit_agent_file,
+    }
+
+    return [
+        *get_agent_commands(**agent_kwargs),
+        *get_pool_commands(**pool_kwargs),
+    ]

agentpool_commands/agents.py

@@ -0,0 +1,199 @@
+"""Agent management commands."""
+
+from __future__ import annotations
+
+from slashed import CommandContext, CommandError  # noqa: TC002
+from slashed.completers import CallbackCompleter
+
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_commands.completers import get_available_agents
+from agentpool_commands.markdown_utils import format_table
+
+
+class CreateAgentCommand(NodeCommand):
+    """Create a new agent in the current session.
+
+    Creates a temporary agent that inherits the current agent's model.
+    The new agent will exist only for this session.
+
+    Options:
+      --system-prompt "prompt"   System instructions for the agent (required)
+      --model model_name        Override model (default: same as current agent)
+      --role role_name         Agent role (assistant/specialist/overseer)
+      --description "text"     Optional description of the agent
+      --tools "import_path1|import_path2"   Optional list tools (by import path)
+
+    Examples:
+      # Create poet using same model as current agent
+      /create-agent poet --system-prompt "Create poems from any text"
+
+      # Create analyzer with different model
+      /create-agent analyzer --system-prompt "Analyze in detail" --model gpt-5
+
+      # Create specialized helper
+      /create-agent helper --system-prompt "Debug code" --role specialist
+    """
+
+    name = "create-agent"
+    category = "agents"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        agent_name: str,
+        system_prompt: str = "",
+        *,
+        model: str | None = None,
+        role: str | None = None,
+        description: str | None = None,
+        tools: str | None = None,
+    ) -> None:
+        """Create a new agent in the current session.
+
+        Args:
+            ctx: Command context
+            agent_name: Name for the new agent
+            system_prompt: System instructions for the agent
+            model: Override model (default: same as current agent)
+            role: Agent role (assistant/specialist/overseer)
+            description: Optional description of the agent
+            tools: Optional pipe-separated list of tools (by import path)
+        """
+        try:
+            if not ctx.context.pool:
+                msg = "No agent pool available"
+                raise CommandError(msg)
+
+            # Get model from args or current agent
+            current_agent = ctx.context.agent
+            tool_list = [t.strip() for t in tools.split("|")] if tools else None
+            # Create and register the new agent
+            await ctx.context.pool.add_agent(
+                name=agent_name,
+                model=model or current_agent.model_name,
+                system_prompt=system_prompt or (),
+                description=description,
+                tools=tool_list,
+            )
+
+            msg = f"✅ **Created agent** `{agent_name}`"
+            if tool_list:
+                msg += f" with tools: `{', '.join(tool_list)}`"
+            await ctx.print(f"{msg}\n\n💡 Use `/connect {agent_name}` to forward messages")
+
+        except ValueError as e:
+            msg = f"Failed to create agent: {e}"
+            raise CommandError(msg) from e
+
+
+class ShowAgentCommand(NodeCommand):
+    """Display the complete configuration of the current agent as YAML.
+
+    Shows:
+    - Basic agent settings
+    - Model configuration (with override indicators)
+    - Environment settings (including inline environments)
+    - System prompts
+    - Response type configuration
+    - Other settings
+
+    Fields that have been overridden at runtime are marked with comments.
+    """
+
+    name = "show-agent"
+    category = "agents"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext]) -> None:
+        """Show current agent's configuration.
+
+        Args:
+            ctx: Command context
+        """
+        import yamling
+
+        node_ctx = ctx.context.node.get_context()
+        config = node_ctx.config
+        config_dict = config.model_dump(exclude_none=True)  # Get base config as dict
+        # Format as annotated YAML
+        yaml_config = yamling.dump_yaml(
+            config_dict,
+            sort_keys=False,
+            indent=2,
+            default_flow_style=False,
+            allow_unicode=True,
+        )
+        # Add header and format for display
+        sections = ["\n**Current Node Configuration:**", "```yaml", yaml_config, "```"]
+        await ctx.print("\n".join(sections))
+
+
+class ListAgentsCommand(NodeCommand):
+    """Show all agents defined in the current configuration.
+
+    Displays:
+    - Agent name
+    - Model used (if specified)
+    - Description (if available)
+    """
+
+    name = "list-agents"
+    category = "agents"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext]) -> None:
+        """List all available agents.
+
+        Args:
+            ctx: Command context
+        """
+        if not ctx.context.pool:
+            msg = "No agent pool available"
+            raise CommandError(msg)
+
+        rows = []
+        for name, agent in ctx.context.pool.agents.items():
+            typ = "dynamic" if name not in ctx.context.definition.agents else "static"
+            rows.append({
+                "Name": name,
+                "Model": str(agent.model_name or ""),
+                "Type": f"agent ({typ})",
+                "Description": agent.description or "",
+            })
+
+        for name, acp_agent in ctx.context.pool.acp_agents.items():
+            rows.append({
+                "Name": name,
+                "Model": str(acp_agent.model_name or ""),
+                "Type": "acp_agent",
+                "Description": acp_agent.description or "",
+            })
+
+        headers = ["Name", "Model", "Type", "Description"]
+        table = format_table(headers, rows)
+        await ctx.print(f"## 🤖 Available Agents\n\n{table}")
+
+
+class SwitchAgentCommand(NodeCommand):
+    """Switch the current chat session to a different agent.
+
+    Use /list-agents to see available agents.
+
+    Example: /switch-agent url_opener
+    """
+
+    name = "switch-agent"
+    category = "agents"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext], agent_name: str) -> None:
+        """Switch to a different agent.
+
+        Args:
+            ctx: Command context
+            agent_name: Name of the agent to switch to
+        """
+        msg = "Temporarily disabled"
+        raise RuntimeError(msg)
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for agent names."""
+        return CallbackCompleter(get_available_agents)

agentpool_commands/base.py

@@ -0,0 +1,45 @@
+"""Base command class with node-type filtering support."""
+
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING, Any
+
+from slashed import SlashedCommand
+
+
+if TYPE_CHECKING:
+    from agentpool.messaging import MessageNode
+
+
+class NodeCommand(SlashedCommand, ABC):
+    """Base class for commands with node-type filtering.
+
+    Commands inheriting from this can override `supports_node` to restrict
+    which node types they're available for.
+    """
+
+    name: str = ""  # Placeholder, must be overridden by concrete subclasses
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        """Check if this command supports the given node type.
+
+        Override in subclasses to restrict to specific node types.
+        Default implementation returns True (supports all nodes).
+
+        Args:
+            node: The node to check compatibility with
+        """
+        return True
+
+
+class AgentCommand(NodeCommand):
+    """Base class for commands that only work with Agent nodes."""
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        """Check if node is an Agent."""
+        from agentpool import Agent
+
+        return isinstance(node, Agent)

agentpool_commands/commands.py

@@ -0,0 +1,58 @@
+"""Slashed command to list nodes."""
+
+from __future__ import annotations
+
+from slashed import CommandContext  # noqa: TC002
+
+from agentpool.log import get_logger
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_commands.markdown_utils import format_table
+
+
+logger = get_logger(__name__)
+
+
+class ListNodesCommand(NodeCommand):
+    """List all nodes in the pool with their status."""
+
+    name = "list-nodes"
+    category = "pool"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        show_connections: bool = False,
+    ) -> None:
+        """List all nodes and their current status.
+
+        Args:
+            ctx: Command context with node
+            show_connections: Whether to show node connections
+        """
+        node = ctx.get_data()
+        assert node.pool
+
+        rows = []
+        for name, node_ in node.pool.nodes.items():
+            # Status check
+            status = "🔄 busy" if node_.task_manager.is_busy() else "⏳ idle"
+
+            # Add connections if requested
+            connections = []
+            if show_connections and node_.connections.get_targets():
+                connections = [a.name for a in node_.connections.get_targets()]
+                conn_str = f"→ {', '.join(connections)}"
+            else:
+                conn_str = ""
+
+            rows.append({
+                "Node": name,
+                "Status": status,
+                "Connections": conn_str,
+                "Description": node_.description or "",
+            })
+
+        headers = ["Node", "Status", "Connections", "Description"]
+        table = format_table(headers, rows)
+        await ctx.print(f"## 🔗 Available Nodes\n\n{table}")

agentpool_commands/completers.py

@@ -0,0 +1,110 @@
+"""Command completion providers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal, get_args
+
+from slashed import CompletionItem, CompletionProvider
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
+    from slashed import CompletionContext
+
+
+def get_available_agents(
+    ctx: CompletionContext[AgentContext[Any]],
+    agent_type: Literal["all", "regular", "acp"] = "all",
+) -> list[str]:
+    """Get available agent names.
+
+    Args:
+        ctx: Completion context
+        agent_type: Filter by agent type ("all", "regular", or "acp")
+    """
+    if not ctx.command_context.context.pool:
+        return []
+    pool = ctx.command_context.context.pool
+    match agent_type:
+        case "all":
+            return list(pool.all_agents.keys())
+        case "regular":
+            return list(pool.agents.keys())
+        case "acp":
+            return list(pool.acp_agents.keys())
+
+
+def get_available_nodes(ctx: CompletionContext[NodeContext[Any]]) -> list[str]:
+    """Get available node names."""
+    if not ctx.command_context.context.pool:
+        return []
+    return list(ctx.command_context.context.pool.nodes.keys())
+
+
+def get_model_names(ctx: CompletionContext[AgentContext[Any]]) -> list[str]:
+    """Get available model names from pydantic-ai and current configuration.
+
+    Returns:
+    - All models from KnownModelName literal type
+    - Plus any additional models from current configuration
+    """
+    # Get models directly from the Literal type
+    from llmling_models import AllModels
+    from tokonomics.model_names import ModelId
+
+    known_models = list(get_args(ModelId)) + list(get_args(AllModels))
+
+    agent = ctx.command_context.context.agent
+    agent_ctx = agent.get_context()
+    if not agent_ctx.definition:
+        return known_models
+
+    # Add any additional models from the current configuration (only native agents have model)
+    agents = agent_ctx.definition.native_agents
+    config_models = {str(a.model) for a in agents.values() if a.model is not None}
+
+    # Combine both sources, keeping order (known models first)
+    all_models = known_models[:]
+    all_models.extend(model for model in config_models if model not in all_models)
+    return all_models
+
+
+class PromptCompleter(CompletionProvider):
+    """Completer for prompts."""
+
+    async def get_completions(
+        self, ctx: CompletionContext[AgentContext[Any]]
+    ) -> AsyncIterator[CompletionItem]:
+        """Complete prompt references."""
+        current = ctx.current_word
+        manifest = ctx.command_context.context.definition
+
+        # If no : yet, suggest providers
+        if ":" not in current:
+            # Always suggest builtin prompts without prefix
+            for name in manifest.prompts.system_prompts:
+                if not name.startswith(current):
+                    continue
+                yield CompletionItem(name, metadata="Builtin prompt", kind="choice")
+
+            # Suggest provider prefixes
+            for provider in manifest.prompts.providers or []:
+                prefix = f"{provider.type}:"
+                if not prefix.startswith(current):
+                    continue
+                yield CompletionItem(prefix, metadata="Prompt provider", kind="choice")
+            return
+
+        # If after provider:, get prompts from that provider
+        provider_, partial = current.split(":", 1)
+        if provider_ == "builtin" or not provider_:
+            # Complete from system prompts
+            for name in manifest.prompts.system_prompts:
+                if not name.startswith(partial):
+                    continue
+                text = f"{provider_}:{name}" if provider_ else name
+                yield CompletionItem(text=text, metadata="Builtin prompt", kind="choice")