agentpool 2.1.9__py3-none-any.whl

agentpool_commands/tools.py

@@ -0,0 +1,269 @@
+"""Tool management commands."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from slashed import CommandContext, CommandError, CompletionContext  # noqa: TC002
+from slashed.completers import CallbackCompleter
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.log import get_logger
+from agentpool.utils.importing import import_callable
+from agentpool_commands.base import NodeCommand
+from agentpool_commands.markdown_utils import format_table
+
+
+if TYPE_CHECKING:
+    from agentpool.messaging import MessageNode
+
+
+logger = get_logger(__name__)
+
+
+class ListToolsCommand(NodeCommand):
+    """Show all available tools and their current status.
+
+    Tools are grouped by source (runtime/agent/builtin).
+    ✓ indicates enabled, ✗ indicates disabled.
+    """
+
+    name = "list-tools"
+    category = "tools"
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        from agentpool import Agent
+
+        return isinstance(node, Agent)
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        source: str | None = None,
+    ) -> None:
+        """List all available tools.
+
+        Args:
+            ctx: Command context
+            source: Optional filter by source (runtime/agent/builtin)
+        """
+        agent = ctx.context.agent
+
+        rows = [
+            {
+                "Status": "✅" if tool_info.enabled else "❌",
+                "Name": tool_info.name,
+                "Source": tool_info.source,
+            }
+            for tool_info in await agent.tools.get_tools()
+            if not source or tool_info.source == source
+        ]
+
+        headers = ["Status", "Name", "Source"]
+        table = format_table(headers, rows)
+        await ctx.print(f"## 🔧 Available Tools\n\n{table}")
+
+
+class ShowToolCommand(NodeCommand):
+    """Display detailed information about a specific tool.
+
+    Shows:
+    - Source (runtime/agent/builtin)
+    - Current status (enabled/disabled)
+    - Parameter descriptions
+    - Additional metadata
+
+    Example: /tool-info open_browser
+    """
+
+    name = "show-tool"
+    category = "tools"
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        from agentpool import Agent
+
+        return isinstance(node, Agent)
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        name: str,
+    ) -> None:
+        """Show detailed information about a tool.
+
+        Args:
+            ctx: Command context
+            name: Tool name to show
+        """
+        agent = ctx.context.agent
+
+        try:
+            tool_info = await agent.tools.get_tool(name)
+            # Start with the standard tool info format
+            sections = [tool_info.format_info(indent="")]
+
+            # Add extra metadata section if we have any additional info
+            extra_info = []
+            if tool_info.requires_confirmation:
+                extra_info.append("Requires Confirmation: Yes")
+            if tool_info.source != "dynamic":  # Only show if not default
+                extra_info.append(f"Source: {tool_info.source}")
+            if tool_info.metadata:
+                extra_info.append("\nMetadata:")
+                extra_info.extend(f"- {k}: {v}" for k, v in tool_info.metadata.items())
+
+            if extra_info:
+                sections.extend(extra_info)
+
+            await ctx.print("\n".join(sections))
+        except KeyError:
+            await ctx.print(f"❌ **Tool** `{name}` **not found**")
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for tool names."""
+        return CallbackCompleter(get_tool_names)
+
+
+class EnableToolCommand(NodeCommand):
+    """Enable a previously disabled tool.
+
+    Use /list-tools to see available tools.
+
+    Example: /enable-tool open_browser
+    """
+
+    name = "enable-tool"
+    category = "tools"
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        from agentpool import Agent
+
+        return isinstance(node, Agent)
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        name: str,
+    ) -> None:
+        """Enable a tool.
+
+        Args:
+            ctx: Command context
+            name: Tool name to enable
+        """
+        try:
+            await ctx.context.agent.tools.enable_tool(name)
+            await ctx.print(f"✅ **Tool** `{name}` **enabled**")
+        except ValueError as e:
+            msg = f"Failed to enable tool: {e}"
+            raise CommandError(msg) from e
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for tool names."""
+        return CallbackCompleter(get_tool_names)
+
+
+class DisableToolCommand(NodeCommand):
+    """Disable a tool to prevent its use.
+
+    Use /list-tools to see available tools.
+
+    Example: /disable-tool open_browser
+    """
+
+    name = "disable-tool"
+    category = "tools"
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        from agentpool import Agent
+
+        return isinstance(node, Agent)
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        name: str,
+    ) -> None:
+        """Disable a tool.
+
+        Args:
+            ctx: Command context
+            name: Tool name to disable
+        """
+        try:
+            await ctx.context.agent.tools.disable_tool(name)
+            await ctx.print(f"❌ **Tool** `{name}` **disabled**")
+        except ValueError as e:
+            msg = f"Failed to disable tool: {e}"
+            raise CommandError(msg) from e
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for tool names."""
+        return CallbackCompleter(get_tool_names)
+
+
+class RegisterToolCommand(NodeCommand):
+    """Register a new tool from a Python import path.
+
+    Examples:
+      /register-tool webbrowser.open
+      /register-tool json.dumps --name format_json
+      /register-tool os.getcwd --description 'Get current directory'
+    """
+
+    name = "register-tool"
+    category = "tools"
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        from agentpool import Agent
+
+        return isinstance(node, Agent)
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        import_path: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> None:
+        """Register a new tool from import path or function.
+
+        Args:
+            ctx: Command context
+            import_path: Python import path to the function
+            name: Optional custom name for the tool
+            description: Optional custom description
+        """
+        try:
+            callable_func = import_callable(import_path)
+            # Register with ToolManager
+            tool_info = ctx.context.agent.tools.register_tool(
+                callable_func,
+                name_override=name,
+                description_override=description,
+                enabled=True,
+                source="dynamic",
+                metadata={"import_path": import_path, "registered_via": "register-tool"},
+            )
+
+            # Show the registered tool info
+            tool_info.format_info()
+            await ctx.print(
+                f"✅ **Tool registered successfully:**\n`{tool_info.name}`"
+                f" - {tool_info.description or '*No description*'}"
+            )
+
+        except Exception as e:
+            msg = f"Failed to register tool: {e}"
+            raise CommandError(msg) from e
+
+
+async def get_tool_names(ctx: CompletionContext[AgentContext]) -> list[str]:
+    manager = ctx.command_context.context.agent.tools
+    return list({t.name for t in await manager.get_tools()})

