agentpool 2.1.9__py3-none-any.whl → 2.2.3__py3-none-any.whl

agentpool_commands/mcp.py

@@ -0,0 +1,176 @@
+"""MCP server management commands."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+
+from pydantic import HttpUrl
+from slashed import CommandContext, CommandError  # noqa: TC002
+
+from agentpool_commands.base import NodeCommand
+
+
+if TYPE_CHECKING:
+    from agentpool.agents.context import AgentContext
+    from agentpool.messaging import MessageNode
+    from agentpool_config.mcp_server import MCPServerConfig
+
+
+class AddMCPServerCommand(NodeCommand):
+    """Add a local MCP server via stdio transport.
+
+    Registers a new MCP server that runs as a subprocess.
+
+    Options:
+      --args "arg1|arg2"       Pipe-separated command arguments
+      --env "KEY=val|KEY2=val" Pipe-separated environment variables
+
+    Examples:
+      /add-mcp-server myserver npx --args "mcp-server-filesystem|/tmp"
+      /add-mcp-server graphql npx --args "mcp-graphql" --env "ENDPOINT=https://api.example.com/graphql"
+    """
+
+    name = "add-mcp-server"
+    category = "integrations"
+
+    @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,
+        command: str,
+        *,
+        args: str | None = None,
+        env: str | None = None,
+    ) -> None:
+        """Add a local MCP server.
+
+        Args:
+            ctx: Command context
+            name: Unique name for the MCP server
+            command: Command to execute for the server
+            args: Pipe-separated command arguments
+            env: Pipe-separated environment variables (KEY=value format)
+        """
+        from agentpool_config.mcp_server import StdioMCPServerConfig
+
+        try:
+            # Parse arguments
+            arg_list = [a.strip() for a in args.split("|")] if args else []
+            # Parse environment variables
+            env_dict: dict[str, str] = {}
+            if env:
+                for pair in env.split("|"):
+                    if "=" in pair:
+                        key, value = pair.split("=", 1)
+                        env_dict[key.strip()] = value.strip()
+
+            config = StdioMCPServerConfig(name=name, command=command, args=arg_list, env=env_dict)
+            await ctx.context.agent.mcp.setup_server(config, add_to_config=True)
+            await ctx.print(f"**Added MCP server** `{name}` with command: `{command}`")
+
+        except Exception as e:
+            msg = f"Failed to add MCP server: {e}"
+            raise CommandError(msg) from e
+
+
+class AddRemoteMCPServerCommand(NodeCommand):
+    """Add a remote MCP server via HTTP transport.
+
+    Connects to an MCP server running on a remote URL.
+
+    Options:
+      --transport sse|streamable-http   Transport type (default: streamable-http)
+
+    Examples:
+      /add-remote-mcp-server myapi https://api.example.com/mcp
+      /add-remote-mcp-server legacy https://old.api.com/mcp --transport sse
+    """
+
+    name = "add-remote-mcp-server"
+    category = "integrations"
+
+    @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,
+        url: str,
+        *,
+        transport: Literal["sse", "streamable-http"] = "streamable-http",
+    ) -> None:
+        """Add a remote MCP server.
+
+        Args:
+            ctx: Command context
+            name: Unique name for the MCP server
+            url: Server URL endpoint
+            transport: HTTP transport type (sse or streamable-http)
+        """
+        from agentpool_config.mcp_server import SSEMCPServerConfig, StreamableHTTPMCPServerConfig
+
+        try:
+            config: MCPServerConfig
+            if transport == "sse":
+                config = SSEMCPServerConfig(name=name, url=HttpUrl(url))
+            else:
+                config = StreamableHTTPMCPServerConfig(name=name, url=HttpUrl(url))
+
+            await ctx.context.agent.mcp.setup_server(config, add_to_config=True)
+            await ctx.print(f"**Added remote MCP server** `{name}` at `{url}` using {transport}")
+
+        except Exception as e:
+            msg = f"Failed to add remote MCP server: {e}"
+            raise CommandError(msg) from e
+
+
+class ListMCPServersCommand(NodeCommand):
+    """List all configured MCP servers.
+
+    Shows server name, type, and connection status.
+    """
+
+    name = "list-mcp-servers"
+    category = "integrations"
+
+    @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]) -> None:
+        """List all MCP servers.
+
+        Args:
+            ctx: Command context
+        """
+        from agentpool_commands.markdown_utils import format_table
+
+        servers = ctx.context.agent.mcp.providers
+        if not servers:
+            await ctx.print("No MCP servers configured.")
+            return
+
+        rows = []
+        for server in servers:
+            server_type = type(server.server).__name__.replace("MCPServerConfig", "")
+            rows.append({
+                "Name": server.name,
+                "Type": server_type,
+                "Status": "connected" if server.client.connected else "disconnected",
+            })
+
+        headers = ["Name", "Type", "Status"]
+        table = format_table(headers, rows)
+        await ctx.print(f"## MCP Servers\n\n{table}")

agentpool_commands/models.py

@@ -16,6 +16,59 @@ if TYPE_CHECKING:
     from agentpool.messaging import MessageNode
 
 
+class ListModelsCommand(NodeCommand):
+    """List available models for the current agent.
+
+    Displays all models that can be used with the current agent,
+    formatted as a markdown table with model ID, name, and description.
+
+    Examples:
+      /list-models
+    """
+
+    name = "list-models"
+    category = "model"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[AgentContext],
+    ) -> None:
+        """List available models.
+
+        Args:
+            ctx: Command context
+        """
+        agent = ctx.context.agent
+        models = await agent.get_available_models()
+
+        if not models:
+            await ctx.print("No models available for this agent.")
+            return
+
+        # Build markdown table
+        lines = [
+            "| Model ID | Name | Description |",
+            "|----------|------|-------------|",
+        ]
+
+        for model in models:
+            model_id = model.id_override if model.id_override else model.id
+            name = model.name or ""
+            description = model.description or ""
+            # Escape pipe characters in fields
+            name = name.replace("|", "\\|")
+            description = description.replace("|", "\\|")
+            lines.append(f"| `{model_id}` | {name} | {description} |")
+
+        await ctx.print("\n".join(lines))
+
+    @classmethod
+    def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
+        from agentpool import ACPAgent, Agent, ClaudeCodeAgent
+
+        return isinstance(node, Agent | ACPAgent | ClaudeCodeAgent)
+
+
 class SetModelCommand(NodeCommand):
     """Change the language model for the current conversation.
 
