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

agentpool_commands/agents.py

@@ -2,15 +2,21 @@
 
 from __future__ import annotations
 
+from typing import TYPE_CHECKING, Any, Literal
+
 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.completers import get_available_agents, get_available_nodes
 from agentpool_commands.markdown_utils import format_table
 
 
+if TYPE_CHECKING:
+    from agentpool.delegation import BaseTeam
+
+
 class CreateAgentCommand(NodeCommand):
     """Create a new agent in the current session.
 
@@ -71,7 +77,7 @@ class CreateAgentCommand(NodeCommand):
             # Create and register the new agent
             await ctx.context.pool.add_agent(
                 name=agent_name,
-                model=model or current_agent.model_name,
+                model=model or current_agent.model_name or "openai:gpt-4o-mini",
                 system_prompt=system_prompt or (),
                 description=description,
                 tools=tool_list,
@@ -197,3 +203,70 @@ class SwitchAgentCommand(NodeCommand):
     def get_completer(self) -> CallbackCompleter:
         """Get completer for agent names."""
         return CallbackCompleter(get_available_agents)
+
+
+class CreateTeamCommand(NodeCommand):
+    """Create a team from existing agents/nodes.
+
+    Teams allow multiple agents to work together, either in parallel
+    or sequentially (pipeline).
+
+    Options:
+      --mode sequential|parallel   How the team operates (default: sequential)
+
+    Examples:
+      # Create a team named "crew" with alice and bob
+      /create-team crew alice bob
+
+      # Create a parallel team
+      /create-team reviewers alice bob --mode parallel
+    """
+
+    name = "create-team"
+    category = "agents"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        name: str,
+        *nodes: str,
+        mode: Literal["sequential", "parallel"] = "sequential",
+    ) -> None:
+        """Create a team from existing nodes.
+
+        Args:
+            ctx: Command context
+            name: Name for the team
+            nodes: Names of agents/teams to include
+            mode: How the team operates (sequential or parallel)
+        """
+        if not ctx.context.pool:
+            msg = "No agent pool available"
+            raise CommandError(msg)
+
+        if len(nodes) < 2:  # noqa: PLR2004
+            msg = "At least 2 members are required to create a team"
+            raise CommandError(msg)
+
+        # Verify all nodes exist
+        node_list = list(nodes)
+        for node_name in node_list:
+            if node_name not in ctx.context.pool.nodes:
+                available = ", ".join(ctx.context.pool.nodes.keys())
+                msg = f"Node '{node_name}' not found. Available: {available}"
+                raise CommandError(msg)
+
+        # Create the team
+        if mode == "sequential":
+            team: BaseTeam[Any, Any] = ctx.context.pool.create_team_run(node_list, name=name)
+        else:
+            team = ctx.context.pool.create_team(node_list, name=name)
+
+        mode_str = "pipeline" if mode == "sequential" else "parallel"
+        await ctx.print(
+            f"**Created {mode_str} team** `{team.name}` with nodes: `{', '.join(node_list)}`"
+        )
+
+    def get_completer(self) -> CallbackCompleter:
+        """Get completer for node names."""
+        return CallbackCompleter(get_available_nodes)

agentpool_commands/history.py

@@ -0,0 +1,62 @@
+"""History management 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
+
+
+class SearchHistoryCommand(NodeCommand):
+    """Search conversation history.
+
+    Search through past conversations with optional filtering.
+
+    Options:
+      --hours N      Look back N hours (default: 24)
+      --limit N      Maximum results to return (default: 5)
+
+    Examples:
+      /search-history                    # Recent conversations
+      /search-history "error handling"   # Search for specific topic
+      /search-history --hours 48 --limit 10
+    """
+
+    name = "search-history"
+    category = "history"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext],
+        query: str | None = None,
+        *,
+        hours: int = 24,
+        limit: int = 5,
+    ) -> None:
+        """Search conversation history.
+
+        Args:
+            ctx: Command context
+            query: Optional search query
+            hours: Look back period in hours
+            limit: Maximum results to return
+        """
+        if not ctx.context.pool:
+            msg = "No agent pool available for history search"
+            raise CommandError(msg)
+
+        try:
+            from agentpool_storage.formatters import format_output
+
+            provider = ctx.context.pool.storage.get_history_provider()
+            results = await provider.get_filtered_conversations(
+                query=query,
+                period=f"{hours}h",
+                limit=limit,
+            )
+            output = format_output(results)
+            await ctx.print(f"## Search Results\n\n{output}")
+        except Exception as e:
+            msg = f"Failed to search history: {e}"
+            raise CommandError(msg) from e

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/pool.py

