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

agentpool_server/acp_server/commands/acp_commands.py

@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
+from pydantic_ai import ModelRequest, ModelResponse  # noqa: TC002
 from slashed import CommandContext  # noqa: TC002
 
 from agentpool.messaging.context import NodeContext  # noqa: TC001
@@ -12,10 +11,6 @@ from agentpool_config.session import SessionQuery
 from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
 
 
-if TYPE_CHECKING:
-    from pydantic_ai import ModelRequest, ModelResponse
-
-
 class ListSessionsCommand(NodeCommand):
     """List all available ACP sessions.
 
@@ -27,17 +22,23 @@ class ListSessionsCommand(NodeCommand):
     Options:
       --active    Show only active sessions
       --stored    Show only stored sessions
+      --detail    Show detailed view (default: compact table)
+      --page      Page number (1-based, default: 1)
+      --per-page  Items per page (default: 20)
     """
 
     name = "list-sessions"
     category = "acp"
 
-    async def execute_command(
+    async def execute_command(  # noqa: PLR0915
         self,
         ctx: CommandContext[NodeContext[ACPSession]],
         *,
         active: bool = False,
         stored: bool = False,
+        detail: bool = False,
+        page: int = 1,
+        per_page: int = 20,
     ) -> None:
         """List available ACP sessions.
 
@@ -45,6 +46,9 @@ class ListSessionsCommand(NodeCommand):
             ctx: Command context with ACP session
             active: Show only active sessions
             stored: Show only stored sessions
+            detail: Show detailed view instead of compact table
+            page: Page number (1-based)
+            per_page: Number of items per page
         """
         session = ctx.context.data
         if not session:
@@ -54,6 +58,11 @@ class ListSessionsCommand(NodeCommand):
             await ctx.output.print("❌ **Session manager not available**")
             return
 
+        # Validate pagination params
+        page = max(page, 1)
+        if per_page < 1:
+            per_page = 20
+
         # If no filter specified, show both
         if not active and not stored:
             active = stored = True
@@ -61,63 +70,117 @@ class ListSessionsCommand(NodeCommand):
         try:
             output_lines = ["## 📋 ACP Sessions\n"]
 
-            # Show active sessions
+            # Collect all sessions to paginate
+            all_sessions: list[tuple[str, str, dict[str, str | None]]] = []  # (id, type, info)
+
+            # Collect active sessions
             if active:
-                output_lines.append("### 🟢 Active Sessions")
                 active_sessions = session.manager._active
-
-                if not active_sessions:
-                    output_lines.append("*No active sessions*\n")
-                else:
-                    for session_id, sess in active_sessions.items():
-                        agent_name = sess.current_agent_name
-                        cwd = sess.cwd or "unknown"
-                        is_current = session_id == session.session_id
-
-                        # Get title from SessionData
-                        session_data = await session.manager.session_manager.store.load(session_id)
-                        title = session_data.title if session_data else None
-
-                        status = " *(current)*" if is_current else ""
-                        title_text = f": {title}" if title else ""
-                        output_lines.append(f"- **{session_id}**{status}{title_text}")
-                        output_lines.append(f"  - Agent: `{agent_name}`")
-                        output_lines.append(f"  - Directory: `{cwd}`")
-                    output_lines.append("")
-
-            # Show stored sessions
+                for session_id, sess in active_sessions.items():
+                    session_data = await session.manager.session_manager.store.load(session_id)
+                    title = session_data.title if session_data else None
+                    is_current = session_id == session.session_id
+                    all_sessions.append((
+                        session_id,
+                        "active",
+                        {
+                            "agent_name": sess.current_agent_name,
+                            "cwd": sess.cwd or "unknown",
+                            "title": title,
+                            "is_current": "yes" if is_current else None,
+                            "last_active": None,
+                        },
+                    ))
+
+            # Collect stored sessions
             if stored:
-                output_lines.append("### 💾 Stored Sessions")
-
                 try:
                     stored_session_ids = await session.manager.session_manager.store.list_sessions()
-                    # Filter out active ones if we already showed them
+                    # Filter out active ones if we already collected them
                     if active:
                         stored_session_ids = [
                             sid for sid in stored_session_ids if sid not in session.manager._active
                         ]
 
-                    if not stored_session_ids:
-                        output_lines.append("*No stored sessions*\n")
-                    else:
-                        for session_id in stored_session_ids:
-                            session_data = await session.manager.session_manager.store.load(
-                                session_id
-                            )
-                            if session_data:
-                                title_text = f": {session_data.title}" if session_data.title else ""
-                                output_lines.append(f"- **{session_id}**{title_text}")
-                                output_lines.append(f"  - Agent: `{session_data.agent_name}`")
-                                output_lines.append(
-                                    f"  - Directory: `{session_data.cwd or 'unknown'}`"
-                                )
-                                output_lines.append(
-                                    f"  - Last active: {session_data.last_active.strftime('%Y-%m-%d %H:%M')}"  # noqa: E501
-                                )
-                        output_lines.append("")
+                    for session_id in stored_session_ids:
+                        session_data = await session.manager.session_manager.store.load(session_id)
+                        if session_data:
+                            all_sessions.append((
+                                session_id,
+                                "stored",
+                                {
+                                    "agent_name": session_data.agent_name,
+                                    "cwd": session_data.cwd or "unknown",
+                                    "title": session_data.title,
+                                    "is_current": None,
+                                    "last_active": session_data.last_active.strftime(
+                                        "%Y-%m-%d %H:%M"
+                                    ),
+                                },
+                            ))
                 except Exception as e:  # noqa: BLE001
                     output_lines.append(f"*Error loading stored sessions: {e}*\n")
 
+            # Calculate pagination
+            total_count = len(all_sessions)
+            total_pages = (total_count + per_page - 1) // per_page if total_count > 0 else 1
+            page = min(page, total_pages)
+
+            start_idx = (page - 1) * per_page
+            end_idx = start_idx + per_page
+            page_sessions = all_sessions[start_idx:end_idx]
+
+            if not page_sessions:
+                output_lines.append("*No sessions found*\n")
+            elif detail:
+                # Detailed view (original format)
+                active_in_page = [(s, i) for s, t, i in page_sessions if t == "active"]
+                stored_in_page = [(s, i) for s, t, i in page_sessions if t == "stored"]
+
+                if active_in_page:
+                    output_lines.append("### 🟢 Active Sessions")
+                    for session_id, info in active_in_page:
+                        status = " *(current)*" if info["is_current"] else ""
+                        title_text = f": {info['title']}" if info["title"] else ""
+                        output_lines.append(f"- **{session_id}**{status}{title_text}")
+                        output_lines.append(f"  - Agent: `{info['agent_name']}`")
+                        output_lines.append(f"  - Directory: `{info['cwd']}`")
+                    output_lines.append("")
+
+                if stored_in_page:
+                    output_lines.append("### 💾 Stored Sessions")
+                    for session_id, info in stored_in_page:
+                        title_text = f": {info['title']}" if info["title"] else ""
+                        output_lines.append(f"- **{session_id}**{title_text}")
+                        output_lines.append(f"  - Agent: `{info['agent_name']}`")
+                        output_lines.append(f"  - Directory: `{info['cwd']}`")
+                        if info["last_active"]:
+                            output_lines.append(f"  - Last active: {info['last_active']}")
+                    output_lines.append("")
+            else:
+                # Compact table view (default)
+                output_lines.append("| Title | Agent | Last Active |")
+                output_lines.append("|-------|-------|-------------|")
+                for session_id, _session_type, info in page_sessions:
+                    title = info["title"] or session_id[:16]
+                    if info["is_current"]:
+                        title = f"▶️ {title}"
+                    agent = info["agent_name"]
+                    last_active = info["last_active"] or "-"
+                    output_lines.append(f"| {title} | {agent} | {last_active} |")
+                output_lines.append("")
+
+            # Add pagination info
+            output_lines.append(f"---\n*Page {page}/{total_pages} ({total_count} total sessions)*")
+            if total_pages > 1:
+                nav_hints = []
+                if page > 1:
+                    nav_hints.append(f"`/list-sessions --page {page - 1}` for previous")
+                if page < total_pages:
+                    nav_hints.append(f"`/list-sessions --page {page + 1}` for next")
+                if nav_hints:
+                    output_lines.append(f"*{', '.join(nav_hints)}*")
+
             await ctx.output.print("\n".join(output_lines))
 
         except Exception as e:  # noqa: BLE001
@@ -582,6 +645,107 @@ class SetPoolCommand(NodeCommand):
             await ctx.output.print(f"❌ **Error switching pool:** {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.
+
+    This will:
+    - Apply configured compaction steps (filter, truncate, summarize)
+    - Reduce the message history while preserving important context
+    - Report the reduction in message count
+
+    Options:
+      --preset <name>   Use a specific preset (minimal, balanced, summarizing)
+
+    Examples:
+      /compact
+      /compact --preset=minimal
+    """
+
+    name = "compact"
+    category = "acp"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[ACPSession]],
+        *,
+        preset: str | None = None,
+    ) -> None:
+        """Compact the conversation history.
+
+        Args:
+            ctx: Command context with ACP session
+            preset: Optional preset name (minimal, balanced, summarizing)
+        """
+        session = ctx.context.data
+        if not session:
+            raise RuntimeError("Session not available in command context")
+
+        agent = session.agent
+
+        # 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:
+                pipeline = session.agent_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}")
+
+
 def get_acp_commands() -> list[type[NodeCommand]]:
     """Get all ACP-specific slash commands."""
     return [
@@ -591,4 +755,5 @@ def get_acp_commands() -> list[type[NodeCommand]]:
         DeleteSessionCommand,
         ListPoolsCommand,
         SetPoolCommand,
+        CompactCommand,
     ]

agentpool_server/acp_server/commands/docs_commands/fetch_repo.py

@@ -66,10 +66,7 @@ class FetchRepoCommand(NodeCommand):
         """
         session = ctx.context.data
         assert session
-
-        # Generate tool call ID
-        tool_call_id = f"fetch-repo-{uuid.uuid4().hex[:8]}"
-
+        tc_id = f"fetch-repo-{uuid.uuid4().hex[:8]}"
         try:
             # Build URL
             base_url = f"https://uithub.com/{repo}"
@@ -113,7 +110,7 @@ class FetchRepoCommand(NodeCommand):
                 display_path += f":{path}"
 
             await session.notifications.tool_call_start(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 title=f"Fetching repository: {display_path}",
                 kind="fetch",
             )
@@ -134,11 +131,10 @@ class FetchRepoCommand(NodeCommand):
                 content=f"Repository contents from {display_path}:\n\n{content}"
             )
             session.staged_content.add([staged_part])
-
             # Send successful result - wrap in code block for proper display
             staged_count = len(session.staged_content)
             await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 status="completed",
                 title=f"Repository {display_path} fetched and staged ({staged_count} total parts)",
                 content=[f"```\n{content}\n```"],
@@ -149,21 +145,25 @@ class FetchRepoCommand(NodeCommand):
                 "HTTP error fetching repository", repo=repo, status=e.response.status_code
             )
             await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 status="failed",
                 title=f"HTTP {e.response.status_code}: Failed to fetch {repo}",
             )
         except httpx.RequestError as e:
             logger.exception("Request error fetching repository", repo=repo)
             await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 status="failed",
                 title=f"Network error: {e}",
             )
         except Exception as e:
             logger.exception("Unexpected error fetching repository", repo=repo)
             await session.notifications.tool_call_progress(
-                tool_call_id=tool_call_id,
+                tool_call_id=tc_id,
                 status="failed",
                 title=f"Error: {e}",
             )