@@ -46,7 +99,7 @@ class SetModelCommand(NodeCommand):
         """
         try:
             # Create new session with model override
-            ctx.context.native_agent.set_model(model)
+            await ctx.context.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}")
@@ -57,6 +110,6 @@ class SetModelCommand(NodeCommand):
 
     @classmethod
     def supports_node(cls, node: MessageNode[Any, Any]) -> bool:
-        from agentpool import Agent
+        from agentpool import ACPAgent, Agent, ClaudeCodeAgent
 
-        return isinstance(node, Agent)
+        return isinstance(node, Agent | ACPAgent | ClaudeCodeAgent)

agentpool_commands/tools.py

@@ -264,6 +264,63 @@ class RegisterToolCommand(NodeCommand):
             raise CommandError(msg) from e
 
 
+class RegisterCodeToolCommand(NodeCommand):
+    """Register a new tool from Python code.
+
+    The code should define a function that will become the tool.
+    The function name becomes the tool name unless overridden.
+
+    Options:
+      --name tool_name         Custom name for the tool
+      --description "text"     Custom description
+
+    Examples:
+      /register-code-tool "def greet(name: str) -> str: return f'Hello {name}'"
+      /register-code-tool "def add(a: int, b: int) -> int: return a + b" --name sum
+    """
+
+    name = "register-code-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],
+        code: str,
+        *,
+        name: str | None = None,
+        description: str | None = None,
+    ) -> None:
+        """Register a new tool from code string.
+
+        Args:
+            ctx: Command context
+            code: Python code defining a function
+            name: Optional custom name for the tool
+            description: Optional custom description
+        """
+        from agentpool.tools.base import Tool
+
+        try:
+            tool_obj = Tool.from_code(code, name=name, description=description)
+            tool_obj.enabled = True
+            tool_obj.source = "dynamic"
+
+            registered = ctx.context.agent.tools.register_tool(tool_obj)
+            await ctx.print(
+                f"**Tool registered:** `{registered.name}`"
+                f" - {registered.description or '*No description*'}"
+            )
+        except Exception as e:
+            msg = f"Failed to register code 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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import importlib.util
+from typing import Literal
 import webbrowser
 
 from anyenv.text_sharing import TextSharerStr, Visibility  # noqa: TC002
@@ -12,6 +13,9 @@ from agentpool.messaging.context import NodeContext  # noqa: TC001
 from agentpool_commands.base import NodeCommand
 
 
+LogLevel = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+
 class CopyClipboardCommand(NodeCommand):
     """Copy messages from conversation history to system clipboard.
 