agentpool_commands/utils.py

@@ -0,0 +1,189 @@
+"""Command utilities."""
+
+from __future__ import annotations
+
+import importlib.util
+import webbrowser
+
+from anyenv.text_sharing import TextSharerStr, Visibility  # noqa: TC002
+from slashed import CommandContext, CommandError  # noqa: TC002
+
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+
+
+class CopyClipboardCommand(NodeCommand):
+    """Copy messages from conversation history to system clipboard.
+
+    Allows copying a configurable number of messages with options for:
+    - Number of messages to include
+    - Including/excluding system messages
+    - Token limit for context size
+    - Custom format templates
+
+    Requires clipman package to be installed.
+    """
+
+    name = "copy-clipboard"
+    category = "utils"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        *,
+        num_messages: int = 1,
+        include_system: bool = False,
+        max_tokens: int | None = None,
+        format_template: str | None = None,
+    ) -> None:
+        """Copy messages to clipboard.
+
+        Args:
+            ctx: Command context
+            num_messages: Number of messages to copy (default: 1)
+            include_system: Include system messages
+            max_tokens: Only include messages up to token limit
+            format_template: Custom format template
+        """
+        try:
+            import clipman  # type: ignore[import-untyped]
+        except ImportError as e:
+            msg = "clipman package required for clipboard operations"
+            raise CommandError(msg) from e
+
+        content = await ctx.context.agent.conversation.format_history(
+            num_messages=num_messages,
+            include_system=include_system,
+            max_tokens=max_tokens,
+            format_template=format_template,
+        )
+
+        if not content.strip():
+            await ctx.print("ℹ️ **No messages found to copy**")  #  noqa: RUF001
+            return
+
+        try:
+            clipman.init()
+            clipman.copy(content)
+            await ctx.print("📋 **Messages copied to clipboard**")
+        except Exception as e:
+            msg = f"Failed to copy to clipboard: {e}"
+            raise CommandError(msg) from e
+
+    @classmethod
+    def condition(cls) -> bool:
+        """Check if clipman is available."""
+        return importlib.util.find_spec("clipman") is not None
+
+
+class EditAgentFileCommand(NodeCommand):
+    """Open the agent's configuration file in your default editor.
+
+    This file contains:
+    - Agent settings and capabilities
+    - System promptss
+    - Model configuration
+    - Environment references
+    - Role definitions
+
+    Note: Changes to the configuration file require reloading the agent.
+    """
+
+    name = "open-agent-file"
+    category = "utils"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext]) -> None:
+        """Open agent's configuration file."""
+        agent = ctx.context.agent
+        agent_ctx = agent.get_context()
+        config = agent_ctx.config
+        if not config.config_file_path:
+            msg = "No configuration file path available"
+            raise CommandError(msg)
+
+        try:
+            webbrowser.open(config.config_file_path)
+            msg = f"🌐 **Opening agent configuration:** `{config.config_file_path}`"
+            await ctx.print(msg)
+        except Exception as e:
+            msg = f"Failed to open configuration file: {e}"
+            raise CommandError(msg) from e
+
+
+class ShareHistoryCommand(NodeCommand):
+    """Share message history using various text sharing providers.
+
+    Supports multiple providers:
+    - gist: GitHub Gist (requires GITHUB_TOKEN or GH_TOKEN)
+    - pastebin: Pastebin (requires PASTEBIN_API_KEY)
+    - paste_rs: paste.rs (no authentication required)
+    - opencode: OpenCode (no authentication required)
+
+    The shared content can be conversation history or custom text.
+    """
+
+    name = "share-text"
+    category = "utils"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        *,
+        provider: TextSharerStr = "paste_rs",
+        num_messages: int = 1,
+        include_system: bool = False,
+        max_tokens: int | None = None,
+        format_template: str | None = None,
+        title: str | None = None,
+        syntax: str = "markdown",
+        visibility: Visibility = "unlisted",
+    ) -> None:
+        """Share text content via a text sharing provider.
+
+        Args:
+            ctx: Command context
+            provider: Text sharing provider to use
+            num_messages: Number of messages from history to share (ignored if custom_content)
+            include_system: Include system messages in history
+            max_tokens: Token limit for conversation history
+            format_template: Custom format template for history
+            title: Title/filename for the shared content
+            syntax: Syntax highlighting (e.g., "python", "markdown")
+            visibility: Visibility level
+        """
+        from anyenv.text_sharing import get_sharer
+
+        content = await ctx.context.agent.conversation.format_history(
+            num_messages=num_messages,
+            include_system=include_system,
+            max_tokens=max_tokens,
+            format_template=format_template,
+        )
+
+        if not content.strip():
+            await ctx.print("ℹ️ **No content to share**")  # noqa: RUF001
+            return
+
+        try:
+            # Get the appropriate sharer
+            sharer = get_sharer(provider)
+            # Share the content
+            result = await sharer.share(content, title=title, syntax=syntax, visibility=visibility)
+            # Format success message
+            provider_name = sharer.name
+            msg_parts = [f"🔗 **Content shared via {provider_name}:**", f"• URL: {result.url}"]
+            if result.raw_url:
+                msg_parts.append(f"• Raw: {result.raw_url}")
+            if result.delete_url:
+                msg_parts.append(f"• Delete: {result.delete_url}")
+
+            await ctx.print("\n".join(msg_parts))
+
+        except Exception as e:
+            msg = f"Failed to share content via {provider}: {e}"
+            raise CommandError(msg) from e
+
+    @classmethod
+    def condition(cls) -> bool:
+        """Check if anyenv text_sharing is available."""
+        return importlib.util.find_spec("anyenv.text_sharing") is not None

