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

agentpool_server/acp_server/session.py

@@ -15,6 +15,8 @@ from typing import TYPE_CHECKING, Any
 from exxec.acp_provider import ACPExecutionEnvironment
 import logfire
 from pydantic_ai import (
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     FinalResultEvent,
     FunctionToolCallEvent,
     FunctionToolResultEvent,
@@ -31,6 +33,7 @@ from pydantic_ai import (
     UserPromptPart,
 )
 from slashed import Command, CommandStore
+from tokonomics.model_discovery.model_info import ModelInfo
 
 from acp import RequestPermissionRequest
 from acp.acp_requests import ACPRequests
@@ -50,12 +53,15 @@ from agentpool import Agent, AgentContext  # noqa: TC001
 from agentpool.agents import SlashedAgent
 from agentpool.agents.acp_agent import ACPAgent
 from agentpool.agents.events import (
+    CompactionEvent,
     PlanUpdateEvent,
     StreamCompleteEvent,
     ToolCallProgressEvent,
     ToolCallStartEvent,
 )
+from agentpool.agents.modes import ModeInfo
 from agentpool.log import get_logger
+from agentpool.utils.pydantic_ai_helpers import safe_args_as_dict
 from agentpool_commands import get_commands
 from agentpool_commands.base import NodeCommand
 from agentpool_server.acp_server.converters import (
@@ -76,6 +82,8 @@ if TYPE_CHECKING:
 
     from acp import Client, RequestPermissionResponse
     from acp.schema import (
+        AvailableCommandsUpdate,
+        ConfigOptionUpdate,
         ContentBlock,
         Implementation,
         McpServer,
@@ -129,13 +137,27 @@ def _is_slash_command(text: str) -> bool:
 
 def split_commands(
     contents: Sequence[UserContent],
+    command_store: CommandStore,
 ) -> tuple[list[str], list[UserContent]]:
+    """Split content into local slash commands and pass-through content.
+
+    Only commands that exist in the local command_store are extracted.
+    Remote commands (from nested ACP agents) stay in non_command_content
+    so they flow through to the agent and reach the nested server.
+    """
     commands: list[str] = []
     non_command_content: list[UserContent] = []
     for item in contents:
-        if isinstance(item, str) and _is_slash_command(item):
+        # Check if this is a LOCAL command we handle
+        if (
+            isinstance(item, str)
+            and _is_slash_command(item)
+            and (match := SLASH_PATTERN.match(item.strip()))
+            and command_store.get_command(match.group(1))
+        ):
             commands.append(item.strip())
         else:
+            # Not a local command - pass through (may be remote command or regular text)
             non_command_content.append(item)
     return commands, non_command_content
 
@@ -231,6 +253,7 @@ class ACPSession:
         self.log = logger.bind(session_id=self.session_id)
         self._task_lock = asyncio.Lock()
         self._cancelled = False
+        self._title_generation_triggered = False
         self._current_tool_inputs: dict[str, dict[str, Any]] = {}
         self._tool_call_states: dict[str, ToolCallState] = {}
         self.fs = ACPFileSystem(self.client, session_id=self.session_id)
@@ -243,9 +266,10 @@ class ACPSession:
             ),
             *get_acp_commands(),
         ]
-        self.command_store = CommandStore(enable_system_commands=True, commands=cmds)
+        self.command_store = CommandStore(commands=cmds)
         self.command_store._initialize_sync()
         self._update_callbacks: list[Callable[[], None]] = []
+        self._remote_commands: list[AvailableCommand] = []  # Commands from nested ACP agents
 
         self.staged_content = StagedContent()
         # Inject Zed-specific instructions if client is Zed
@@ -294,8 +318,44 @@ class ACPSession:
                         return response
 
                 agent.acp_permission_callback = permission_callback
+
+            # Subscribe to state change signal for all agents
+            agent.state_updated.connect(self._on_state_updated)
         self.log.info("Created ACP session", current_agent=self.current_agent_name)
 
+    async def _on_state_updated(
+        self, state: ModeInfo | ModelInfo | AvailableCommandsUpdate | ConfigOptionUpdate
+    ) -> None:
+        """Handle state update signal from agent - forward to ACP client."""
+        from acp.schema import (
+            AvailableCommandsUpdate as ACPAvailableCommandsUpdate,
+            ConfigOptionUpdate as ACPConfigOptionUpdate,
+            CurrentModelUpdate,
+            CurrentModeUpdate,
+            SessionNotification,
+        )
+
+        update: CurrentModeUpdate | CurrentModelUpdate | ACPConfigOptionUpdate
+        match state:
+            case ModeInfo(id=mode_id):
+                update = CurrentModeUpdate(current_mode_id=mode_id)
+                self.log.debug("Forwarding mode change to client", mode_id=mode_id)
+            case ModelInfo(id=model_id):
+                update = CurrentModelUpdate(current_model_id=model_id)
+                self.log.debug("Forwarding model change to client", model_id=model_id)
+            case ACPAvailableCommandsUpdate(available_commands=cmds):
+                # Store remote commands and send merged list
+                self._remote_commands = list(cmds)
+                await self.send_available_commands_update()
+                self.log.debug("Merged and sent commands update to client")
+                return
+            case ACPConfigOptionUpdate():
+                update = state
+                self.log.debug("Forwarding config option update to client")
+
+        notification = SessionNotification(session_id=self.session_id, update=update)
+        await self.client.session_update(notification)
+
     async def initialize(self) -> None:
         """Initialize async resources. Must be called after construction."""
         await self.acp_env.__aenter__()
@@ -377,7 +437,14 @@ class ACPSession:
             self.log.exception("Failed to discover client-side skills", error=e)
 
     @property
-    def agent(self) -> Agent[ACPSession, str] | ACPAgent | AGUIAgent | ClaudeCodeAgent:
+    def agent(
+        self,
+    ) -> (
+        Agent[ACPSession, str]
+        | ACPAgent[ACPSession]
+        | AGUIAgent[ACPSession]
+        | ClaudeCodeAgent[ACPSession]
+    ):
         """Get the currently active agent."""
         if self.current_agent_name in self.agent_pool.agents:
             return self.agent_pool.get_agent(self.current_agent_name, deps_type=ACPSession)
@@ -425,6 +492,10 @@ class ACPSession:
         self._cancelled = True
         self.log.info("Session cancelled, interrupting agent")
 
+        # Clear pending tool call states to avoid stale data on next prompt
+        self._tool_call_states.clear()
+        self._current_tool_inputs.clear()
+
         # Actively interrupt the agent's stream
         try:
             await self.agent.interrupt()
@@ -450,7 +521,7 @@ class ACPSession:
         if not contents:
             self.log.warning("Empty prompt received")
             return "refusal"
-        commands, non_command_content = split_commands(contents)
+        commands, non_command_content = split_commands(contents, self.command_store)
         async with self._task_lock:
             if commands:  # Process commands if found
                 for command in commands:
@@ -474,15 +545,22 @@ class ACPSession:
 
             try:  # Use the session's persistent input provider
                 async for event in self.agent.run_stream(
-                    *all_content, input_provider=self.input_provider
+                    *all_content, input_provider=self.input_provider, deps=self
                 ):
                     if self._cancelled:
+                        self.log.info("Cancelled during event loop")
                         return "cancelled"
 
                     event_count += 1
                     await self.handle_event(event)
                 self.log.info("Streaming finished", events_processed=event_count)
 
+            except asyncio.CancelledError:
+                # Task was cancelled (e.g., via interrupt()) - return proper stop reason
+                # This is critical: CancelledError doesn't inherit from Exception,
+                # so we must catch it explicitly to send the PromptResponse
+                self.log.info("Stream cancelled via CancelledError")
+                return "cancelled"
             except UsageLimitExceeded as e:
                 self.log.info("Usage limit exceeded", error=str(e))
                 error_msg = str(e)  # Determine which limit was hit based on error
@@ -503,16 +581,51 @@ class ACPSession:
                 )
                 return "end_turn"
             else:
