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

agentpool/models/acp_agents/mcp_capable.py

@@ -5,16 +5,18 @@ from __future__ import annotations
 import json
 from typing import TYPE_CHECKING, Any, Literal, assert_never, cast
 
+import anyenv
 from pydantic import BaseModel, ConfigDict, Field
-from tokonomics.model_discovery import ProviderType  # noqa: TC002
 
 from agentpool.models.acp_agents.base import BaseACPAgentConfig
+from agentpool_config import AnyToolConfig, BaseToolConfig  # noqa: TC001
 from agentpool_config.output_types import StructuredResponseConfig  # noqa: TC001
-from agentpool_config.toolsets import ToolsetConfig  # noqa: TC001
+from agentpool_config.toolsets import BaseToolsetConfig
 
 
 if TYPE_CHECKING:
     from agentpool.prompts.manager import PromptManager
+    from agentpool.resource_providers import ResourceProvider
 
 
 ClaudeCodeModelName = Literal["default", "sonnet", "opus", "haiku", "sonnet[1m]", "opusplan"]
@@ -23,6 +25,7 @@ ClaudeCodeToolName = Literal[
     "Bash",
     "BashOutput",
     "Edit",
+    "EnterPlanMode",
     "ExitPlanMode",
     "Glob",
     "Grep",
@@ -47,23 +50,51 @@ class MCPCapableACPAgentConfig(BaseACPAgentConfig):
     that can be exposed via an internal MCP bridge.
     """
 
-    toolsets: list[ToolsetConfig] = Field(
+    tools: list[AnyToolConfig | str] = Field(
         default_factory=list,
-        title="Toolsets",
+        title="Tools",
         examples=[
             [
                 {"type": "subagent"},
                 {"type": "agent_management"},
+                "webbrowser:open",
             ],
         ],
     )
-    """Toolsets to expose to this ACP agent via MCP bridge.
+    """Tools and toolsets to expose to this ACP agent via MCP bridge.
 
-    These toolsets will be started as an in-process MCP server and made
-    available to the external ACP agent. This allows ACP agents to use
-    internal agentpool toolsets like subagent delegation.
+    Supports both single tools and toolsets. These will be started as an
+    in-process MCP server and made available to the external ACP agent.
     """
 
+    def get_tool_providers(self) -> list[ResourceProvider]:
+        """Get all resource providers for this agent's tools.
+
+        Returns:
+            List of ResourceProvider instances
+        """
+        from agentpool.resource_providers import StaticResourceProvider
+        from agentpool.tools.base import Tool
+
+        providers: list[ResourceProvider] = []
+        static_tools: list[Tool] = []
+
+        for tool_config in self.tools:
+            try:
+                if isinstance(tool_config, BaseToolsetConfig):
+                    providers.append(tool_config.get_provider())
+                elif isinstance(tool_config, str):
+                    static_tools.append(Tool.from_callable(tool_config))
+                elif isinstance(tool_config, BaseToolConfig):
+                    static_tools.append(tool_config.get_tool())
+            except Exception:  # noqa: BLE001
+                continue
+
+        if static_tools:
+            providers.append(StaticResourceProvider(name="tools", tools=static_tools))
+
+        return providers
+
     def build_mcp_config_json(self) -> str | None:
         """Convert inherited mcp_servers to standard MCP config JSON format.
 
@@ -197,12 +228,12 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
     )
     """Additional directories to allow tool access to."""
 
-    tools: list[ClaudeCodeToolName | str] | None = Field(
+    builtin_tools: list[ClaudeCodeToolName | str] | None = Field(
         default=None,
-        title="Tools",
+        title="Built-in Tools",
         examples=[["Bash", "Edit", "Read"], []],
     )
-    """Available tools from built-in set. Empty list disables all tools."""
+    """Available tools from Claude's built-in set. Empty list disables all tools."""
 
     fallback_model: ClaudeCodeModelName | None = Field(
         default=None,
@@ -211,9 +242,9 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
     )
     """Fallback model when default is overloaded."""
 
-    dangerously_skip_permissions: bool = Field(
+    auto_approve: bool = Field(
         default=False,
-        title="Dangerously Skip Permissions",
+        title="Auto Approve",
     )
     """Bypass all permission checks. Only for sandboxed environments."""
 
@@ -260,14 +291,14 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
             args.append("--strict-mcp-config")
         if self.add_dir:
             args.extend(["--add-dir", *self.add_dir])
-        if self.tools is not None:
-            if self.tools:
-                args.extend(["--tools", ",".join(self.tools)])
+        if self.builtin_tools is not None:
+            if self.builtin_tools:
+                args.extend(["--tools", ",".join(self.builtin_tools)])
             else:
                 args.extend(["--tools", ""])
         if self.fallback_model:
             args.extend(["--fallback-model", self.fallback_model])
-        if self.dangerously_skip_permissions:
+        if self.auto_approve:
             args.append("--dangerously-skip-permissions")
         if self.output_type:
             args.extend(["--output-format", "json"])
@@ -286,128 +317,7 @@ class ClaudeACPAgentConfig(MCPCapableACPAgentConfig):
             return None
         # StructuredResponseConfig - resolve schema via get_schema()
         model_cls = cast(type[BaseModel], self.output_type.response_schema.get_schema())
-        return json.dumps(model_cls.model_json_schema())
-
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Claude Code uses Anthropic models."""
-        return ["anthropic"]
-
-
-class GeminiACPAgentConfig(MCPCapableACPAgentConfig):
-    """Configuration for Gemini CLI via ACP.
-
-    Provides typed settings for the gemini CLI with ACP support.
-
-    Example:
-        ```yaml
-        agents:
-          coder:
-            type: acp
-            provider: gemini
-            cwd: /path/to/project
-            model: gemini-2.5-pro
-            approval_mode: auto_edit
-            allowed_tools:
-              - read_file
-              - write_file
-              - terminal
-        ```
-    """
-
-    model_config = ConfigDict(json_schema_extra={"title": "Gemini ACP Agent Configuration"})
-
-    provider: Literal["gemini"] = Field("gemini", init=False)
-    """Discriminator for Gemini ACP agent."""
-
-    model: str | None = Field(
-        default=None,
-        title="Model",
-        examples=["gemini-2.5-pro", "gemini-2.5-flash"],
-    )
-    """Model override."""
-
-    approval_mode: Literal["default", "auto_edit", "yolo"] | None = Field(
-        default=None,
-        title="Approval Mode",
-        examples=["auto_edit", "yolo"],
-    )
-    """Approval mode for tool execution."""
-
-    sandbox: bool = Field(default=False, title="Sandbox")
-    """Run in sandbox mode."""
-
-    yolo: bool = Field(default=False, title="YOLO")
-    """Automatically accept all actions."""
-
-    allowed_tools: list[str] | None = Field(
-        default=None,
-        title="Allowed Tools",
-        examples=[["read_file", "write_file", "terminal"], ["search"]],
-    )
-    """Tools allowed to run without confirmation."""
-
-    allowed_mcp_server_names: list[str] | None = Field(
-        default=None,
-        title="Allowed MCP Server Names",
-        examples=[["filesystem", "github"], ["slack"]],
-    )
-    """Allowed MCP server names."""
-
-    extensions: list[str] | None = Field(
-        default=None,
-        title="Extensions",
-        examples=[["python", "typescript"], ["rust", "go"]],
-    )
-    """List of extensions to use. If not provided, all are used."""
-
-    include_directories: list[str] | None = Field(
-        default=None,
-        title="Include Directories",
-        examples=[["/path/to/lib", "/path/to/shared"], ["./vendor"]],
-    )
-    """Additional directories to include in the workspace."""
-
-    output_format: Literal["text", "json", "stream-json"] | None = Field(
-        default=None,
-        title="Output Format",
-        examples=["json", "stream-json"],
-    )
-    """Output format."""
-
-    def get_command(self) -> str:
-        """Get the command to spawn the ACP server."""
-        return "gemini"
-
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Gemini CLI uses Google Gemini models."""
-        return ["gemini"]
-
-    async def get_args(self, prompt_manager: PromptManager | None = None) -> list[str]:
-        """Build command arguments from settings."""
-        args: list[str] = ["--experimental-acp"]
-
-        if self.model:
-            args.extend(["--model", self.model])
-        if self.approval_mode:
-            args.extend(["--approval-mode", self.approval_mode])
-        if self.sandbox:
-            args.append("--sandbox")
-        if self.yolo:
-            args.append("--yolo")
-        if self.allowed_tools:
-            args.extend(["--allowed-tools", *self.allowed_tools])
-        if self.allowed_mcp_server_names:
-            args.extend(["--allowed-mcp-server-names", *self.allowed_mcp_server_names])
-        if self.extensions:
-            args.extend(["--extensions", *self.extensions])
-        if self.include_directories:
-            args.extend(["--include-directories", *self.include_directories])
-        if self.output_format:
-            args.extend(["--output-format", self.output_format])
-
-        return args
+        return anyenv.dump_json(model_cls.model_json_schema())
 
 
 class FastAgentACPAgentConfig(MCPCapableACPAgentConfig):
@@ -428,7 +338,7 @@ class FastAgentACPAgentConfig(MCPCapableACPAgentConfig):
             provider: fast-agent
             cwd: /path/to/project
             model: claude-3.5-sonnet-20241022
-            toolsets:
+            tools:
               - type: subagent
               - type: agent_management
             skills_dir: ./my-skills
@@ -513,11 +423,6 @@ class FastAgentACPAgentConfig(MCPCapableACPAgentConfig):
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """fast-agent supports multiple providers."""
-        return ["openai", "anthropic", "gemini", "openrouter"]
-
 
 class AuggieACPAgentConfig(MCPCapableACPAgentConfig):
     """Configuration for Auggie (Augment Code) via ACP.
@@ -681,11 +586,6 @@ class AuggieACPAgentConfig(MCPCapableACPAgentConfig):
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Auggie uses Augment Code's models."""
-        return []
-
 
 class KimiACPAgentConfig(MCPCapableACPAgentConfig):
     """Configuration for Kimi CLI via ACP.
@@ -737,7 +637,7 @@ class KimiACPAgentConfig(MCPCapableACPAgentConfig):
     )
     """Working directory for the agent."""
 
-    yolo: bool = Field(default=False, title="YOLO")
+    auto_approve: bool = Field(default=False, title="Auto Approve")
     """Automatically approve all actions."""
 
     thinking: bool | None = Field(default=None, title="Thinking")
@@ -767,24 +667,93 @@ class KimiACPAgentConfig(MCPCapableACPAgentConfig):
         if mcp_json:
             args.extend(["--mcp-config", mcp_json])
 
-        if self.yolo:
+        if self.auto_approve:
             args.append("--yolo")
         if self.thinking is not None and self.thinking:
             args.append("--thinking")
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Kimi uses Moonshot AI's models."""
-        return []
+
+class AgentpoolACPAgentConfig(MCPCapableACPAgentConfig):
+    """Configuration for agentpool's own ACP server.
+
+    This allows using agentpool serve-acp as an ACP agent, with MCP bridge support
+    for tool metadata preservation.
+
+    Example:
+        ```yaml
+        acp_agents:
+          my_agentpool:
+            type: agentpool
+            config_path: path/to/agent_config.yml
+            agent: agent_name  # Optional: specific agent to use
+            mcp_servers:
+              - type: stdio
+                command: mcp-server-filesystem
+                args: ["--root", "/workspace"]
+        ```
+    """
+
+    model_config = ConfigDict(title="Agentpool ACP Agent")
+
+    provider: Literal["agentpool"] = Field("agentpool", init=False)
+    """Discriminator for agentpool ACP agent."""
+
+    config_path: str | None = None
+    """Path to agentpool configuration file (optional)."""
+
+    agent: str | None = None
+    """Specific agent name to use from config (defaults to first agent)."""
+
+    file_access: bool = True
+    """Enable file system access for the agent."""
+
+    terminal_access: bool = True
+    """Enable terminal access for the agent."""
+
+    load_skills: bool = True
+    """Load client-side skills from .claude/skills directory."""
+
+    def get_command(self) -> str:
+        """Get the command to run agentpool serve-acp."""
+        return "agentpool"
+
+    async def get_args(self, prompt_manager: PromptManager | None = None) -> list[str]:
+        """Build command arguments for agentpool serve-acp."""
+        args = ["serve-acp"]
+
+        # Add config path if specified
+        if self.config_path:
+            args.append(self.config_path)
+
+        # Add agent selection
+        if self.agent:
+            args.extend(["--agent", self.agent])
+
+        # Add file/terminal access flags
+        if not self.file_access:
+            args.append("--no-file-access")
+        if not self.terminal_access:
+            args.append("--no-terminal-access")
+
+        # Add skills flag
+        if not self.load_skills:
+            args.append("--no-skills")
+
+        # Convert inherited mcp_servers to --mcp-config format
+        mcp_json = self.build_mcp_config_json()
+        if mcp_json:
+            args.extend(["--mcp-config", mcp_json])
+
+        return args
 
 
 # Union of all ACP agent config types
 MCPCapableACPAgentConfigTypes = (
     ClaudeACPAgentConfig
-    | GeminiACPAgentConfig
     | FastAgentACPAgentConfig
     | AuggieACPAgentConfig
     | KimiACPAgentConfig
+    | AgentpoolACPAgentConfig
 )