agentpool_commands/workers.py

@@ -0,0 +1,163 @@
+"""Tool management commands."""
+
+from __future__ import annotations
+
+from slashed import CommandContext, CommandError  # noqa: TC002
+from slashed.completers import CallbackCompleter
+
+from agentpool.agents.context import AgentContext  # noqa: TC001
+from agentpool.log import get_logger
+from agentpool_commands.base import AgentCommand
+from agentpool_commands.completers import get_available_agents
+from agentpool_commands.markdown_utils import format_table
+
+
+logger = get_logger(__name__)
+
+
+class AddWorkerCommand(AgentCommand):
+    """Add another agent as a worker tool.
+
+    Add another agent as a worker tool.
+
+    Options:
+      --reset-history    Clear worker's history before each run (default: true)
+      --share-history   Pass current agent's message history (default: false)
+      --share-context   Share context data between agents (default: false)
+
+    Examples:
+      /add-worker specialist               # Basic worker
+      /add-worker analyst --share-history  # Pass conversation history
+      /add-worker helper --share-context   # Share context between agents
+    """
+
+    name = "add-worker"
+    category = "tools"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        worker_name: str,
+        *,
+        reset_history: str = "true",
+        share_history: str = "false",
+    ) -> None:
+        """Add another agent as a worker tool.
+
+        Args:
+            ctx: Command context
+            worker_name: Name of the agent to add as worker
+            reset_history: Clear worker's history before each run
+            share_history: Pass current agent's message history
+        """
+        try:
+            if not ctx.context.pool:
+                msg = "No agent pool available"
+                raise CommandError(msg)  # noqa: TRY301
+
+            # Get worker agent from pool
+            worker = ctx.context.pool.get_agent(worker_name)
+
+            # Parse boolean flags with defaults
+            reset_history_bool = reset_history.lower() != "false"
+            share_history_bool = share_history.lower() == "true"
+
+            # Register worker
+            tool_info = ctx.context.agent.tools.register_worker(
+                worker,
+                reset_history_on_run=reset_history_bool,
+                pass_message_history=share_history_bool,
+                parent=ctx.context.native_agent,
+            )
+
+            await ctx.print(
+                f"✅ **Added agent** `{worker_name}` **as worker tool:** `{tool_info.name}`\n"
+                f"🔧 **Tool enabled:** {tool_info.enabled}"
+            )
+
+        except KeyError as e:
+            msg = f"Agent not found: {worker_name}"
+            raise CommandError(msg) from e
+        except Exception as e:
+            msg = f"Failed to add worker: {e}"
+            raise CommandError(msg) from e
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for agent names."""
+        return CallbackCompleter(get_available_agents)
+
+
+class RemoveWorkerCommand(AgentCommand):
+    """Remove a worker tool from the current agent.
+
+    Examples:
+      /remove-worker specialist  # Remove the specialist worker tool
+    """
+
+    name = "remove-worker"
+    category = "tools"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+        worker_name: str,
+    ) -> None:
+        """Remove a worker tool.
+
+        Args:
+            ctx: Command context
+            worker_name: Name of the worker to remove
+        """
+        tool_name = f"ask_{worker_name}"  # Match the naming in to_tool
+
+        try:
+            ctx.context.agent.tools.worker_provider.remove_tool(tool_name)
+            await ctx.print(f"🗑️ **Removed worker tool:** `{tool_name}`")
+        except Exception as e:
+            msg = f"Failed to remove worker: {e}"
+            raise CommandError(msg) from e
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for agent names."""
+        return CallbackCompleter(get_available_agents)
+
+
+class ListWorkersCommand(AgentCommand):
+    """List all registered worker tools and their settings.
+
+    Shows:
+    - Worker agent name
+    - Tool name
+    - Current settings (history/context sharing)
+    - Enabled/disabled status
+
+    Example: /list-workers
+    """
+
+    name = "list-workers"
+    category = "tools"
+
+    async def execute_command(self, ctx: CommandContext[AgentContext]) -> None:
+        """List all worker tools.
+
+        Args:
+            ctx: Command context
+        """
+        # Filter tools by source="agent"
+        worker_tools = await ctx.context.agent.tools.worker_provider.get_tools()
+        if not worker_tools:
+            await ctx.print("ℹ️ **No worker tools registered**")  #  noqa: RUF001
+            return
+
+        rows = [
+            {
+                "Status": "✅" if tool_info.enabled else "❌",
+                "Agent": tool_info.agent_name,
+                "Tool": tool_info.name,
+                "Description": tool_info.description or "",
+            }
+            for tool_info in worker_tools
+        ]
+        headers = ["Status", "Agent", "Tool", "Description"]
+        table = format_table(headers, rows)
+        await ctx.print(f"## 👥 Registered Workers\n\n{table}")

