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

agentpool_cli/serve_acp.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import asyncio
 import os
-from typing import Annotated
+from typing import TYPE_CHECKING, Annotated, Literal
 
 from platformdirs import user_log_path
 import typer as t
@@ -17,6 +17,10 @@ import typer as t
 from agentpool_cli import log, resolve_agent_config
 
 
+if TYPE_CHECKING:
+    from acp import Transport
+
+
 logger = log.get_logger(__name__)
 
 
@@ -49,13 +53,6 @@ def acp_command(
             help="File to save JSON-RPC debug messages (default: acp-debug.jsonl)",
         ),
     ] = None,
-    providers: Annotated[
-        list[str] | None,
-        t.Option(
-            "--model-provider",
-            help="Providers to search for models (can be specified multiple times)",
-        ),
-    ] = None,
     debug_commands: Annotated[
         bool,
         t.Option(
@@ -77,6 +74,28 @@ def acp_command(
             help="Load client-side skills from .claude/skills directory",
         ),
     ] = True,
+    transport: Annotated[
+        Literal["stdio", "websocket"],
+        t.Option(
+            "--transport",
+            "-t",
+            help="Transport type: stdio (default) or websocket",
+        ),
+    ] = "stdio",
+    ws_host: Annotated[
+        str,
+        t.Option(
+            "--ws-host",
+            help="WebSocket host (only used with --transport websocket)",
+        ),
+    ] = "localhost",
+    ws_port: Annotated[
+        int,
+        t.Option(
+            "--ws-port",
+            help="WebSocket port (only used with --transport websocket)",
+        ),
+    ] = 8765,
 ) -> None:
     r"""Run agents as an ACP (Agent Client Protocol) server.
 
@@ -99,9 +118,19 @@ def acp_command(
     allowing users to switch between agents mid-conversation. Each agent appears
     as a different "mode" with its own name and capabilities.
     """
+    from acp import StdioTransport, WebSocketTransport
     from agentpool import log
+    from agentpool.config_resources import ACP_ASSISTANT
     from agentpool_server.acp_server import ACPServer
 
+    # Build transport config
+    if transport == "websocket":
+        transport_config: Transport = WebSocketTransport(host=ws_host, port=ws_port)
+    elif transport == "stdio":
+        transport_config = StdioTransport()
+    else:
+        raise t.BadParameter(f"Unknown transport: {transport}. Use 'stdio' or 'websocket'.")
+
     # Always log to file with rollover
     log_dir = user_log_path("agentpool", appauthor=False)
     log_dir.mkdir(parents=True, exist_ok=True)
