agentpool 2.1.9__py3-none-any.whl

agentpool_commands/connections.py

@@ -0,0 +1,175 @@
+"""Agent connection management commands."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.tree import Tree
+from slashed import CommandContext, CommandError  # noqa: TC002
+from slashed.completers import CallbackCompleter
+
+from agentpool.log import get_logger
+from agentpool.messaging import MessageNode
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_commands.completers import get_available_nodes
+
+
+logger = get_logger(__name__)
+
+
+def format_node_name(node: MessageNode[Any, Any], current: bool = False) -> str:
+    """Format node name for display."""
+    name = node.name
+    if current:
+        return f"► {name} (current)"
+    if node.connections.get_targets():
+        return f"● {name}"
+    return f"○ {name}"
+
+
+class ConnectCommand(NodeCommand):
+    """Connect the current node to another node.
+
+    Messages will be forwarded to the target node.
+
+    Examples:
+      /connect node2          # Forward to node, wait for responses
+      /connect node2 --no-wait  # Forward without waiting
+    """
+
+    name = "connect"
+    category = "nodes"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        node_name: str,
+        *,
+        wait: bool = True,
+    ) -> None:
+        """Connect to another node.
+
+        Args:
+            ctx: Command context
+            node_name: Name of the node to connect to
+            wait: Whether to wait for responses (default: True)
+        """
+        try:
+            assert ctx.context.pool
+            target_node = ctx.context.pool[node_name]
+            assert isinstance(target_node, MessageNode)
+            ctx.context.node.connect_to(target_node)
+            ctx.context.node.connections.set_wait_state(node_name, wait)
+            text = "*(waiting for responses)*" if wait else "*(async)*"
+            msg = f"🔗 **Connected:** `{ctx.context.node_name}` → `{node_name}` {text}"
+            await ctx.print(msg)
+        except Exception as e:
+            msg = f"Failed to connect {ctx.context.node_name!r} to {node_name!r}: {e}"
+            raise CommandError(msg) from e
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for node names."""
+        return CallbackCompleter(get_available_nodes)
+
+
+class DisconnectCommand(NodeCommand):
+    """Disconnect the current node from a target node.
+
+    Stops forwarding messages to the specified node.
+
+    Example: /disconnect node2
+    """
+
+    name = "disconnect"
+    category = "nodes"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        node_name: str,
+    ) -> None:
+        """Disconnect from another node.
+
+        Args:
+            ctx: Command context
+            node_name: Name of the node to disconnect from
+        """
+        source = ctx.context.node_name
+        try:
+            assert ctx.context.pool
+            target_node = ctx.context.pool[node_name]
+            assert isinstance(target_node, MessageNode)
+            ctx.context.node.connections.disconnect(target_node)
+            await ctx.print(f"🔌 **Disconnected:** `{source}` ⛔ `{node_name}`")
+        except Exception as e:
+            msg = f"{source!r} failed to disconnect from {node_name!r}: {e}"
+            raise CommandError(msg) from e
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for node names."""
+        return CallbackCompleter(get_available_nodes)
+
+
+class DisconnectAllCommand(NodeCommand):
+    """Disconnect from all nodes.
+
+    Remove all node connections.
+    """
+
+    name = "disconnect-all"
+    category = "nodes"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext]) -> None:
+        """Disconnect from all nodes.
+
+        Args:
+            ctx: Command context
+        """
+        if not ctx.context.node.connections.get_targets():
+            await ctx.print("ℹ️ **No active connections**")  # noqa: RUF001
+            return
+        source = ctx.context.node_name
+        await ctx.context.node.disconnect_all()
+        await ctx.print(f"🔌 **Disconnected** `{source}` from all nodes")
+
+
+class ListConnectionsCommand(NodeCommand):
+    """Show current node connections and their status.
+
+    Displays:
+    - Connected nodes
+    - Wait settings
+    - Message flow direction
+    """
+
+    name = "connections"
+    category = "nodes"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext]) -> None:
+        """List current connections.
+
+        Args:
+            ctx: Command context
+        """
+        if not ctx.context.node.connections.get_targets():
+            await ctx.print("ℹ️ **No active connections**")  # noqa: RUF001
+            return
+
+        # Create tree visualization
+        tree = Tree(format_node_name(ctx.context.node, current=True))
+
+        # Use session's get_connections() for info
+        for node in ctx.context.node.connections.get_targets():
+            assert ctx.context.pool
+            name = format_node_name(ctx.context.pool[node.name])
+            _branch = tree.add(name)
+
+        # Create string representation
+        from rich.console import Console
+
+        console = Console()
+        with console.capture() as capture:
+            console.print(tree)
+        tree_str = capture.get()
+        await ctx.print(f"\n## 🌳 Connection Tree\n\n```\n{tree_str}\n```")

agentpool_commands/markdown_utils.py

@@ -0,0 +1,31 @@
+"""Markdown formatting utilities for command output."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def format_table(headers: list[str], rows: list[dict[str, Any]]) -> str:
+    """Format data as a markdown table.
+
+    Args:
+        headers: Column headers
+        rows: List of dicts with keys matching headers
+
+    Returns:
+        Markdown table string
+    """
+    if not rows:
+        return ""
+
+    # Create header row
+    header_row = "| " + " | ".join(headers) + " |"
+    separator_row = "|" + "|".join("---" for _ in headers) + "|"
+
+    # Create data rows
+    data_rows = []
+    for row in rows:
+        values = [str(row.get(header, "")) for header in headers]
+        data_rows.append("| " + " | ".join(values) + " |")
+
+    return "\n".join([header_row, separator_row, *data_rows])

