agentpool 2.1.9__py3-none-any.whl

agentpool_cli/history.py

@@ -0,0 +1,217 @@
+"""History management commands."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Annotated
+
+import typer as t
+
+from agentpool_cli import log, resolve_agent_config
+from agentpool_cli.cli_types import GroupBy
+from agentpool_cli.common import OutputFormat, format_output, output_format_opt
+
+
+if TYPE_CHECKING:
+    from agentpool_storage.base import StorageProvider
+
+
+logger = log.get_logger(__name__)
+
+help_text = "Conversation history management"
+history_cli = t.Typer(name="history", help=help_text, no_args_is_help=True)
+
+AGENT_NAME_HELP = "Agent name (shows all if not provided)"
+SINCE_HELP = "Show conversations since (YYYY-MM-DD or YYYY-MM-DD HH:MM)"
+PERIOD_HELP = "Show conversations from last period (1h, 2d, 1w, 1m)"
+COMPACT_HELP = "Show only first/last message of conversations"
+TOKEN_HELP = "Include token usage statistics"
+CONFIG_HELP = "Override agent config path"
+
+
+def get_history_provider(config_path: str) -> StorageProvider:
+    """Get history provider from manifest config.
+
+    Args:
+        config_path: Path to agent configuration file
+
+    Returns:
+        Storage provider configured for history operations
+    """
+    from agentpool import AgentsManifest
+    from agentpool.storage import StorageManager
+
+    manifest = AgentsManifest.from_file(config_path)
+    storage = StorageManager(manifest.storage)
+    return storage.get_history_provider()
+
+
+@history_cli.command(name="show")
+def show_history(
+    agent_name: Annotated[str | None, t.Argument(help=AGENT_NAME_HELP)] = None,
+    config: Annotated[str | None, t.Option("--config", "-c", help=CONFIG_HELP)] = None,
+    # Time-based filtering
+    since: Annotated[datetime | None, t.Option("--since", "-s", help=SINCE_HELP)] = None,
+    period: Annotated[str | None, t.Option("--period", "-p", help=PERIOD_HELP)] = None,
+    # Content filtering
+    query: Annotated[
+        str | None, t.Option("--query", "-q", help="Search in message content")
+    ] = None,
+    model: Annotated[str | None, t.Option("--model", "-m", help="Filter by model used")] = None,
+    # Output control
+    limit: Annotated[int, t.Option("--limit", "-n", help="Number of conversations")] = 10,
+    compact: Annotated[bool, t.Option("--compact", help=COMPACT_HELP)] = False,
+    tokens: Annotated[bool, t.Option("--tokens", "-t", help=TOKEN_HELP)] = False,
+    output_format: OutputFormat = output_format_opt,
+) -> None:
+    """Show conversation history with filtering options.
+
+    Examples:
+        # Show last 5 conversations
+        agentpool history show -n 5
+
+        # Show conversations from last 24 hours
+        agentpool history show --period 24h
+
+        # Show conversations since specific date
+        agentpool history show --since 2024-01-01
+
+        # Search for specific content
+        agentpool history show --query "database schema"
+
+        # Show GPT-5 conversations with token usage
+        agentpool history show --model gpt-5 --tokens
+
+        # Compact view of recent conversations
+        agentpool history show --period 1d --compact
+    """
+    import anyio
+
+    try:
+        # Resolve config and get provider
+        config_path = resolve_agent_config(config)
+        provider = get_history_provider(config_path)
+
+        async def main() -> None:
+            async with provider:
+                results = await provider.get_filtered_conversations(
+                    agent_name=agent_name,
+                    period=period,
+                    since=since,
+                    query=query,
+                    model=model,
+                    limit=limit,
+                    compact=compact,
+                    include_tokens=tokens,
+                )
+                format_output(results, output_format)
+
+        anyio.run(main)
+
+    except Exception as e:
+        logger.exception("Failed to show history")
+        raise t.Exit(1) from e
+
+
+@history_cli.command(name="stats")
+def show_stats(
+    agent_name: Annotated[str | None, t.Argument(help=AGENT_NAME_HELP)] = None,
+    config: Annotated[str | None, t.Option("--config", "-c", help=CONFIG_HELP)] = None,
+    period: Annotated[
+        str, t.Option("--period", "-p", help="Time period (1h, 1d, 1w, 1m, 1y)")
+    ] = "1d",
+    group_by: Annotated[GroupBy, t.Option("--group-by", "-g", help="Group by")] = "agent",
+    output_format: OutputFormat = output_format_opt,
+) -> None:
+    """Show usage statistics.
+
+    Examples:
+        # Show stats for all agents
+        agentpool history stats
+
+        # Show daily stats for specific agent
+        agentpool history stats myagent --group-by day
+
+        # Show model usage for last week
+        agentpool history stats --period 1w --group-by model
+    """
+    import anyio
+
+    from agentpool.utils.parse_time import parse_time_period
+    from agentpool_storage.formatters import format_stats
+    from agentpool_storage.models import StatsFilters
+
+    try:
+        # Resolve config and get provider
+        config_path = resolve_agent_config(config)
+        provider = get_history_provider(config_path)
+
+        # Create filters
+        cutoff = datetime.now(UTC) - parse_time_period(period)
+        filters = StatsFilters(cutoff=cutoff, group_by=group_by, agent_name=agent_name)
+
+        async def main() -> None:
+            async with provider:
+                stats = await provider.get_conversation_stats(filters)
+            formatted = format_stats(stats, period, group_by)
+            format_output(formatted, output_format)
+
+        anyio.run(main)
+
+    except Exception as e:
+        logger.exception("Failed to show stats")
+        raise t.Exit(1) from e
+
+
+@history_cli.command(name="reset")
+def reset_history(
+    config: Annotated[str | None, t.Option("--config", "-c", help=CONFIG_HELP)] = None,
+    confirm: Annotated[bool, t.Option("--confirm", "-y", help="Confirm deletion")] = False,
+    agent_name: Annotated[
+        str | None, t.Option("--agent", "-a", help="Only delete for specific agent")
+    ] = None,
+    hard: Annotated[
+        bool, t.Option("--hard", help="Drop and recreate tables (for schema changes)")
+    ] = False,
+) -> None:
+    """Reset (clear) conversation history.
+
+    Examples:
+        # Clear all history (with confirmation)
+        agentpool history reset
+
+        # Clear without confirmation
+        agentpool history reset --confirm
+
+        # Clear history for specific agent
+        agentpool history reset --agent myagent
+
+        # Drop and recreate tables (for schema changes)
+        agentpool history reset --hard --confirm
+    """
+    import anyio
+
+    try:
+        # Resolve config and get provider
+        config_path = resolve_agent_config(config)
+        provider = get_history_provider(config_path)
+
+        if not confirm:
+            what = f" for {agent_name}" if agent_name else ""
+            msg = f"This will delete all history{what}. Are you sure? [y/N] "
+            if input(msg).lower() != "y":
+                print("Operation cancelled.")
+                return
+
+        async def main() -> None:
+            async with provider:
+                conv_count, msg_count = await provider.reset(agent_name=agent_name, hard=hard)
+
+                what = f" for {agent_name}" if agent_name else ""
+                print(f"Deleted {conv_count} conversations and {msg_count} messages{what}.")
+
+        anyio.run(main)
+
+    except Exception as e:
+        logger.exception("Failed to reset history")
+        raise t.Exit(1) from e

agentpool_cli/log.py

@@ -0,0 +1,78 @@
+"""Lightweight logging configuration for CLI startup.
+
+This is a simplified copy of agentpool.log to avoid importing the full
+agentpool package (which pulls in pydantic-ai, llmling-models, etc.)
+just for CLI help text.
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any
+
+import structlog
+
+
+_LOGGING_CONFIGURED = False
+
+
+def configure_logging(
+    level: str | int = "INFO",
+    *,
+    use_colors: bool | None = None,
+) -> None:
+    """Configure structlog and standard logging for CLI.
+
+    Args:
+        level: Logging level (e.g., "INFO", "DEBUG")
+        use_colors: Whether to use colored output (auto-detected if None)
+    """
+    global _LOGGING_CONFIGURED  # noqa: PLW0603
+
+    if _LOGGING_CONFIGURED:
+        return
+
+    if isinstance(level, str):
+        level = getattr(logging, level.upper())
+
+    # Determine if we should use colors
+    colors = sys.stderr.isatty() if use_colors is None else use_colors
+
+    # Configure standard logging
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(logging.Formatter("%(message)s"))
+    logging.basicConfig(level=level, handlers=[handler], force=True)
+
+    # Configure structlog
+    processors: list[Any] = [
+        structlog.stdlib.filter_by_level,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.UnicodeDecoder(),
+        structlog.dev.ConsoleRenderer(colors=colors),
+    ]
+
+    structlog.configure(
+        processors=processors,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+    _LOGGING_CONFIGURED = True
+
+
+def get_logger(name: str) -> structlog.stdlib.BoundLogger:
+    """Get a structlog logger for the given name.
+
+    Args:
+        name: The name of the logger
+
+    Returns:
+        A structlog BoundLogger instance
+    """
+    return structlog.get_logger(name)  # type: ignore[no-any-return]

agentpool_cli/run.py

@@ -0,0 +1,84 @@
+"""Run command for agent execution."""
+
+from __future__ import annotations
+
+import asyncio
+import traceback
+from typing import TYPE_CHECKING, Annotated, Any
+
+import typer as t
+
+from agentpool_cli import resolve_agent_config
+from agentpool_cli.cli_types import DetailLevel  # noqa: TC001
+from agentpool_cli.common import verbose_opt
+
+
+if TYPE_CHECKING:
+    from agentpool import ChatMessage
+
+
+def run_command(
+    node_name: Annotated[str, t.Argument(help="Agent / Team name to run")],
+    prompts: Annotated[list[str] | None, t.Argument(help="Additional prompts to send")] = None,
+    config_path: Annotated[
+        str | None, t.Option("-c", "--config", help="Override config path")
+    ] = None,
+    show_messages: Annotated[
+        bool, t.Option("--show-messages", help="Show all messages (not just final responses)")
+    ] = True,
+    detail_level: Annotated[
+        DetailLevel, t.Option("-d", "--detail", help="Output detail level")
+    ] = "simple",
+    show_metadata: Annotated[bool, t.Option("--metadata", help="Show message metadata")] = False,
+    show_costs: Annotated[bool, t.Option("--costs", help="Show token usage and costs")] = False,
+    verbose: bool = verbose_opt,
+) -> None:
+    """Single-shot run a node (agent/team) with prompts."""
+    try:
+        # Resolve configuration path
+        try:
+            config_path = resolve_agent_config(config_path)
+        except ValueError as e:
+            error_msg = str(e)
+            raise t.BadParameter(error_msg) from e
+
+        async def run() -> None:
+            from agentpool import AgentPool
+
+            async with AgentPool(config_path) as pool:
+
+                def on_message(chat_message: ChatMessage[Any]) -> None:
+                    print(
+                        chat_message.format(
+                            style=detail_level,
+                            show_metadata=show_metadata,
+                            show_costs=show_costs,
+                        )
+                    )
+
+                # Connect message handlers if showing all messages
+                if show_messages:
+                    for node in pool.nodes.values():
+                        node.message_sent.connect(on_message)
+                for prompt in prompts or []:
+                    response = await pool.nodes[node_name].run(prompt)
+
+                    if not show_messages:
+                        print(
+                            response.format(
+                                style=detail_level,
+                                show_metadata=show_metadata,
+                                show_costs=show_costs,
+                            )
+                        )
+
+        # Run the async code in the sync command
+        asyncio.run(run())
+
+    except t.Exit:
+        raise
+    except Exception as e:
+        t.echo(f"Error: {e}", err=True)
+        if verbose:
+            t.echo(traceback.format_exc(), err=True)
+        raise t.Exit(1) from e

agentpool_cli/serve_acp.py

@@ -0,0 +1,177 @@
+"""Command for running agents as an ACP (Agent Client Protocol) server.
+
+This creates an ACP-compatible JSON-RPC 2.0 server that exposes your agents
+for bidirectional communication over stdio streams, enabling desktop application
+integration with file system access, permission handling, and terminal support.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+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 acp_command(
+    config: Annotated[str | None, t.Argument(help="Path to agent configuration (optional)")] = None,
+    file_access: Annotated[
+        bool,
+        t.Option(
+            "--file-access/--no-file-access",
+            help="Enable file system access for agents",
+        ),
+    ] = True,
+    terminal_access: Annotated[
+        bool,
+        t.Option(
+            "--terminal-access/--no-terminal-access",
+            help="Enable terminal access for agents",
+        ),
+    ] = True,
+    show_messages: Annotated[
+        bool, t.Option("--show-messages", help="Show message activity in logs")
+    ] = False,
+    debug_messages: Annotated[
+        bool, t.Option("--debug-messages", help="Save raw JSON-RPC messages to debug file")
+    ] = False,
+    debug_file: Annotated[
+        str | None,
+        t.Option(
+            "--debug-file",
+            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(
+            "--debug-commands",
+            help="Enable debug slash commands for testing ACP notifications",
+        ),
+    ] = False,
+    agent: Annotated[
+        str | None,
+        t.Option(
+            "--agent",
+            help="Name of specific agent to use (defaults to first agent in config)",
+        ),
+    ] = None,
+    load_skills: Annotated[
+        bool,
+        t.Option(
+            "--skills/--no-skills",
+            help="Load client-side skills from .claude/skills directory",
+        ),
+    ] = True,
+) -> None:
+    r"""Run agents as an ACP (Agent Client Protocol) server.
+
+    This creates an ACP-compatible JSON-RPC 2.0 server that communicates over stdio
+    streams, enabling your agents to work with desktop applications that support
+    the Agent Client Protocol.
+
+    Configuration:
+    Config file is optional. Without a config file, creates a general-purpose
+    agent with default settings. This is useful for clients/installers that
+    start agents directly without configuration support.
+
+    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 "agentpool"
+    if no config provided).
+
+    Agent Mode Switching:
+    If your config defines multiple agents, the IDE will show a mode selector
+    allowing users to switch between agents mid-conversation. Each agent appears
+    as a different "mode" with its own name and capabilities.
+    """
+    from agentpool import log
+    from agentpool_server.acp_server import ACPServer
+
+    # 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 / "acp.log"
+    log.configure_logging(force=True, log_file=str(log_file))
+    logger.info("Configured file logging with rollover", log_file=str(log_file))
+
+    if config:
+        # Use config file
+        try:
+            config_path = resolve_agent_config(config)
+        except ValueError as e:
+            msg = str(e)
+            raise t.BadParameter(msg) from e
+
+        logger.info("Starting ACP server", config_path=config_path)
+        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,
+        )
+    else:
+        # Use default ACP assistant config
+        from agentpool.config_resources import ACP_ASSISTANT
+
+        logger.info("Starting ACP server with default configuration")
+        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,
+        )
+    # 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:
+        debug_path = debug_file or "acp-debug.jsonl"
+        logger.info("Raw JSON-RPC message debugging enabled", path=debug_path)
+    if debug_commands:
+        logger.info("Debug slash commands enabled")
+    logger.info("Server PID", pid=os.getpid())
+
+    async def run_acp_server() -> None:
+        try:
+            async with acp_server:
+                await acp_server.start()
+        except KeyboardInterrupt:
+            logger.info("ACP server shutdown requested")
+        except Exception as e:
+            logger.exception("ACP server error")
+            raise t.Exit(1) from e
+
+    asyncio.run(run_acp_server())
+
+
+if __name__ == "__main__":
+    t.run(acp_command)

agentpool_cli/serve_api.py

@@ -0,0 +1,69 @@
+"""Command for running agents as a completions API 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 api_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")] = 8000,
+    cors: Annotated[bool, t.Option(help="Enable CORS")] = True,
+    show_messages: Annotated[
+        bool, t.Option("--show-messages", help="Show message activity")
+    ] = False,
+    docs: Annotated[bool, t.Option(help="Enable API documentation")] = True,
+) -> None:
+    """Run agents as a completions API server.
+
+    This creates an OpenAI-compatible API server that makes your agents available
+    through a standard completions API interface.
+    """
+    import uvicorn
+
+    from agentpool import AgentPool, AgentsManifest
+    from agentpool_server.openai_api_server.server import OpenAIAPIServer
+
+    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)
+    pool = AgentPool(manifest)
+
+    if show_messages:
+        for agent in pool.agents.values():
+            agent.message_sent.connect(on_message)
+
+    server = OpenAIAPIServer(pool, cors=cors, docs=docs)
+
+    # Get log level from the global context
+    log_level = ctx.obj.get("log_level", "info") if ctx.obj else "info"
+    uvicorn.run(server.app, host=host, port=port, log_level=log_level.lower())
+
+
+if __name__ == "__main__":
+    import typer
+
+    typer.run(api_command)

