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

agentpool_cli/__main__.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from importlib import metadata
+
 import typer as t
 
 from agentpool_cli import log
@@ -10,11 +12,14 @@ from agentpool_cli.cli_types import LogLevel  # noqa: TC001
 from agentpool_cli.history import history_cli
 from agentpool_cli.run import run_command
 from agentpool_cli.serve_acp import acp_command
+from agentpool_cli.serve_agui import agui_command
 from agentpool_cli.serve_api import api_command
 from agentpool_cli.serve_mcp import serve_command
+from agentpool_cli.serve_opencode import opencode_command
 from agentpool_cli.serve_vercel import vercel_command
 from agentpool_cli.store import ConfigStore
 from agentpool_cli.task import task_command
+from agentpool_cli.ui import ui_app
 from agentpool_cli.watch import watch_command
 
 
@@ -30,8 +35,24 @@ def get_command_help(base_help: str) -> str:
     return f"{base_help}\n\n(No active config set)"
 
 
+def version_callback(value: bool) -> None:
+    """Print version and exit."""
+    if value:
+        version = metadata.version("agentpool")
+        t.echo(f"agentpool version {version}")
+        raise t.Exit
+
+
 def main(
     ctx: t.Context,
+    version: bool = t.Option(
+        False,
+        "--version",
+        "-v",
+        help="Show version and exit",
+        callback=version_callback,
+        is_eager=True,
+    ),
     log_level: LogLevel = t.Option("info", "--log-level", "-l", help="Log level"),  # noqa: B008
 ) -> None:
     """🤖 AgentPool CLI - Run and manage LLM agents."""
@@ -54,12 +75,15 @@ cli.command(name="list-configs")(list_configs)
 cli.command(name="set")(set_active_file)
 cli.command(name="watch")(watch_command)
 cli.command(name="serve-acp")(acp_command)
+cli.command(name="serve-agui")(agui_command)
 cli.command(name="serve-mcp")(serve_command)
 cli.command(name="serve-api")(api_command)
+cli.command(name="serve-opencode")(opencode_command)
 cli.command(name="serve-vercel")(vercel_command)
 cli.command(name="task")(task_command)
 
 cli.add_typer(history_cli, name="history")
+cli.add_typer(ui_app, name="ui")
 
 
 if __name__ == "__main__":

agentpool_cli/create.py

@@ -115,7 +115,7 @@ def create(
             from upathtools import to_upath
 
             super().__init__()
-            agent = Agent(output_type=YAMLCode)
+            agent = Agent(output_type=YAMLCode, model="openai:gpt-5-nano")
             self.agent = agent
             self.current_config: str | None = None
             self.output_path = to_upath(output_path) if output_path else None

agentpool_cli/serve_acp.py

@@ -8,8 +8,9 @@ integration with file system access, permission handling, and terminal support.
 from __future__ import annotations
 
 import asyncio
+import json
 import os
-from typing import Annotated
+from typing import TYPE_CHECKING, Annotated, Literal
 
 from platformdirs import user_log_path
 import typer as t
@@ -17,10 +18,16 @@ import typer as t
 from agentpool_cli import log, resolve_agent_config
 
 
+if TYPE_CHECKING:
+    from acp import Transport
+    from agentpool_config.mcp_server import MCPServerConfig
+
+
 logger = log.get_logger(__name__)
 
 
-def acp_command(
+def acp_command(  # noqa: PLR0915
+    # Too many statements - complex CLI command with many options
     config: Annotated[str | None, t.Argument(help="Path to agent configuration (optional)")] = None,
     file_access: Annotated[
         bool,
@@ -49,13 +56,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 +77,35 @@ 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,
+    mcp_config: Annotated[
+        str | None,
+        t.Option(
+            "--mcp-config",
+            help='MCP servers configuration as JSON (format: {"mcpServers": {...}})',
+        ),
+    ] = None,
 ) -> None:
     r"""Run agents as an ACP (Agent Client Protocol) server.
 
@@ -99,9 +128,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 +156,80 @@ 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)
+
+    # Inject MCP servers from --mcp-config if provided
+    # TODO: Consider adding to specific agent's MCP manager instead of pool-level
+    # for better isolation (currently all agents in pool share these servers)
+    if mcp_config:
+        try:
+            mcp_data = json.loads(mcp_config)
+            if "mcpServers" not in mcp_data:
+                raise t.BadParameter("MCP config must contain 'mcpServers' key")
+
+            from agentpool_config.mcp_server import (
+                SSEMCPServerConfig,
+                StreamableHTTPMCPServerConfig,
+            )
+
+            for server_name, server_cfg in mcp_data["mcpServers"].items():
+                # Parse server config based on transport type
+                if "transport" in server_cfg:
+                    if server_cfg["transport"] == "sse":
+                        server: MCPServerConfig = SSEMCPServerConfig(
+                            name=server_name,
+                            url=server_cfg["url"],
+                        )
+                    elif server_cfg["transport"] == "http":
+                        server = StreamableHTTPMCPServerConfig(
+                            name=server_name,
+                            url=server_cfg["url"],
+                        )
+                    else:
+                        msg = f"Unsupported transport type: {server_cfg['transport']}"
+                        raise t.BadParameter(msg)
+                else:
+                    # Default to HTTP if no transport specified
+                    server = StreamableHTTPMCPServerConfig(
+                        name=server_name,
+                        url=server_cfg["url"],
+                    )
+
+                acp_server.pool.mcp.add_server_config(server)
+                logger.info(
+                    "Added MCP server from --mcp-config",
+                    server_name=server_name,
+                    url=server_cfg.get("url"),
+                )
+        except json.JSONDecodeError as e:
+            msg = f"Invalid JSON in --mcp-config: {e}"
+            raise t.BadParameter(msg) from e
+
     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.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)