agentpool_commands/models.py

@@ -0,0 +1,62 @@
+"""Model-related commands."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from slashed import CommandContext  # noqa: TC002
+from slashed.completers import CallbackCompleter
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_commands.completers import get_model_names
+
+
+if TYPE_CHECKING:
+    from agentpool.messaging import MessageNode
+
+
+class SetModelCommand(NodeCommand):
+    """Change the language model for the current conversation.
+
+    The model change takes effect immediately for all following messages.
+    Previous messages and their context are preserved.
+
+    Examples:
+      /set-model gpt-5
+      /set-model openai:gpt-5-mini
+      /set-model claude-2
+
+    Note: Available models depend on your configuration and API access.
+    """
+
+    name = "set-model"
+    category = "model"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        model: str,
+    ) -> None:
+        """Change the model for the current conversation.
+
+        Args:
+            ctx: Command context
+            model: Model name to switch to
+        """
+        try:
+            # Create new session with model override
+            ctx.context.native_agent.set_model(model)
+            await ctx.print(f"✅ **Model changed to:** `{model}`")
+        except Exception as e:  # noqa: BLE001
+            await ctx.print(f"❌ **Failed to change model:** {e}")
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for model names."""
+        return CallbackCompleter(get_model_names)
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        from agentpool import Agent
+
+        return isinstance(node, Agent)

agentpool_commands/prompts.py

@@ -0,0 +1,78 @@
+"""Prompt slash commands."""
+
+from __future__ import annotations
+
+from slashed import CommandContext, CommandError  # noqa: TC002
+
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_commands.completers import PromptCompleter
+
+
+class ShowPromptCommand(NodeCommand):
+    """Show prompts from configured prompt hubs.
+
+    Usage examples:
+      /prompt role.reviewer            # Use builtin prompt
+      /prompt langfuse:explain@v2     # Use specific version
+      /prompt some_prompt[var=value]  # With variables
+    """
+
+    name = "prompt"
+    category = "prompts"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext], identifier: str) -> None:
+        """Show prompt content.
+
+        Args:
+            ctx: Command context
+            identifier: Prompt identifier ([provider:]name[@version][?var=val])
+        """
+        try:
+            prompt = await ctx.context.prompt_manager.get(identifier)
+            await ctx.print(f"## 📝 Prompt Content\n\n```\n{prompt}\n```")
+        except Exception as e:
+            msg = f"Error getting prompt: {e}"
+            raise CommandError(msg) from e
+
+    def get_completer(self) -> PromptCompleter:
+        """Get completer for prompt names."""
+        return PromptCompleter()
+
+
+class ListPromptsCommand(NodeCommand):
+    """List available prompts from all providers.
+
+    Show all prompts available in the current configuration.
+    Each prompt is shown with its name and description.
+    """
+
+    name = "list-prompts"
+    category = "prompts"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext]) -> None:
+        """List available prompts from all providers.
+
+        Args:
+            ctx: Command context
+        """
+        prompts = await ctx.context.prompt_manager.list_prompts()
+        output_lines = ["\n## 📝 Available Prompts\n"]
+
+        for provider, provider_prompts in prompts.items():
+            if not provider_prompts:
+                continue
+
+            output_lines.append(f"\n### {provider.title()}\n")
+            sorted_prompts = sorted(provider_prompts)
+
+            # For builtin prompts we can show their description
+            if provider == "builtin":
+                for prompt_name in sorted_prompts:
+                    prompt = ctx.context.definition.prompts.system_prompts[prompt_name]
+                    desc = f" - *{prompt.category}*" if prompt.category else ""
+                    output_lines.append(f"- **{prompt_name}**{desc}")
+            else:
+                # For other providers, just show names
+                output_lines.extend(f"- `{prompt_name}`" for prompt_name in sorted_prompts)
+        await ctx.print("\n".join(output_lines))