agentpool_cli/serve_mcp.py

@@ -0,0 +1,74 @@
+"""Command for running agents as an MCP server."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import TYPE_CHECKING, Annotated, Any, Literal
+
+import typer as t
+
+from agentpool_cli import log
+
+
+# Duplicated from agentpool_config.pool_server to avoid heavy imports at CLI startup
+TransportType = Literal["stdio", "sse", "streamable-http"]
+
+if TYPE_CHECKING:
+    from agentpool import ChatMessage
+
+
+logger = log.get_logger(__name__)
+
+
+def serve_command(
+    config: Annotated[str, t.Argument(help="Path to agent configuration")],
+    transport: Annotated[TransportType, t.Option(help="Transport type")] = "stdio",
+    host: Annotated[
+        str, t.Option(help="Host to bind server to (sse/streamable-http only)")
+    ] = "localhost",
+    port: Annotated[int, t.Option(help="Port to listen on (sse/streamable-http only)")] = 3001,
+    zed_mode: Annotated[bool, t.Option(help="Enable Zed editor compatibility")] = False,
+    show_messages: Annotated[
+        bool, t.Option("--show-messages", help="Show message activity")
+    ] = False,
+) -> None:
+    """Run agents as an MCP server.
+
+    This makes agents available as tools to other applications, regardless of
+    whether pool_server is configured in the manifest.
+    """
+
+    def on_message(message: ChatMessage[Any]) -> None:
+        print(message.format(style="simple"))
+
+    async def run_server() -> None:
+
+        from agentpool import AgentPool, AgentsManifest
+        from agentpool_config.pool_server import MCPPoolServerConfig
+        from agentpool_server.mcp_server.server import MCPServer
+
+        logger.info("Server PID", pid=os.getpid())
+        # Load manifest and create pool (without server config)
+        manifest = AgentsManifest.from_file(config)
+        pool = AgentPool(manifest)
+        # Create server config and server externally
+        server_config = MCPPoolServerConfig(
+            enabled=True,
+            transport=transport,
+            host=host,
+            port=port,
+            zed_mode=zed_mode,
+        )
+        server = MCPServer(pool, server_config)
+        async with pool, server:
+            if show_messages:
+                for agent in pool.agents.values():
+                    agent.message_sent.connect(on_message)
+
+            try:
+                await server.start()  # Blocks until server stops
+            except KeyboardInterrupt:
+                logger.info("Server shutdown requested")
+
+    asyncio.run(run_server())