@@ -0,0 +1,260 @@
+"""Pool-level commands for managing agent pools and configurations."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from agentpool.agents.base_agent import BaseAgent
+from agentpool_commands.base import NodeCommand
+
+
+if TYPE_CHECKING:
+    from slashed import CommandContext
+
+    from agentpool.messaging.context import NodeContext
+
+
+class ListPoolsCommand(NodeCommand):
+    """List available agent pool configurations.
+
+    Examples:
+      /list-pools
+    """
+
+    name = "list-pools"
+    category = "pool"
+
+    async def execute_command(self, ctx: CommandContext[NodeContext[Any]]) -> None:
+        """List available pool configurations.
+
+        Args:
+            ctx: Command context with node context
+        """
+        from agentpool_cli import agent_store
+
+        try:
+            output_lines = ["## 🏊 Agent Pool Configurations\n"]
+
+            # Show current pool info
+            output_lines.append("### 📍 Current Pool")
+
+            # Get config path from context config (works for all agent types)
+            current_config = ctx.context.config.config_file_path if ctx.context.config else None
+            if current_config:
+                output_lines.append(f"**Config:** `{current_config}`")
+            else:
+                output_lines.append("**Config:** *(default/built-in)*")
+
+            # Show agents in current pool
+            pool = ctx.context.pool
+            if pool:
+                agent_names = list(pool.all_agents.keys())
+                output_lines.append(f"**Agents:** {', '.join(f'`{n}`' for n in agent_names)}")
+                output_lines.append(f"**Active agent:** `{ctx.context.node.name}`")
+            else:
+                output_lines.append("**No pool available**")
+            output_lines.append("")
+
+            # Show stored configurations
+            output_lines.append("### 💾 Stored Configurations")
+            stored_configs = agent_store.list_configs()
+            active_config = agent_store.get_active()
+
+            if not stored_configs:
+                output_lines.append("*No stored configurations*")
+                output_lines.append("")
+                output_lines.append("Use `agentpool add <name> <path>` to add configurations.")
+            else:
+                # Build markdown table
+                output_lines.append("| Name | Path |")
+                output_lines.append("|------|------|")
+                for name, path in stored_configs:
+                    is_active = active_config and active_config.name == name
+                    is_current = current_config and path == current_config
+                    markers = []
+                    if is_active:
+                        markers.append("default")
+                    if is_current:
+                        markers.append("current")
+                    name_col = f"{name} ({', '.join(markers)})" if markers else name
+                    output_lines.append(f"| {name_col} | `{path}` |")
+
+            output_lines.append("")
+            output_lines.append("*Use `/set-pool <name>` or `/set-pool <path>` to switch pools.*")
+
+            await ctx.output.print("\n".join(output_lines))
+
+        except Exception as e:  # noqa: BLE001
+            await ctx.output.print(f"❌ **Error listing pools:** {e}")
+
+
+class CompactCommand(NodeCommand):
+    """Compact the conversation history to reduce context size.
+
+    Uses the configured compaction pipeline from the agent pool manifest,
+    or falls back to a default summarizing pipeline.
+
+    Options:
+      --preset <name>   Use a specific preset (minimal, balanced, summarizing)
+
+    Examples:
+      /compact
+      /compact --preset=minimal
+    """
+
+    name = "compact"
+    category = "pool"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[Any]],
+        *,
+        preset: str | None = None,
+    ) -> None:
+        """Compact the conversation history.
+
+        Args:
+            ctx: Command context with node context
+            preset: Optional preset name (minimal, balanced, summarizing)
+        """
+        from agentpool.agents.base_agent import BaseAgent
+
+        # Get agent from context
+        agent = ctx.context.node
+        if not isinstance(agent, BaseAgent):
+            await ctx.output.print(
+                "❌ **This command requires an agent with conversation history**"
+            )
+            return
+
+        # Check if there's any history to compact
+        if not agent.conversation.get_history():
+            await ctx.output.print("📭 **No message history to compact**")
+            return
+
+        try:
+            # Get compaction pipeline
+            from agentpool.messaging.compaction import (
+                balanced_context,
+                minimal_context,
+                summarizing_context,
+            )
+
+            pipeline = None
+
+            # Check for preset override
+            if preset:
+                match preset.lower():
+                    case "minimal":
+                        pipeline = minimal_context()
+                    case "balanced":
+                        pipeline = balanced_context()
+                    case "summarizing":
+                        pipeline = summarizing_context()
+                    case _:
+                        await ctx.output.print(
+                            f"⚠️ **Unknown preset:** `{preset}`\n"
+                            "Available: minimal, balanced, summarizing"
+                        )
+                        return
+
+            # Fall back to pool's configured pipeline
+            if pipeline is None and ctx.context.pool:
+                pipeline = ctx.context.pool.compaction_pipeline
+
+            # Fall back to default summarizing pipeline
+            if pipeline is None:
+                pipeline = summarizing_context()
+
+            await ctx.output.print("🔄 **Compacting conversation history...**")
+
+            # Apply the pipeline using shared helper
+            from agentpool.messaging.compaction import compact_conversation
+
+            original_count, compacted_count = await compact_conversation(
+                pipeline, agent.conversation
+            )
+            reduction = original_count - compacted_count
+
+            await ctx.output.print(
+                f"✅ **Compaction complete**\n"
+                f"- Messages: {original_count} → {compacted_count} ({reduction} removed)\n"
+                f"- Reduction: {reduction / original_count * 100:.1f}%"
+                if original_count > 0
+                else "✅ **Compaction complete** (no messages)"
+            )
+
+        except Exception as e:  # noqa: BLE001
+            await ctx.output.print(f"❌ **Error compacting history:** {e}")
+
+
+class SpawnCommand(NodeCommand):
+    """Spawn a subagent to execute a specific task.
+
+    The subagent runs and its progress is streamed back through the event system.
+    How the progress is displayed depends on the protocol (tool box in ACP, inline, etc.).
+
+    Examples:
+      /spawn agent-name "task description"
+      /spawn code-reviewer "Review main.py for bugs"
+    """
+
+    name = "spawn"
+    category = "pool"
+
+    @classmethod
+    def supports_node(cls, node: Any) -> bool:
+        """Only available when running from an agent (needs events)."""
+        return isinstance(node, BaseAgent)
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[Any]],
+        agent_name: str,
+        task_prompt: str,
+    ) -> None:
+        """Spawn a subagent to execute a task.
+
+        Args:
+            ctx: Command context with node context
+            agent_name: Name of the agent to spawn
+            task_prompt: Task prompt for the subagent
+        """
+        from agentpool.agents.events import SubAgentEvent
+
+        pool = ctx.context.pool
+        if not pool:
+            await ctx.output.print("❌ **No agent pool available**")
+            return
+
+        if agent_name not in pool.nodes:
+            available = list(pool.nodes.keys())
+            await ctx.output.print(
+                f"❌ **Agent** `{agent_name}` **not found**\n\n"
+                f"Available agents: {', '.join(available)}"
+            )
+            return
+
+        from agentpool.common_types import SupportsRunStream
+
+        agent = pool.nodes[agent_name]
+
+        # Check if node supports streaming
+        if not isinstance(agent, SupportsRunStream):
+            await ctx.output.print(f"❌ **Agent** `{agent_name}` **does not support streaming**")
+            return
+
+        # Stream subagent execution by wrapping events in SubAgentEvent
+        # The event handler system (ACP, OpenCode, CLI, etc.) handles rendering
+        # Get parent agent's context to access event emitter
+        parent_ctx = ctx.context.agent.get_context()
+
+        async for event in agent.run_stream(task_prompt):
+            wrapped = SubAgentEvent(
+                source_name=agent_name,
+                source_type="agent",
+                event=event,
+                depth=1,
+            )
+            # Emit to parent agent's event stream
+            await parent_ctx.events.emit_event(wrapped)

agentpool_commands/session.py

@@ -23,7 +23,7 @@ class ClearCommand(AgentCommand):
         Args:
             ctx: Command context
         """
-        ctx.context.agent.conversation.clear()
+        await ctx.context.agent.conversation.clear()
         await ctx.print("🧹 **Chat history cleared**")