agentpool_commands/read.py

@@ -0,0 +1,77 @@
+"""Command for reading file content into conversations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from slashed import CommandContext, CommandError  # noqa: TC002
+from slashed.completers import PathCompleter
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.log import get_logger
+from agentpool_commands.base import NodeCommand
+
+
+if TYPE_CHECKING:
+    from agentpool.messaging import MessageNode
+
+logger = get_logger(__name__)
+
+
+class ReadCommand(NodeCommand):
+    """Read content from files or URLs into the conversation.
+
+    By default reads raw content, but can convert supported formats to markdown
+    with the --convert-to-md flag.
+
+    Supported formats for conversion:
+    - PDF documents
+    - Office files (Word, Excel, PowerPoint)
+    - Images (with metadata)
+    - Audio files (metadata)
+    - HTML pages
+    - Text formats (CSV, JSON, XML)
+
+    Examples:
+      /read document.txt               # Read raw text
+      /read document.pdf --convert-to-md   # Convert PDF to markdown
+      /read https://example.com/doc.docx --convert-to-md
+      /read presentation.pptx --convert-to-md
+    """
+
+    name = "read"
+    category = "content"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        path: str,
+        *,
+        convert_to_md: bool = False,
+    ) -> None:
+        """Read file content into conversation.
+
+        Args:
+            ctx: Command context
+            path: Path or URL to read
+            convert_to_md: Whether to convert to markdown format
+        """
+        try:
+            agent = ctx.context.agent
+            await agent.conversation.add_context_from_path(path, convert_to_md=convert_to_md)
+            await ctx.print(f"📄 **Added content from** {path!r} **to next message as context**")
+        except Exception as e:
+            msg = f"Unexpected error reading {path}: {e}"
+            logger.exception(msg)
+            raise CommandError(msg) from e
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        """Only available for Agent nodes."""
+        from agentpool import Agent
+
+        return isinstance(node, Agent)
+
+    def get_completer(self) -> PathCompleter:
+        """Get completer for file paths."""
+        return PathCompleter()

agentpool_commands/resources.py

@@ -0,0 +1,210 @@
+"""Resource management commands."""
+
+from __future__ import annotations
+
+from slashed import CommandContext, CommandError  # noqa: TC002
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.log import get_logger
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import AgentCommand, NodeCommand
+from agentpool_commands.markdown_utils import format_table
+
+
+logger = get_logger(__name__)
+
+
+class ListResourcesCommand(NodeCommand):
+    """Display all resources available to the agent.
+
+    Shows:
+    - Resource names and descriptions
+    - Resource types and URIs
+    - Whether parameters are supported
+    - MIME types
+
+    Resource types can be:
+    - path: Files or URLs
+    - text: Raw text content
+    - cli: Command line tools
+    - source: Python source code
+    - callable: Python functions
+    - image: Image files
+
+    Use /show-resource for detailed information about specific resources.
+    """
+
+    name = "list-resources"
+    category = "resources"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext]) -> None:
+        """List available resources.
+
+        Args:
+            ctx: Command context
+        """
+        try:
+            fs = ctx.context.definition.vfs_registry.get_fs()
+            root = await fs._ls("/", detail=True)
+
+            rows = []
+            for entry in root:
+                protocol = entry["name"].removesuffix("://")
+                info = await fs._info(f"{protocol}://")
+
+                rows.append({
+                    "Resource": protocol,
+                    "Type": info.get("type", "unknown"),
+                    "URI": info.get("uri", ""),
+                    "Description": info.get("description", ""),
+                })
+
+            headers = ["Resource", "Type", "URI", "Description"]
+            table = format_table(headers, rows)
+            await ctx.print(f"## 📁 Available Resources\n\n{table}")
+        except Exception as e:  # noqa: BLE001
+            await ctx.print(f"❌ **Failed to list resources:** {e}")
+
+
+class ShowResourceCommand(NodeCommand):
+    """Display detailed information and content of a specific resource.
+
+    Shows:
+    - Resource metadata (type, URI, description)
+    - MIME type information
+    - Parameter support status
+    - Resource content (if loadable)
+
+    For resources that support parameters:
+    - Pass parameters as --param arguments
+    - Parameters are passed to resource loader
+
+    Examples:
+      /show-resource config.yml               # Show configuration file
+      /show-resource template --date today    # Template with parameters
+      /show-resource image.png               # Show image details
+      /show-resource api --key value         # API with parameters
+
+    Note: Some resources might require parameters to be viewed.
+    """
+
+    name = "show-resource"
+    category = "resources"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        name: str,
+        **kwargs: str,
+    ) -> None:
+        """Show details or content of a resource.
+
+        Args:
+            ctx: Command context
+            name: Resource name to show
+            **kwargs: Additional parameters for the resource
+        """
+        try:
+            fs = ctx.context.definition.vfs_registry.get_fs()
+
+            # Get resource info
+            try:
+                info = await fs._info(f"{name}://")
+            except Exception as e:  # noqa: BLE001
+                await ctx.print(f"❌ **Resource** `{name}` **not found:** {e}")
+                return
+
+            sections = [f"## 📁 Resource: {name}\n"]
+            if typ := info.get("type"):
+                sections.append(f"**Type:** `{typ}`")
+            if uri := info.get("uri"):
+                sections.append(f"**URI:** `{uri}`")
+            if desc := info.get("description"):
+                sections.append(f"Description: {desc}")
+            if mime := info.get("mime_type"):
+                sections.append(f"MIME Type: {mime}")
+
+            # Try to list contents
+            try:
+                listing = await fs._ls(f"{name}://", detail=False)
+                if listing:
+                    sections.extend(["\n# Contents:", "```", *listing, "```"])
+            except Exception as e:  # noqa: BLE001
+                sections.append(f"\nFailed to list contents: {e}")
+
+            await ctx.print("\n".join(sections))
+        except Exception as e:  # noqa: BLE001
+            await ctx.print(f"❌ **Error accessing resource:** {e}")
+
+
+class AddResourceCommand(AgentCommand):
+    """Add content from a resource to the next message.
+
+    Parameters are passed to the resource loader if supported.
+
+    Examples:
+    /add-resource config.yml
+    /add-resource template --date today
+    /add-resource api_data --key value
+    """
+
+    name = "add-resource"
+    category = "resources"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        resource_path: str,
+        *,
+        pattern: str | None = None,
+        **kwargs: str,
+    ) -> None:
+        """Add resource content as context for the next message.
+
+        Args:
+            ctx: Command context
+            resource_path: Resource name or resource/path
+            pattern: Pattern for filtering files
+            **kwargs: Additional parameters for the resource
+        """
+        try:
+            # Parse resource name and path
+            parts = resource_path.split("/", 1)
+            resource_name = parts[0]
+            path = parts[1] if len(parts) > 1 else ""
+
+            registry = ctx.context.definition.vfs_registry
+
+            if path:
+                if "*" in path:
+                    # It's a pattern - use query
+                    files = await registry.query(resource_name, pattern=path)
+                    for file in files:
+                        content = await registry.get_content(resource_name, file)
+                        ctx.context.agent.conversation.add_context_message(
+                            content, source=f"{resource_name}/{file}", **kwargs
+                        )
+                    msg = f"Added {len(files)} files from {resource_name!r} matching {path!r}"
+                else:
+                    # Specific file
+                    content = await registry.get_content(resource_name, path)
+                    ctx.context.agent.conversation.add_context_message(
+                        content, source=f"{resource_name}/{path}", **kwargs
+                    )
+                    msg = f"Added '{resource_name}/{path}' to context"
+            else:
+                # Add all content from resource root
+                files = await registry.query(resource_name, pattern=pattern or "**/*")
+                for file in files:
+                    content = await registry.get_content(resource_name, file)
+                    ctx.context.agent.conversation.add_context_message(
+                        content, source=f"{resource_name}/{file}", **kwargs
+                    )
+                msg = f"✅ **Added {len(files)} files from** `{resource_name}`"
+
+            await ctx.print(msg)
+
+        except Exception as e:
+            msg = f"Error loading resource: {e}"
+            logger.exception(msg)
+            raise CommandError(msg) from e

agentpool_commands/session.py

@@ -0,0 +1,48 @@
+"""Agent session slash commands."""
+
+from __future__ import annotations
+
+from slashed import CommandContext  # noqa: TC002
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool_commands.base import AgentCommand
+
+
+class ClearCommand(AgentCommand):
+    """Clear the current chat session history.
+
+    This removes all previous messages but keeps tools and settings.
+    """
+
+    name = "clear"
+    category = "session"
+
+    async def execute_command(self, ctx: CommandContext[AgentContext]) -> None:
+        """Clear chat history.
+
+        Args:
+            ctx: Command context
+        """
+        ctx.context.agent.conversation.clear()
+        await ctx.print("🧹 **Chat history cleared**")
+
+
+class ResetCommand(AgentCommand):
+    """Reset the entire session state.
+
+    - Clears chat history
+    - Restores default tool settings
+    - Resets any session-specific configurations
+    """
+
+    name = "reset"
+    category = "session"
+
+    async def execute_command(self, ctx: CommandContext[AgentContext]) -> None:
+        """Reset session state.
+
+        Args:
+            ctx: Command context
+        """
+        await ctx.context.native_agent.reset()
+        await ctx.print("🔄 **Session state reset** - history cleared, tools and settings restored")