+
+
+if __name__ == "__main__":
+    cmd = FetchRepoCommand()

agentpool_server/acp_server/server.py

@@ -7,14 +7,10 @@ the Agent Client Protocol.
 from __future__ import annotations
 
 import asyncio
-from datetime import timedelta
 import functools
 from typing import TYPE_CHECKING, Any, Self
 
-import logfire
-
-from acp import AgentSideConnection
-from acp.stdio import stdio_streams
+from acp import serve
 from agentpool import AgentPool
 from agentpool.log import get_logger
 from agentpool.models.manifest import AgentsManifest
@@ -23,41 +19,14 @@ from agentpool_server.acp_server.acp_agent import AgentPoolACPAgent
 
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
-
-    from tokonomics.model_discovery import ProviderType
-    from tokonomics.model_discovery.model_info import ModelInfo
     from upathtools import JoinablePathLike
 
-    from acp.schema import ModelInfo as ACPModelInfo
+    from acp import Transport
 
 
 logger = get_logger(__name__)
 
 
-def _convert_to_acp_model_info(
-    toko_models: Sequence[ModelInfo],
-) -> list[ACPModelInfo]:
-    """Convert tokonomics ModelInfo list to ACP ModelInfo list.
-
-    Args:
-        toko_models: List of tokonomics ModelInfo objects
-
-    Returns:
-        List of ACP ModelInfo objects with pydantic_ai_id as model_id
-    """
-    from acp.schema import ModelInfo as ACPModelInfo
-
-    return [
-        ACPModelInfo(
-            model_id=model.pydantic_ai_id,
-            name=f"{model.provider}: {model.name}" if model.provider else model.name,
-            description=model.format(),
-        )
-        for model in toko_models
-    ]
-
-
 class ACPServer(BaseServer):
     """ACP (Agent Client Protocol) server for agentpool using external library.
 
@@ -75,13 +44,13 @@ class ACPServer(BaseServer):
         name: str | None = None,
         file_access: bool = True,
         terminal_access: bool = True,
-        providers: list[ProviderType] | None = None,
         debug_messages: bool = False,
         debug_file: str | None = None,
         debug_commands: bool = False,
         agent: str | None = None,
         load_skills: bool = True,
         config_path: str | None = None,
+        transport: Transport = "stdio",
     ) -> None:
         """Initialize ACP server with configuration.
 
