agentpool 2.1.9__py3-none-any.whl

agentpool_server/acp_server/commands/spawn.py

@@ -0,0 +1,210 @@
+"""Spawn subagent slash command."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+import uuid
+
+from pydantic_ai import (
+    FinalResultEvent,
+    FunctionToolCallEvent,
+    FunctionToolResultEvent,
+    PartDeltaEvent,
+    PartStartEvent,
+    RetryPromptPart,
+    TextPart,
+    TextPartDelta,
+    ThinkingPart,
+    ThinkingPartDelta,
+    ToolCallPartDelta,
+    ToolReturnPart,
+)
+from slashed import CommandContext, CommandError  # noqa: TC002
+
+from agentpool.agents.events import StreamCompleteEvent, ToolCallProgressEvent
+from agentpool.log import get_logger
+from agentpool.messaging.context import NodeContext  # noqa: TC001
+from agentpool_commands.base import NodeCommand
+from agentpool_server.acp_server.session import ACPSession  # noqa: TC001
+
+
+if TYPE_CHECKING:
+    from agentpool.agents.events import RichAgentStreamEvent
+
+
+logger = get_logger(__name__)
+
+
+class SpawnSubagentCommand(NodeCommand):
+    """Spawn a subagent to execute a specific task.
+
+    The subagent runs concurrently and reports progress in a dedicated tool call box.
+
+    Usage:
+      /spawn "agent-name" "prompt for the subagent"
+      /spawn "code-reviewer" "Review the main.py file for potential bugs"
+    """
+
+    name = "spawn"
+    category = "agents"
+
+    async def execute_command(
+        self,
+        ctx: CommandContext[NodeContext[ACPSession]],
+        agent_name: str,
+        task_prompt: str,
+    ) -> None:
+        """Spawn a subagent to execute a task.
+
+        Args:
+            ctx: Command context with ACP session
+            agent_name: Name of the agent to spawn
+            task_prompt: Task prompt for the subagent
+        """
+        session = ctx.context.data
+        assert session, "ACP session required for spawn command"
+        # Generate unique tool call ID
+        tool_call_id = f"spawn-{agent_name}-{uuid.uuid4().hex[:8]}"
+        try:
+            # Check if agent exists in pool
+            if not session.agent_pool or agent_name not in session.agent_pool.agents:
+                available = list(session.agent_pool.agents.keys())
+                error_msg = f"Agent {agent_name!r} not found. Available agents: {available}"
+                await ctx.print(f"❌ {error_msg}")
+                return
+
+            target_agent = session.agent_pool.get_agent(agent_name)
+            await session.notifications.tool_call_start(
+                tool_call_id=tool_call_id,
+                title=f"Spawning agent: {agent_name}",
+                kind="execute",
+                raw_input={
+                    "agent_name": agent_name,
+                    "task_prompt": task_prompt,
+                },
+            )
+
+            aggregated_content: list[str] = []  # Aggregate output as we stream
+            try:
+                # Run the subagent and handle events
+                async for event in target_agent.run_stream(task_prompt):
+                    await _handle_subagent_event(event, tool_call_id, aggregated_content, session)
+
+                final_content = "".join(aggregated_content).strip()
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="completed",
+                    content=[final_content] if final_content else None,
+                )
+            except Exception as e:
+                error_msg = f"Subagent execution failed: {e}"
+                logger.exception("Subagent execution error", error=str(e))
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="failed",
+                    raw_output=error_msg,
+                )
+
+        except Exception as e:
+            error_msg = f"Failed to spawn agent '{agent_name}': {e}"
+            logger.exception("Spawn command error", error=str(e))
+            raise CommandError(error_msg) from e
+
+
+async def _handle_subagent_event(
+    event: RichAgentStreamEvent[Any],
+    tool_call_id: str,
+    aggregated_content: list[str],
+    session: ACPSession,
+) -> None:
+    """Handle events from spawned subagent and convert to tool_call_progress.
+
+    Args:
+        event: Event from the subagent stream
+        tool_call_id: ID of the tool call box
+        aggregated_content: List to accumulate content for final display
+        session: ACP session for notifications
+    """
+    match event:
+        case (
+            PartStartEvent(part=TextPart(content=delta))
+            | PartDeltaEvent(delta=TextPartDelta(content_delta=delta))
+        ):
+            # Subagent text output → accumulate and update progress
+            aggregated_content.append(delta)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="in_progress",
+                content=["".join(aggregated_content)],
+            )
+
+        case (
+            PartStartEvent(part=ThinkingPart(content=delta))
+            | PartDeltaEvent(delta=ThinkingPartDelta(content_delta=delta))
+        ):
+            # Subagent thinking → show thinking indicator
+            if delta:
+                thinking_text = f"💭 {delta}"
+                aggregated_content.append(thinking_text)
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="in_progress",
+                    content=["".join(aggregated_content)],
+                )
+
+        case FunctionToolCallEvent(part=part):
+            # Subagent calls a tool → show nested tool call
+            tool_text = f"\n🔧 Using tool: {part.tool_name}\n"
+            aggregated_content.append(tool_text)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="in_progress",
+                content=["".join(aggregated_content)],
+            )
+
+        case FunctionToolResultEvent(
+            result=ToolReturnPart(content=content, tool_name=tool_name),
+        ):
+            # Subagent tool completes → show tool result
+            result_text = f"✅ {tool_name}: {content}\n"
+            aggregated_content.append(result_text)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="in_progress",
+                content=["".join(aggregated_content)],
+            )
+
+        case FunctionToolResultEvent(
+            result=RetryPromptPart(tool_name=tool_name) as result,
+        ):
+            # Tool call failed and needs retry
+            error_message = result.model_response()
+            error_text = f"❌ {tool_name or 'unknown'}: Error: {error_message}\n"
+            aggregated_content.append(error_text)
+            await session.notifications.tool_call_progress(
+                tool_call_id=tool_call_id,
+                status="in_progress",
+                content=["".join(aggregated_content)],
+            )
+
+        case ToolCallProgressEvent(message=message, tool_name=tool_name):
+            # Progress event from tools
+            if message:
+                progress_text = f"🔄 {tool_name}: {message}\n"
+                aggregated_content.append(progress_text)
+                await session.notifications.tool_call_progress(
+                    tool_call_id=tool_call_id,
+                    status="in_progress",
+                    content=["".join(aggregated_content)],
+                )
+
+        case (
+            PartStartEvent()
+            | PartDeltaEvent(delta=ToolCallPartDelta())
+            | FinalResultEvent()
+            | StreamCompleteEvent()
+        ):
+            pass  # These events don't need special handling
+
+        case _:
+            logger.debug("Unhandled subagent event", event_type=type(event).__name__)

agentpool_server/acp_server/converters.py

@@ -0,0 +1,235 @@
+"""Content conversion utilities for ACP (Agent Client Protocol) integration.
+
+This module handles conversion between pydantic-ai message formats and ACP protocol
+content blocks, session updates, and other data structures using the external acp library.
+"""
+
+from __future__ import annotations
+
+import base64
+from typing import TYPE_CHECKING, Any, assert_never, overload
+
+from pydantic import HttpUrl
+from pydantic_ai import AudioUrl, BinaryContent, BinaryImage, DocumentUrl, ImageUrl, VideoUrl
+
+from acp.schema import (
+    AudioContentBlock,
+    BlobResourceContents,
+    EmbeddedResourceContentBlock,
+    HttpMcpServer,
+    ImageContentBlock,
+    ResourceContentBlock,
+    SessionMode,
+    SseMcpServer,
+    StdioMcpServer,
+    TextContentBlock,
+    TextResourceContents,
+)
+from agentpool.log import get_logger
+from agentpool_config.mcp_server import (
+    SSEMCPServerConfig,
+    StdioMCPServerConfig,
+    StreamableHTTPMCPServerConfig,
+)
+
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from pydantic_ai import UserContent
+
+    from acp.schema import ContentBlock, McpServer
+    from agentpool.messaging import MessageNode
+    from agentpool_config.mcp_server import MCPServerConfig
+    from agentpool_config.nodes import ToolConfirmationMode
+
+logger = get_logger(__name__)
+
+
+@overload
+def convert_acp_mcp_server_to_config(
+    acp_server: HttpMcpServer,
+) -> StreamableHTTPMCPServerConfig: ...
+
+
+@overload
+def convert_acp_mcp_server_to_config(
+    acp_server: SseMcpServer,
+) -> SSEMCPServerConfig: ...
+
+
+@overload
+def convert_acp_mcp_server_to_config(
+    acp_server: StdioMcpServer,
+) -> StdioMCPServerConfig: ...
+
+
+@overload
+def convert_acp_mcp_server_to_config(acp_server: McpServer) -> MCPServerConfig: ...
+
+
+def convert_acp_mcp_server_to_config(acp_server: McpServer) -> MCPServerConfig:
+    """Convert ACP McpServer to native MCPServerConfig.
+
+    Args:
+        acp_server: ACP McpServer object from session/new request
+
+    Returns:
+        MCPServerConfig instance
+    """
+    match acp_server:
+        case StdioMcpServer(name=name, command=cmd, args=args, env=env_vars):
+            env = {var.name: var.value for var in env_vars}
+            return StdioMCPServerConfig(name=name, command=cmd, args=list(args), env=env)
+        case SseMcpServer(name=name, url=url, headers=headers):
+            h = {h.name: h.value for h in headers}
+            return SSEMCPServerConfig(name=name, url=HttpUrl(url), headers=h)
+        case HttpMcpServer(name=name, url=url, headers=headers):
+            h = {h.name: h.value for h in acp_server.headers}
+            return StreamableHTTPMCPServerConfig(name=name, url=HttpUrl(url), headers=h)
+        case _ as unreachable:
+            assert_never(unreachable)
+
+
+def format_uri_as_link(uri: str) -> str:
+    """Format URI as markdown-style link similar to other ACP implementations.
+
+    Args:
+        uri: URI to format (file://, zed://, etc.)
+
+    Returns:
+        Markdown-style link in format [@name](uri)
+    """
+    if uri.startswith("file://"):
+        path = uri[7:]  # Remove "file://"
+        name = path.split("/")[-1] or path
+        return f"[@{name}]({uri})"
+    if uri.startswith("zed://"):
+        parts = uri.split("/")
+        name = parts[-1] or uri
+        return f"[@{name}]({uri})"
+    return uri
+
+
+def from_acp_content(blocks: Sequence[ContentBlock]) -> Sequence[UserContent]:
+    """Convert ACP content blocks to pydantic-ai UserContent objects.
+
+    Args:
+        blocks: List of ACP ContentBlock objects
+
+    Returns:
+        List of pydantic-ai UserContent objects (str, ImageUrl, BinaryContent, etc.)
+    """
+    content: list[UserContent] = []
+
+    for block in blocks:
+        match block:
+            case TextContentBlock(text=text):
+                content.append(text)
+
+            case ImageContentBlock(data=data, mime_type=mime_type):
+                # ACP image data is base64 encoded
+                binary_data = base64.b64decode(data)
+                content.append(BinaryImage(data=binary_data, media_type=mime_type))
+
+            case AudioContentBlock(data=data, mime_type=mime_type):
+                binary_data = base64.b64decode(data)
+                content.append(BinaryContent(data=binary_data, media_type=mime_type))
+
+            case ResourceContentBlock(uri=uri, mime_type=mime_type):
+                # Convert to appropriate URL type based on MIME type
+                if mime_type:
+                    if mime_type.startswith("image/"):
+                        content.append(ImageUrl(url=uri))
+                    elif mime_type.startswith("audio/"):
+                        content.append(AudioUrl(url=uri))
+                    elif mime_type.startswith("video/"):
+                        content.append(VideoUrl(url=uri))
+                    elif mime_type == "application/pdf":
+                        content.append(DocumentUrl(url=uri))
+                    else:
+                        # Generic resource - convert to text link
+                        content.append(format_uri_as_link(uri))
+                else:
+                    # No MIME type - fallback to text link
+                    content.append(format_uri_as_link(uri))
+
+            case EmbeddedResourceContentBlock(resource=resource):
+                match resource:
+                    case TextResourceContents(uri=uri, text=text):
+                        content.append(format_uri_as_link(uri))
+                        content.append(f'\n<context ref="{uri}">\n{text}\n</context>')
+                    case BlobResourceContents(blob=blob, mime_type=mime_type):
+                        # Convert embedded binary to appropriate content type
+                        binary_data = base64.b64decode(blob)
+                        if mime_type and mime_type.startswith("image/"):
+                            content.append(BinaryImage(data=binary_data, media_type=mime_type))
+                        elif mime_type and mime_type.startswith("audio/"):
+                            content.append(BinaryContent(data=binary_data, media_type=mime_type))
+                        elif mime_type == "application/pdf":
+                            content.append(
+                                BinaryContent(data=binary_data, media_type="application/pdf")
+                            )
+                        else:
+                            # Unknown binary type - describe it
+                            formatted_uri = format_uri_as_link(resource.uri)
+                            content.append(f"Binary Resource: {formatted_uri}")
+
+    return content
+
+
+def agent_to_mode(agent: MessageNode[Any, Any]) -> SessionMode:
+    """Convert agent to a session mode (deprecated - use get_confirmation_modes)."""
+    desc = agent.description or f"Switch to {agent.name} agent"
+    return SessionMode(id=agent.name, name=agent.display_name, description=desc)
+
+
+def get_confirmation_modes() -> list[SessionMode]:
+    """Get available tool confirmation modes as ACP session modes.
+
+    Returns standard ACP-compatible modes for tool confirmation levels.
+    """
+    return [
+        SessionMode(
+            id="default",
+            name="Default",
+            description="Require confirmation for tools marked as needing it",
+        ),
+        SessionMode(
+            id="acceptEdits",
+            name="Accept Edits",
+            description="Auto-approve all tool calls without confirmation",
+        ),
+    ]
+
+
+def mode_id_to_confirmation_mode(mode_id: str) -> ToolConfirmationMode | None:
+    """Map ACP mode ID to ToolConfirmationMode.
+
+    Returns:
+        ToolConfirmationMode value or None if mode_id is invalid
+    """
+    mapping: dict[str, ToolConfirmationMode] = {
+        "default": "per_tool",
+        "acceptEdits": "never",
+        "bypassPermissions": "never",
+        # "plan": "..."
+    }
+    return mapping.get(mode_id)
+
+
+def confirmation_mode_to_mode_id(mode: ToolConfirmationMode) -> str:
+    """Map ToolConfirmationMode to ACP mode ID.
+
+    Args:
+        mode: Tool confirmation mode
+
+    Returns:
+        ACP mode ID string
+    """
+    mapping: dict[ToolConfirmationMode, str] = {
+        "per_tool": "default",
+        "always": "default",  # No direct ACP equivalent, use default (requires confirmation)
+        "never": "acceptEdits",
+    }
+    return mapping.get(mode, "default")