+                # Trigger title generation on first successful prompt
+                if not self._title_generation_triggered and self.agent_pool.storage:
+                    self._title_generation_triggered = True
+                    self.acp_agent.tasks.create_task(
+                        self._generate_title(),
+                        name=f"generate_title_{self.session_id}",
+                    )
                 return "end_turn"
 
+    async def _generate_title(self) -> None:
+        """Generate conversation title in the background."""
+        try:
+            messages = self.agent.conversation.get_history()
+            if not messages:
+                return
+
+            title = await self.agent_pool.storage.generate_conversation_title(
+                self.session_id,
+                messages,
+            )
+
+            # Persist to session store
+            if title and self.manager:
+                session_data = await self.manager.session_manager.store.load(self.session_id)
+                if session_data:
+                    updated_data = session_data.with_title(title)
+                    await self.manager.session_manager.store.save(updated_data)
+                    self.log.info("Generated session title", title=title)
+        except Exception:
+            self.log.exception("Failed to generate conversation title")
+
     async def _send_error_notification(self, message: str) -> None:
         """Send error notification, with exception handling."""
+        if self._cancelled:
+            return
         try:
             await self.notifications.send_agent_text(message)
         except Exception:
             self.log.exception("Failed to send error notification")
 
     async def handle_event(self, event: RichAgentStreamEvent[Any]) -> None:  # noqa: PLR0915