@@ -90,27 +59,24 @@ class ACPServer(BaseServer):
             name: Optional Server name (auto-generated if None)
             file_access: Whether to support file access operations
             terminal_access: Whether to support terminal access operations
-            providers: List of providers to use for model discovery (None = openrouter)
             debug_messages: Whether to enable debug message logging
             debug_file: File path for debug message logging
             debug_commands: Whether to enable debug slash commands for testing
             agent: Optional specific agent name to use (defaults to first agent)
             load_skills: Whether to load client-side skills from .claude/skills
             config_path: Path to the configuration file (for tracking/hot-switching)
+            transport: Transport configuration ("stdio", "websocket", or transport object)
         """
         super().__init__(pool, name=name, raise_exceptions=True)
         self.file_access = file_access
         self.terminal_access = terminal_access
-        self.providers = providers or ["openai", "anthropic", "gemini"]
         self.debug_messages = debug_messages
         self.debug_file = debug_file
         self.debug_commands = debug_commands
         self.agent = agent
         self.load_skills = load_skills
         self.config_path = config_path
-
-        self._available_models: list[ACPModelInfo] = []
-        self._models_initialized = False
+        self.transport: Transport = transport
 
     @classmethod
     def from_config(
@@ -119,12 +85,12 @@ class ACPServer(BaseServer):
         *,
         file_access: bool = True,
         terminal_access: bool = True,
-        providers: list[ProviderType] | None = None,
         debug_messages: bool = False,
         debug_file: str | None = None,
         debug_commands: bool = False,
         agent: str | None = None,
         load_skills: bool = True,
+        transport: Transport = "stdio",
     ) -> Self:
         """Create ACP server from existing agentpool configuration.
 