@@ -117,40 +146,32 @@ def acp_command(
             msg = str(e)
             raise t.BadParameter(msg) from e
 
-        logger.info("Starting ACP server", config_path=config_path)
+        logger.info("Starting ACP server", config_path=config_path, transport=transport)
         acp_server = ACPServer.from_config(
             config_path,
             file_access=file_access,
             terminal_access=terminal_access,
-            providers=providers,  # type: ignore[arg-type]
             debug_messages=debug_messages,
             debug_file=debug_file or "acp-debug.jsonl" if debug_messages else None,
             debug_commands=debug_commands,
             agent=agent,
             load_skills=load_skills,
+            transport=transport_config,
         )
     else:
         # Use default ACP assistant config
-        from agentpool.config_resources import ACP_ASSISTANT
-
-        logger.info("Starting ACP server with default configuration")
+        logger.info("Starting ACP server with default configuration", transport=transport)
         acp_server = ACPServer.from_config(
             ACP_ASSISTANT,
             file_access=file_access,
             terminal_access=terminal_access,
-            providers=providers,  # type: ignore[arg-type]
             debug_messages=debug_messages,
             debug_file=debug_file or "acp-debug.jsonl" if debug_messages else None,
             debug_commands=debug_commands,
             agent=agent,
             load_skills=load_skills,
+            transport=transport_config,
         )
-    # Configure agent capabilities
-    agent_count = len(acp_server.pool.all_agents)
-    if agent_count == 0:
-        logger.error("No agents found in configuration")
-        raise t.Exit(1)
-    logger.info("Configured agents for ACP protocol", count=agent_count)
     if show_messages:
         logger.info("Message activity logging enabled")
     if debug_messages:

agentpool_cli/serve_agui.py

@@ -0,0 +1,87 @@
+"""Command for running agents as an AG-UI server."""
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Annotated, Any
+
+import typer as t
+
+from agentpool_cli import resolve_agent_config
+from agentpool_cli.log import get_logger
+
+
+if TYPE_CHECKING:
+    from agentpool import ChatMessage
+
+
+logger = get_logger(__name__)
+
+
+def agui_command(
+    ctx: t.Context,
+    config: Annotated[str | None, t.Argument(help="Path to agent configuration")] = None,
+    host: Annotated[str, t.Option(help="Host to bind server to")] = "localhost",
+    port: Annotated[int, t.Option(help="Port to listen on")] = 8002,
+    show_messages: Annotated[
+        bool, t.Option("--show-messages", help="Show message activity")
+    ] = False,
+) -> None:
+    """Run agents as an AG-UI server.
+
+    This creates an AG-UI protocol server that makes your agents available
+    through the AG-UI interface, compatible with AG-UI clients like Toad.
+
+    Each agent is accessible at /{agent_name} route.
+    """
+    import anyio
+
+    from agentpool import AgentPool, AgentsManifest
+    from agentpool_server.agui_server import AGUIServer
+
+    logger.info("Server PID", pid=os.getpid())
+
+    def on_message(message: ChatMessage[Any]) -> None:
+        print(message.format(style="simple"))
+
+    try:
+        config_path = resolve_agent_config(config)
+    except ValueError as e:
+        msg = str(e)
+        raise t.BadParameter(msg) from e
+
+    manifest = AgentsManifest.from_file(config_path)
+
+    async def run_server() -> None:
+        async with AgentPool(manifest) as pool:
+            if show_messages:
+                for agent in pool.agents.values():
+                    agent.message_sent.connect(on_message)
+
+            server = AGUIServer(pool, host=host, port=port)
+            async with server:
+                logger.info(
+                    "AG-UI server started",
+                    host=host,
+                    port=port,
+                    agents=list(pool.agents.keys()),
+                )
+                # List agent routes
+                for name, url in server.list_agent_routes().items():
+                    logger.info("Agent route", agent=name, url=url)
+
+                async with server.run_context():
+                    # Keep running until interrupted
+                    try:
+                        while True:
+                            await anyio.sleep(1)
+                    except KeyboardInterrupt:
+                        logger.info("Shutting down AG-UI server")
+
+    anyio.run(run_server)
+
+
+if __name__ == "__main__":
+    import typer
+
+    typer.run(agui_command)

agentpool_cli/serve_opencode.py

@@ -0,0 +1,119 @@
+"""Command for running agents as an OpenCode-compatible server.
+
+This creates an HTTP server that implements the OpenCode API protocol,
+allowing OpenCode TUI and SDK clients to interact with AgentPool agents.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from platformdirs import user_log_path
+import typer as t
+
+from agentpool_cli import log, resolve_agent_config
+
+
+logger = log.get_logger(__name__)
+
+
+def opencode_command(
+    config: Annotated[str | None, t.Argument(help="Path to agent configuration (optional)")] = None,
+    host: Annotated[
+        str,
+        t.Option("--host", "-h", help="Host to bind to"),
+    ] = "127.0.0.1",
+    port: Annotated[
+        int,
+        t.Option("--port", "-p", help="Port to listen on"),
+    ] = 4096,
+    agent: Annotated[
+        str | None,
+        t.Option(
+            "--agent",
+            help="Name of specific agent to use (defaults to first agent in config)",
+        ),
+    ] = None,
+    working_dir: Annotated[
+        str | None,
+        t.Option(
+            "--working-dir",
+            "-w",
+            help="Working directory for file operations (defaults to current directory)",
+        ),
+    ] = None,
+) -> None:
+    """Run agents as an OpenCode-compatible HTTP server.
+
+    This creates an HTTP server implementing the OpenCode API protocol,
+    enabling your AgentPool agents to work with OpenCode TUI and SDK clients.
+
+    Configuration:
+    Config file is optional. Without a config file, creates a general-purpose
+    agent with default settings similar to the ACP server.
+
+    Agent Selection:
+    Use --agent to specify which agent to use by name. Without this option,
+    the first agent in your config is used as the default (or "assistant"
+    if no config provided).
+
+    Examples:
+        # Start with default agent
+        agentpool serve-opencode
+
+        # Start with specific config
+        agentpool serve-opencode agents.yml
+
+        # Start on custom port with specific agent
+        agentpool serve-opencode --port 8080 --agent myagent agents.yml
+    """
+    from agentpool import AgentPool, log as ap_log
+    from agentpool.config_resources import CLAUDE_CODE_ASSISTANT
+    from agentpool_server.opencode_server import OpenCodeServer
+
+    # Always log to file with rollover
+    log_dir = user_log_path("agentpool", appauthor=False)
+    log_dir.mkdir(parents=True, exist_ok=True)
+    log_file = log_dir / "opencode.log"
+    ap_log.configure_logging(force=True, log_file=str(log_file))
+    logger.info("Configured file logging with rollover", log_file=str(log_file))
+
+    # Resolve config path (use default if not provided)
+    if config:
+        try:
+            config_path = resolve_agent_config(config)
+        except ValueError as e:
+            raise t.BadParameter(str(e)) from e
+    else:
+        config_path = CLAUDE_CODE_ASSISTANT
+
+    logger.info("Starting OpenCode server", config_path=config_path, host=host, port=port)
+
+    # Load agent from config
+    pool = AgentPool(config_path)
+
+    async def run_server() -> None:
+        async with pool:
+            server = OpenCodeServer(
+                pool,
+                host=host,
+                port=port,
+                working_dir=working_dir,
+                agent_name=agent,
+            )
+            logger.info("Server starting", url=f"http://{host}:{port}")
+            await server.run_async()
+
+    import asyncio
+
+    try:
+        asyncio.run(run_server())
+    except KeyboardInterrupt:
+        logger.info("OpenCode server shutdown requested")
+    except Exception as e:
+        logger.exception("OpenCode server error")
+        raise t.Exit(1) from e
+
+
+if __name__ == "__main__":
+    t.run(opencode_command)

agentpool_commands/__init__.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from agentpool_commands.base import NodeCommand
 from agentpool_commands.agents import (
     CreateAgentCommand,
+    CreateTeamCommand,
     ListAgentsCommand,
     ShowAgentCommand,
     # SwitchAgentCommand,
@@ -15,6 +16,12 @@ from agentpool_commands.connections import (
     ListConnectionsCommand,
     DisconnectAllCommand,
 )
+from agentpool_commands.history import SearchHistoryCommand
+from agentpool_commands.mcp import (
+    AddMCPServerCommand,
+    AddRemoteMCPServerCommand,
+    ListMCPServersCommand,
+)
 from agentpool_commands.models import SetModelCommand
 from agentpool_commands.prompts import ListPromptsCommand, ShowPromptCommand
 from agentpool_commands.resources import (
@@ -28,6 +35,7 @@ from agentpool_commands.tools import (
     DisableToolCommand,
     EnableToolCommand,
     ListToolsCommand,
+    RegisterCodeToolCommand,
     RegisterToolCommand,
     ShowToolCommand,
 )
@@ -39,6 +47,7 @@ from agentpool_commands.workers import (
 from agentpool_commands.utils import (
     CopyClipboardCommand,
     EditAgentFileCommand,
+    GetLogsCommand,
     ShareHistoryCommand,
 )
 from typing import TYPE_CHECKING, Any
@@ -64,6 +73,7 @@ def get_agent_commands(**kwargs: Any) -> Sequence[BaseCommand | type[SlashedComm
         "enable_enable_tool": EnableToolCommand,
         "enable_disable_tool": DisableToolCommand,
         "enable_register_tool": RegisterToolCommand,
+        "enable_register_code_tool": RegisterCodeToolCommand,
         "enable_list_resources": ListResourcesCommand,
         "enable_show_resource": ShowResourceCommand,
         "enable_add_resource": AddResourceCommand,
@@ -77,6 +87,11 @@ def get_agent_commands(**kwargs: Any) -> Sequence[BaseCommand | type[SlashedComm
         "enable_list_connections": ListConnectionsCommand,
         "enable_disconnect_all": DisconnectAllCommand,
         "enable_read": ReadCommand,
+        "enable_add_mcp_server": AddMCPServerCommand,
+        "enable_add_remote_mcp_server": AddRemoteMCPServerCommand,
+        "enable_list_mcp_servers": ListMCPServersCommand,
+        "enable_search_history": SearchHistoryCommand,
+        "enable_get_logs": GetLogsCommand,
     }
     return [command for flag, command in command_map.items() if kwargs.get(flag, True)]
 
@@ -85,6 +100,7 @@ def get_pool_commands(**kwargs: Any) -> Sequence[BaseCommand | type[SlashedComma
     """Get commands that operate on multiple agents or the pool itself."""
     command_map = {
         "enable_create_agent": CreateAgentCommand,
+        "enable_create_team": CreateTeamCommand,
         "enable_list_agents": ListAgentsCommand,
         "enable_show_agent": ShowAgentCommand,
         "enable_edit_agent_file": EditAgentFileCommand,
@@ -123,6 +139,7 @@ def get_commands(
     enable_enable_tool: bool = True,
     enable_disable_tool: bool = True,
     enable_register_tool: bool = True,
+    enable_register_code_tool: bool = True,
     enable_list_resources: bool = True,
     enable_show_resource: bool = True,
     enable_add_resource: bool = True,
@@ -136,7 +153,13 @@ def get_commands(
     enable_list_connections: bool = True,
     enable_disconnect_all: bool = True,
     enable_read: bool = True,
+    enable_add_mcp_server: bool = True,
+    enable_add_remote_mcp_server: bool = True,
+    enable_list_mcp_servers: bool = True,
+    enable_search_history: bool = True,
+    enable_get_logs: bool = True,
     enable_create_agent: bool = True,
+    enable_create_team: bool = True,
     enable_list_agents: bool = True,
     enable_show_agent: bool = True,
     enable_edit_agent_file: bool = True,
@@ -153,6 +176,7 @@ def get_commands(
         "enable_enable_tool": enable_enable_tool,
         "enable_disable_tool": enable_disable_tool,
         "enable_register_tool": enable_register_tool,
+        "enable_register_code_tool": enable_register_code_tool,
         "enable_list_resources": enable_list_resources,
         "enable_show_resource": enable_show_resource,
         "enable_add_resource": enable_add_resource,
@@ -166,9 +190,15 @@ def get_commands(
         "enable_list_connections": enable_list_connections,
         "enable_disconnect_all": enable_disconnect_all,
         "enable_read": enable_read,
+        "enable_add_mcp_server": enable_add_mcp_server,
+        "enable_add_remote_mcp_server": enable_add_remote_mcp_server,
+        "enable_list_mcp_servers": enable_list_mcp_servers,
+        "enable_search_history": enable_search_history,
+        "enable_get_logs": enable_get_logs,
     }
     pool_kwargs = {
         "enable_create_agent": enable_create_agent,
+        "enable_create_team": enable_create_team,
         "enable_list_agents": enable_list_agents,
         "enable_show_agent": enable_show_agent,
         "enable_edit_agent_file": enable_edit_agent_file,

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.
 
@@ -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