+        # Don't send notifications after cancellation to avoid stale updates
+        if self._cancelled:
+            return
+
         match event:
             case (
                 PartStartEvent(part=TextPart(content=delta))
@@ -526,6 +639,36 @@ class ACPSession:
             ):
                 await self.notifications.send_agent_thought(delta or "\n")
 
+            # Builtin tool call started (e.g., WebSearchTool, CodeExecutionTool)
+            case PartStartEvent(part=BuiltinToolCallPart() as part):
+                tool_call_id = part.tool_call_id
+                tool_input = safe_args_as_dict(part, default={})
+                self._current_tool_inputs[tool_call_id] = tool_input
+                state = self._get_or_create_tool_state(
+                    tool_call_id=tool_call_id,
+                    tool_name=part.tool_name,
+                    tool_input=tool_input,
+                )
+                await state.start()
+
+            # Builtin tool completed
+            case PartStartEvent(part=BuiltinToolReturnPart() as part):
+                tool_call_id = part.tool_call_id
+                if complete_state := self._tool_call_states.get(tool_call_id):
+                    final_output = part.content
+                    if complete_state.has_content:
+                        await complete_state.complete(raw_output=final_output)
+                    else:
+                        converted_blocks = to_acp_content_blocks(final_output)
+                        content_items = [
+                            ContentToolCallContent(content=block) for block in converted_blocks
+                        ]
+                        await complete_state.complete(
+                            raw_output=final_output,
+                            content=content_items,
+                        )
+                self._cleanup_tool_state(tool_call_id)
+
             case PartStartEvent(part=part):
                 self.log.debug("Received unhandled PartStartEvent", part=part)
 
@@ -551,14 +694,7 @@ class ACPSession:
             # Tool call started - create/update state and start notification
             case FunctionToolCallEvent(part=part):
                 tool_call_id = part.tool_call_id
-                try:
-                    tool_input = part.args_as_dict()
-                except ValueError as e:
-                    # Args might be malformed - use empty dict and log
-                    self.log.warning(
-                        "Failed to parse tool args", tool_name=part.tool_name, error=str(e)
-                    )
-                    tool_input = {}
+                tool_input = safe_args_as_dict(part, default={})
                 self._current_tool_inputs[tool_call_id] = tool_input
                 # Create state and send initial notification
                 state = self._get_or_create_tool_state(
@@ -694,6 +830,8 @@ class ACPSession:
                                 status=status,
                                 changed_lines=[],
                             )
+                            # Mark content as sent so completion doesn't override
+                            progress_state._has_content = True
                         case LocationContentItem(path=loc_path):
                             location_paths.append(loc_path)
 
@@ -717,6 +855,25 @@ class ACPSession:
                 ]
                 await self.notifications.update_plan(acp_entries)
 
+            case CompactionEvent(trigger=trigger, phase=phase):
+                # Convert semantic CompactionEvent to text for ACP display
+                if phase == "starting":
+                    if trigger == "auto":
+                        text = (
+                            "\n\n---\n\n"
+                            "📦 **Context compaction** triggered. "
+                            "Summarizing conversation..."
+                            "\n\n---\n\n"
+                        )
+                    else:
+                        text = (
+                            "\n\n---\n\n"
+                            "📦 **Manual compaction** requested. "
+                            "Summarizing conversation..."
+                            "\n\n---\n\n"
+                        )
+                    await self.notifications.send_agent_text(text)
+
             case _:
                 self.log.debug("Unhandled event", event_type=type(event).__name__)
 
@@ -743,9 +900,14 @@ class ACPSession:
             self.log.exception("Error closing session")
 
     async def send_available_commands_update(self) -> None:
-        """Send current available commands to client."""
+        """Send current available commands to client.
+
+        Merges local commands from command_store with any remote commands
+        from nested ACP agents.
+        """
         try:
-            commands = self.get_acp_commands()
+            commands = self.get_acp_commands()  # Local commands
+            commands.extend(self._remote_commands)  # Merge remote commands
             await self.notifications.update_commands(commands)
         except Exception:
             self.log.exception("Failed to send available commands update")
@@ -908,8 +1070,8 @@ class ACPSession:
         usage_hint = (
             " ".join(f"<{arg['name']}>" for arg in prompt.arguments) if prompt.arguments else None
         )
-        return Command(
-            execute_func=execute_prompt,
+        return Command.from_raw(
+            execute_prompt,
             name=prompt.name,
             description=prompt.description or f"MCP prompt: {prompt.name}",
             category="mcp",
@@ -960,8 +1122,8 @@ class ACPSession:
         # Create command name - prefix with provider if not builtin
         command_name = f"{provider}_{name}" if provider != "builtin" else name
 
-        return Command(
-            execute_func=execute_prompt,
+        return Command.from_raw(
+            execute_prompt,
             name=command_name,
             description=f"Prompt hub: {provider}:{name}",
             category="prompts",

agentpool_server/opencode_server/.rules

@@ -0,0 +1,95 @@
+# OpenCode-Compatible Server
+
+This module implements an OpenCode-compatible API server, allowing OpenCode SDK clients
+to interact with AgentPool agents.
+
+## Reference Documentation
+
+- **Python SDK**: https://github.com/sst/opencode-sdk-python
+- **Server Docs**: https://raw.githubusercontent.com/sst/opencode/refs/heads/dev/packages/web/src/content/docs/server.mdx
+- **OpenCode Main Repo**: https://github.com/sst/opencode
+
+## SDK Clone (for reference during development)
+
+To get the SDK locally for reference:
+```bash
+git clone --depth 1 https://github.com/sst/opencode-sdk-python.git /tmp/opencode-sdk-python
+```
+
+Key SDK paths:
+- Types: `src/opencode_ai/types/` - All Pydantic models
+- Resources: `src/opencode_ai/resources/` - API client methods (shows endpoint signatures)
+
+## Architecture
+
+```
+opencode_server/
+├── __init__.py
+├── server.py           # FastAPI app factory and main server class
+├── models/             # Pydantic models matching OpenCode API types
+│   ├── __init__.py
+│   ├── base.py         # Shared base model with camelCase alias config
+│   ├── session.py      # Session, SessionStatus, etc.
+│   ├── message.py      # Message, Parts, etc.
+│   ├── provider.py     # Provider, Model, Config
+│   ├── file.py         # File operations models
+│   └── events.py       # SSE event models
+├── routes/             # Route handlers grouped by domain
+│   ├── __init__.py
+│   ├── global_routes.py
+│   ├── session_routes.py
+│   ├── message_routes.py
+│   ├── file_routes.py
+│   ├── config_routes.py
+│   └── agent_routes.py
+├── state.py            # Server state management
+└── ENDPOINTS.md        # Implementation status checklist
+```
+
+## Key Conventions
+
+### Models
+- All models inherit from `OpenCodeBaseModel` which sets `populate_by_name=True`
+- Use `Field(alias="camelCase")` for fields that differ from snake_case
+- OpenCode uses camelCase in JSON (e.g., `sessionID`, `messageID`, `providerID`)
+
+### Routes
+- Each route file defines a router with appropriate prefix/tags
+- Routes are registered in `server.py`
+- Use dependency injection for server state access
+
+### Field Naming Examples
+```python
+session_id: str = Field(alias="sessionID")
+message_id: str = Field(alias="messageID")
+provider_id: str = Field(alias="providerID")
+model_id: str = Field(alias="modelID")
+parent_id: str | None = Field(default=None, alias="parentID")
+```
+
+## Implementation Status
+
+See `ENDPOINTS.md` for the full checklist of endpoints and their implementation status.
+
+## Logging
+
+Log file location: `~/.local/state/agentpool/log/opencode.log`
+
+To tail the logs:
+```bash
+tail -f ~/.local/state/agentpool/log/opencode.log
+```
+
+To filter for SSE events:
+```bash
+tail -f ~/.local/state/agentpool/log/opencode.log | grep -i sse
+```
+
+## Testing with the SDK
+
+```python
+from opencode_ai import Opencode
+
+client = Opencode(base_url="http://localhost:4096")
+sessions = client.session.list()
+```