@@ -187,3 +191,50 @@ class ShareHistoryCommand(NodeCommand):
     def condition(cls) -> bool:
         """Check if anyenv text_sharing is available."""
         return importlib.util.find_spec("anyenv.text_sharing") is not None
+
+
+class GetLogsCommand(NodeCommand):
+    """Get recent log entries from memory.
+
+    Shows captured log entries with filtering options:
+    - Filter by minimum log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    - Filter by logger name substring
+    - Limit number of entries returned
+
+    Logs are shown newest first.
+    """
+
+    name = "get-logs"
+    category = "debug"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        *,
+        level: LogLevel = "INFO",
+        logger_filter: str | None = None,
+        limit: int | str = 50,
+    ) -> None:
+        """Get recent log entries.
+
+        Args:
+            ctx: Command context
+            level: Minimum log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+            logger_filter: Only show logs from loggers containing this string
+            limit: Maximum number of log entries to return
+        """
+        from agentpool_toolsets.builtin.debug import get_memory_handler
+
+        # Convert limit to int (slashed passes args as strings)
+        limit_int = int(limit) if isinstance(limit, str) else limit
+
+        handler = get_memory_handler()
+        records = handler.get_records(level=level, logger_filter=logger_filter, limit=limit_int)
+
+        if not records:
+            await ctx.print("No log entries found matching criteria")
+            return
+
+        await ctx.print(f"## 📋 {len(records)} Log Entries (newest first)\n")
+        for record in records:
+            await ctx.print(record.message)

agentpool_config/builtin_tools.py

@@ -25,17 +25,33 @@ if TYPE_CHECKING:
 class BaseBuiltinToolConfig(BaseToolConfig):
     """Base configuration for PydanticAI builtin tools."""
 
+    type: Literal["builtin"] = Field("builtin", init=False)
+    """Top-level discriminator - always 'builtin' for builtin tools."""
+
+    builtin_type: str = Field(init=False)
+    """Sub-discriminator for specific builtin tool type."""
+
     def get_builtin_tool(self) -> AbstractBuiltinTool:
         """Convert config to PydanticAI builtin tool instance."""
         raise NotImplementedError
 
 
 class WebSearchToolConfig(BaseBuiltinToolConfig):
-    """Configuration for PydanticAI web search builtin tool."""
+    """Configuration for PydanticAI web search builtin tool.
+
+    Example:
+        ```yaml
+        tools:
+          - type: builtin
+            builtin_type: web_search
+            search_context_size: high
+            blocked_domains: ["spam.com"]
+        ```
+    """
 
     model_config = ConfigDict(title="Web Search Tool")
 