@@ -132,12 +98,12 @@ class ACPServer(BaseServer):
             config_path: Path to agentpool YAML config file
             file_access: Enable file system access
             terminal_access: Enable terminal access
-            providers: List of provider types to use for model discovery
             debug_messages: Enable saving JSON messages to file
             debug_file: Path to debug file
             debug_commands: Enable debug slash commands for testing
             agent: Optional specific agent name to use (defaults to first agent)
             load_skills: Whether to load client-side skills from .claude/skills
+            transport: Transport configuration ("stdio", "websocket", or transport object)
 
         Returns:
             Configured ACP server instance with agent pool from config
@@ -148,13 +114,13 @@ class ACPServer(BaseServer):
             pool,
             file_access=file_access,
             terminal_access=terminal_access,
-            providers=providers,
             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,
             config_path=str(config_path),
+            transport=transport,
         )
         agent_names = list(server.pool.agents.keys())
 
@@ -170,13 +136,13 @@ class ACPServer(BaseServer):
 
     async def _start_async(self) -> None:
         """Start the ACP server (blocking async - runs until stopped)."""
-        agent_names = list(self.pool.agents.keys())
-        self.log.info("Starting ACP server on stdio", agent_names=agent_names)
-        await self._initialize_models()  # Initialize models on first run
+        transport_name = (
+            type(self.transport).__name__ if not isinstance(self.transport, str) else self.transport
+        )
+        self.log.info("Starting ACP server", transport=transport_name)
         create_acp_agent = functools.partial(
             AgentPoolACPAgent,
             agent_pool=self.pool,
-            available_models=self._available_models,
             file_access=self.file_access,
             terminal_access=self.terminal_access,
             debug_commands=self.debug_commands,
@@ -184,21 +150,24 @@ class ACPServer(BaseServer):
             load_skills=self.load_skills,
             server=self,
         )