agentpool_config/__init__.py

@@ -0,0 +1,53 @@
+"""Core data models for AgentPool."""
+
+from __future__ import annotations
+
+from agentpool_config.resources import ResourceInfo
+from agentpool_config.forward_targets import ForwardingTarget
+from agentpool_config.session import SessionQuery
+from agentpool_config.teams import TeamConfig
+from agentpool_config.mcp_server import (
+    BaseMCPServerConfig,
+    StdioMCPServerConfig,
+    StreamableHTTPMCPServerConfig,
+    MCPServerConfig,
+    SSEMCPServerConfig,
+)
+from agentpool_config.event_handlers import (
+    BaseEventHandlerConfig,
+    StdoutEventHandlerConfig,
+    CallbackEventHandlerConfig,
+    EventHandlerConfig,
+    resolve_handler_configs,
+)
+from agentpool_config.hooks import (
+    BaseHookConfig,
+    CallableHookConfig,
+    CommandHookConfig,
+    HookConfig,
+    HooksConfig,
+    PromptHookConfig,
+)
+
+__all__ = [
+    "BaseEventHandlerConfig",
+    "BaseHookConfig",
+    "BaseMCPServerConfig",
+    "CallableHookConfig",
+    "CallbackEventHandlerConfig",
+    "CommandHookConfig",
+    "EventHandlerConfig",
+    "ForwardingTarget",
+    "HookConfig",
+    "HooksConfig",
+    "MCPServerConfig",
+    "PromptHookConfig",
+    "ResourceInfo",
+    "SSEMCPServerConfig",
+    "SessionQuery",
+    "StdioMCPServerConfig",
+    "StdoutEventHandlerConfig",
+    "StreamableHTTPMCPServerConfig",
+    "TeamConfig",
+    "resolve_handler_configs",
+]