-    type: Literal["web_search"] = Field("web_search", init=False)
+    builtin_type: Literal["web_search"] = Field("web_search", init=False)
     """Web search builtin tool."""
 
     search_context_size: Literal["low", "medium", "high"] = Field(
@@ -77,11 +93,19 @@ class WebSearchToolConfig(BaseBuiltinToolConfig):
 
 
 class CodeExecutionToolConfig(BaseBuiltinToolConfig):
-    """Configuration for PydanticAI code execution builtin tool."""
+    """Configuration for PydanticAI code execution builtin tool.
+
+    Example:
+        ```yaml
+        tools:
+          - type: builtin
+            builtin_type: code_execution
+        ```
+    """
 
     model_config = ConfigDict(title="Code Execution Tool")
 
-    type: Literal["code_execution"] = Field("code_execution", init=False)
+    builtin_type: Literal["code_execution"] = Field("code_execution", init=False)
     """Code execution builtin tool."""
 
     def get_builtin_tool(self) -> CodeExecutionTool:
@@ -90,12 +114,20 @@ class CodeExecutionToolConfig(BaseBuiltinToolConfig):
 
 
 class WebFetchToolConfig(BaseBuiltinToolConfig):
-    """Configuration for PydanticAI URL context builtin tool."""
+    """Configuration for PydanticAI web fetch builtin tool.
+
+    Example:
+        ```yaml
+        tools:
+          - type: builtin
+            builtin_type: web_fetch
+        ```
+    """
 
-    model_config = ConfigDict(title="Url Context Tool")
+    model_config = ConfigDict(title="Web Fetch Tool")
 
-    type: Literal["web_fetch"] = Field("web_fetch", init=False)
-    """URL context builtin tool."""
+    builtin_type: Literal["web_fetch"] = Field("web_fetch", init=False)
+    """Web fetch builtin tool."""
 
     def get_builtin_tool(self) -> WebFetchTool:
         """Convert config to WebFetchTool instance."""
@@ -103,11 +135,21 @@ class WebFetchToolConfig(BaseBuiltinToolConfig):
 
 
 class ImageGenerationToolConfig(BaseBuiltinToolConfig):
-    """Configuration for PydanticAI image generation builtin tool."""
+    """Configuration for PydanticAI image generation builtin tool.
+
+    Example:
+        ```yaml
+        tools:
+          - type: builtin
+            builtin_type: image_generation
+            quality: high
+            size: 1024x1024
+        ```
+    """
 
     model_config = ConfigDict(title="Image Generation Tool")
 
-    type: Literal["image_generation"] = Field("image_generation", init=False)
+    builtin_type: Literal["image_generation"] = Field("image_generation", init=False)
     """Image generation builtin tool."""
 
     background: Literal["transparent", "opaque", "auto"] = Field(
@@ -184,11 +226,19 @@ class ImageGenerationToolConfig(BaseBuiltinToolConfig):
 
 
 class MemoryToolConfig(BaseBuiltinToolConfig):
-    """Configuration for PydanticAI memory builtin tool."""
+    """Configuration for PydanticAI memory builtin tool.
+
+    Example:
+        ```yaml
+        tools:
+          - type: builtin
+            builtin_type: memory
+        ```
+    """
 
     model_config = ConfigDict(title="Memory Tool")
 
-    type: Literal["memory"] = Field("memory", init=False)
+    builtin_type: Literal["memory"] = Field("memory", init=False)
     """Memory builtin tool."""
 
     def get_builtin_tool(self) -> MemoryTool:
@@ -197,11 +247,21 @@ class MemoryToolConfig(BaseBuiltinToolConfig):
 
 
 class MCPServerToolConfig(BaseBuiltinToolConfig):
-    """Configuration for PydanticAI MCP server builtin tool."""
+    """Configuration for PydanticAI MCP server builtin tool.
+
+    Example:
+        ```yaml
+        tools:
+          - type: builtin
+            builtin_type: mcp_server
+            id: my_server
+            url: https://api.example.com/mcp
+        ```
+    """
 
     model_config = ConfigDict(title="MCP Server Tool")
 
-    type: Literal["mcp_server"] = Field("mcp_server", init=False)
+    builtin_type: Literal["mcp_server"] = Field("mcp_server", init=False)
     """MCP server builtin tool."""
 
     server_id: str = Field(
@@ -224,12 +284,7 @@ class MCPServerToolConfig(BaseBuiltinToolConfig):
     )
     """Authorization header to use when making requests to the MCP server."""
 
-    description: str | None = Field(
-        default=None,
-        examples=["External API tools", "Code execution server"],
-        title="Server description",
-    )
-    """A description of the MCP server."""
+    # description is inherited from BaseToolConfig
 
     allowed_tools: list[str] | None = Field(
         default=None,
@@ -253,7 +308,7 @@ class MCPServerToolConfig(BaseBuiltinToolConfig):
         )
 
 
-# Union type for builtin tool configs
+# Union type for builtin tool configs (sub-discriminated by builtin_type)
 BuiltinToolConfig = Annotated[
     WebSearchToolConfig
     | CodeExecutionToolConfig
@@ -261,5 +316,5 @@ BuiltinToolConfig = Annotated[
     | ImageGenerationToolConfig
     | MemoryToolConfig
     | MCPServerToolConfig,
-    Field(discriminator="type"),
+    Field(discriminator="builtin_type"),
 ]

agentpool_config/commands.py

@@ -6,12 +6,16 @@ from collections.abc import Callable
 import inspect
 from pathlib import Path
 import re
-from typing import Annotated, Any, Literal
+from typing import TYPE_CHECKING, Annotated, Any, Literal
 
 from pydantic import ConfigDict, Field, ImportString
 from schemez import Schema
 
 
+if TYPE_CHECKING:
+    from slashed import Command
+
+
 class BaseCommandConfig(Schema):
     """Base configuration for commands."""
 
@@ -43,6 +47,25 @@ class BaseCommandConfig(Schema):
         """
         raise NotImplementedError
 
+    def get_slashed_command(self, category: str = "manifest") -> Command:
+        """Create a slashed Command from this configuration.
+
+        Args:
+            category: Category to assign to the command
+
+        Returns:
+            A slashed Command instance ready for registration
+        """
+        from slashed import Command
+
+        func = self.get_callable()
+        return Command(
+            func,
+            name=self.name,
+            description=self.description,
+            category=category,
+        )
+
 
 class StaticCommandConfig(BaseCommandConfig):
     """Static command with inline content."""