-        reader, writer = await stdio_streams()
-        file = self.debug_file if self.debug_messages else None
-        conn = AgentSideConnection(create_acp_agent, writer, reader, debug_file=file)
+
+        debug_file = self.debug_file if self.debug_messages else None
         self.log.info("ACP server started", file=self.file_access, terminal=self.terminal_access)
-        try:  # Keep the connection alive until shutdown
-            await self._shutdown_event.wait()
+
+        try:
+            await serve(
+                create_acp_agent,
+                transport=self.transport,
+                shutdown_event=self._shutdown_event,
+                debug_file=debug_file,
+            )
         except asyncio.CancelledError:
             self.log.info("ACP server shutdown requested")
             raise
         except KeyboardInterrupt:
             self.log.info("ACP server shutdown requested")
         except Exception:
-            self.log.exception("Connection receive task failed")
-        finally:
-            await conn.close()
+            self.log.exception("ACP server error")
 
     async def swap_pool(
         self,
@@ -261,28 +230,3 @@ class ACPServer(BaseServer):
 
         self.log.info("Pool swapped successfully", agent_names=agent_names, default_agent=agent)
         return agent_names
-
-    @logfire.instrument("ACP: Initializing models.")
-    async def _initialize_models(self) -> None:
-        """Initialize available models using tokonomics model discovery.
-
-        Converts tokonomics ModelInfo to ACP ModelInfo format at startup
-        so all downstream code works with ACP types consistently.
-        """
-        from tokonomics.model_discovery import get_all_models
-
-        if self._models_initialized:
-            return
-        try:
-            self.log.info("Discovering available models...")
-            delta = timedelta(days=200)
-            toko_models = await get_all_models(providers=self.providers, max_age=delta)
-            # Convert to ACP format once at startup
-            self._available_models = _convert_to_acp_model_info(toko_models)
-            self._models_initialized = True
-            self.log.info("Discovered models", count=len(self._available_models))
-        except Exception:
-            self.log.exception("Failed to discover models")
-            self._available_models = []
-        finally:
-            self._models_initialized = True