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

agentpool/models/acp_agents/non_mcp.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Literal
 
 from pydantic import ConfigDict, Field
-from tokonomics.model_discovery import ProviderType  # noqa: TC002
 
 from agentpool.models.acp_agents.base import BaseACPAgentConfig
 
@@ -14,29 +13,6 @@ if TYPE_CHECKING:
     from agentpool.prompts.manager import PromptManager
 
 
-ClaudeCodeModelName = Literal["default", "sonnet", "opus", "haiku", "sonnet[1m]", "opusplan"]
-ClaudeCodeToolName = Literal[
-    "AskUserQuestion",
-    "Bash",
-    "BashOutput",
-    "Edit",
-    "ExitPlanMode",
-    "Glob",
-    "Grep",
-    "KillShell",
-    "NotebookEdit",
-    "Read",
-    "Skill",
-    "SlashCommand",
-    "Task",
-    "TodoWrite",
-    "WebFetch",
-    "WebSearch",
-    "Write",
-]
-ClaudeCodePermissionmode = Literal["default", "acceptEdits", "bypassPermissions", "dontAsk", "plan"]
-
-
 class CodexACPAgentConfig(BaseACPAgentConfig):
     """Configuration for Zed Codex via ACP.
 
@@ -67,6 +43,12 @@ class CodexACPAgentConfig(BaseACPAgentConfig):
     )
     """Model override."""
 
+    auto_approve: bool = Field(
+        default=False,
+        title="Auto Approve",
+    )
+    """Automatically accept all actions (YOLO mode)."""
+
     sandbox_permissions: list[str] | None = Field(
         default=None,
         title="Sandbox Permissions",
@@ -85,11 +67,6 @@ class CodexACPAgentConfig(BaseACPAgentConfig):
         """Get the command to spawn the ACP server."""
         return "npx"
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Codex uses OpenAI models."""
-        return ["openai"]
-
     async def get_args(self, prompt_manager: PromptManager | None = None) -> list[str]:
         """Build command arguments from settings."""
         args: list[str] = ["@zed-industries/codex-acp"]
@@ -105,6 +82,8 @@ class CodexACPAgentConfig(BaseACPAgentConfig):
                 "-c",
                 f"shell_environment_policy.inherit={self.shell_environment_policy_inherit}",
             ])
+        if self.auto_approve:
+            args.extend(["-c", "approval_mode=yolo"])
 
         return args
 
@@ -142,11 +121,6 @@ class OpenCodeACPAgentConfig(BaseACPAgentConfig):
             args.extend(["--cwd", self.cwd])
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """OpenCode supports multiple providers."""
-        return ["openai", "anthropic", "gemini", "openrouter"]
-
 
 class GooseACPAgentConfig(BaseACPAgentConfig):
     """Configuration for Goose via ACP.
@@ -176,11 +150,6 @@ class GooseACPAgentConfig(BaseACPAgentConfig):
         """Build command arguments from settings."""
         return ["acp"]
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Goose supports multiple providers."""
-        return ["openai", "anthropic", "gemini", "openrouter"]
-
 
 class MistralACPAgentConfig(BaseACPAgentConfig):
     """Configuration for Mistral Agent via ACP.
@@ -208,11 +177,6 @@ class MistralACPAgentConfig(BaseACPAgentConfig):
         """Build command arguments from settings."""
         return []
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Goose supports multiple providers."""
-        return ["mistral"]
-
 
 class OpenHandsACPAgentConfig(BaseACPAgentConfig):
     """Configuration for OpenHands via ACP.
@@ -242,11 +206,6 @@ class OpenHandsACPAgentConfig(BaseACPAgentConfig):
         """Build command arguments from settings."""
         return ["acp"]
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """OpenHands supports multiple providers."""
-        return ["openai", "anthropic", "gemini", "openrouter"]
-
 
 class AmpACPAgentConfig(BaseACPAgentConfig):
     """Configuration for Amp (AmpCode) via ACP.
@@ -292,11 +251,6 @@ class AmpACPAgentConfig(BaseACPAgentConfig):
         """Build command arguments for amp-acp bridge."""
         return ["-y", "amp-acp"]
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Amp supports multiple providers."""
-        return ["openai", "anthropic", "gemini"]
-
 
 class CagentACPAgentConfig(BaseACPAgentConfig):
     """Configuration for Docker cagent via ACP.
@@ -393,11 +347,6 @@ class CagentACPAgentConfig(BaseACPAgentConfig):
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Cagent supports multiple providers via MCP."""
-        return ["openai", "anthropic", "gemini"]
-
 
 class StakpakACPAgentConfig(BaseACPAgentConfig):
     """Configuration for Stakpak Agent via ACP.
@@ -538,11 +487,6 @@ class StakpakACPAgentConfig(BaseACPAgentConfig):
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Stakpak supports multiple providers."""
-        return ["openai", "anthropic", "gemini"]
-
 
 class VTCodeACPAgentConfig(BaseACPAgentConfig):
     """Configuration for VT Code via ACP.
@@ -644,7 +588,7 @@ class VTCodeACPAgentConfig(BaseACPAgentConfig):
     )
     """Configuration file path."""
 
-    skip_confirmations: bool = Field(default=False, title="Skip Confirmations")
+    auto_approve: bool = Field(default=False, title="Auto Approve")
     """Skip safety confirmations."""
 
     full_auto: bool = Field(default=False, title="Full Auto")
@@ -684,18 +628,13 @@ class VTCodeACPAgentConfig(BaseACPAgentConfig):
             args.extend(["--max-tool-calls", str(self.max_tool_calls)])
         if self.config:
             args.extend(["--config", self.config])
-        if self.skip_confirmations:
+        if self.auto_approve:
             args.append("--skip-confirmations")
         if self.full_auto:
             args.append("--full-auto")
 
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """VT Code supports multiple providers."""
-        return ["openai", "anthropic", "gemini"]
-
 
 class CursorACPAgentConfig(BaseACPAgentConfig):
     """Configuration for Cursor via ACP.
@@ -748,25 +687,13 @@ class CursorACPAgentConfig(BaseACPAgentConfig):
     )
     """Session storage directory (default: ~/.cursor-sessions)."""
 
-    timeout: int | None = Field(
-        default=None,
-        title="Timeout",
-        examples=[30000, 60000],
-    )
+    timeout: int | None = Field(default=None, title="Timeout", examples=[30000, 60000])
     """Cursor-agent timeout in milliseconds (default: 30000)."""
 
-    retries: int | None = Field(
-        default=None,
-        title="Retries",
-        examples=[3, 5],
-    )
+    retries: int | None = Field(default=None, title="Retries", examples=[3, 5])
     """Number of retries for cursor-agent commands (default: 3)."""
 
-    max_sessions: int | None = Field(
-        default=None,
-        title="Max Sessions",
-        examples=[100, 200],
-    )
+    max_sessions: int | None = Field(default=None, title="Max Sessions", examples=[100, 200])
     """Maximum number of concurrent sessions (default: 100)."""
 
     session_timeout: int | None = Field(
@@ -782,11 +709,7 @@ class CursorACPAgentConfig(BaseACPAgentConfig):
     no_terminal: bool = Field(default=False, title="No Terminal")
     """Disable terminal tools."""
 
-    max_processes: int | None = Field(
-        default=None,
-        title="Max Processes",
-        examples=[5, 10],
-    )
+    max_processes: int | None = Field(default=None, title="Max Processes", examples=[5, 10])
     """Maximum number of terminal processes (default: 5)."""
 
     def get_command(self) -> str:
@@ -821,10 +744,120 @@ class CursorACPAgentConfig(BaseACPAgentConfig):
             args.extend(["--max-processes", str(self.max_processes)])
         return args
 
-    @property
-    def model_providers(self) -> list[ProviderType]:
-        """Cursor supports multiple providers."""
-        return ["openai", "anthropic", "gemini", "openrouter"]
+
+class GeminiACPAgentConfig(BaseACPAgentConfig):
+    """Configuration for Gemini CLI via ACP.
+
+    Provides typed settings for the gemini CLI with ACP support.
+
+    Note:
+        Gemini CLI does not support runtime MCP server injection via config.
+        MCP servers must be pre-configured using `gemini mcp add` command.
+
+    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."""
+
+    auto_approve: bool = Field(default=False, title="Auto Approve")
+    """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"
+
+    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.auto_approve:
+            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
 
 
 # Union of all ACP agent config types
@@ -839,4 +872,5 @@ RegularACPAgentConfigTypes = (
     | MistralACPAgentConfig
     | VTCodeACPAgentConfig
     | CursorACPAgentConfig
+    | GeminiACPAgentConfig
 )

agentpool/models/agents.py

@@ -4,14 +4,15 @@ from __future__ import annotations
 
 from collections.abc import Sequence  # noqa: TC003
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal, assert_never
+from typing import TYPE_CHECKING, Annotated, Any, Literal, assert_never
 from uuid import UUID
 
-from exxec.configs import ExecutionEnvironmentConfig  # noqa: TC002
-from llmling_models.configs import AnyModelConfig  # noqa: TC002
+from exxec_config import ExecutionEnvironmentConfig  # noqa: TC002
+from llmling_models_config import AnyModelConfig  # noqa: TC002
 from pydantic import ConfigDict, Field, model_validator
 from pydantic_ai import UsageLimits  # noqa: TC002
 from schemez import InlineSchemaDef
+from tokonomics.model_discovery import ProviderType  # noqa: TC002
 from tokonomics.model_names import ModelId  # noqa: TC002
 from toprompt import render_prompt
 
@@ -19,14 +20,15 @@ from agentpool import log
 from agentpool.common_types import EndStrategy  # noqa: TC001
 from agentpool.prompts.prompts import PromptMessage, StaticPrompt
 from agentpool.resource_providers import StaticResourceProvider
+from agentpool_config import BaseToolConfig, NativeAgentToolConfig
+from agentpool_config.builtin_tools import BaseBuiltinToolConfig
 from agentpool_config.hooks import HooksConfig  # noqa: TC001
 from agentpool_config.knowledge import Knowledge  # noqa: TC001
 from agentpool_config.nodes import BaseAgentConfig
 from agentpool_config.output_types import StructuredResponseConfig  # noqa: TC001
 from agentpool_config.session import MemoryConfig, SessionQuery
 from agentpool_config.system_prompts import PromptConfig  # noqa: TC001
-from agentpool_config.tools import BaseToolConfig, ToolConfig  # noqa: TC001
-from agentpool_config.toolsets import ToolsetConfig  # noqa: TC001
+from agentpool_config.toolsets import BaseToolsetConfig, ToolsetConfig
 from agentpool_config.workers import WorkerConfig  # noqa: TC001
 
 
@@ -37,10 +39,15 @@ if TYPE_CHECKING:
 
 
 ToolMode = Literal["codemode"]
-AutoCache = Literal["off", "5m", "1h"]
 
 logger = log.get_logger(__name__)
 
+# Unified type for all tool configurations (single tools + toolsets)
+AnyToolConfig = Annotated[
+    NativeAgentToolConfig | ToolsetConfig,
+    Field(discriminator="type"),
+]
+
 
 class NativeAgentConfig(BaseAgentConfig):
     """Configuration for a single agent in the system.
@@ -61,11 +68,8 @@ class NativeAgentConfig(BaseAgentConfig):
     type: Literal["native"] = Field(default="native", init=False)
     """Top-level discriminator for agent type."""
 
-    inherits: str | None = Field(default=None, title="Inheritance source")
-    """Name of agent config to inherit from"""
-
-    model: AnyModelConfig | ModelId | str | None = Field(
-        default=None,
+    model: AnyModelConfig | ModelId | str = Field(
+        ...,
         examples=["openai:gpt-5-nano"],
         title="Model configuration or name",
         json_schema_extra={
@@ -78,7 +82,7 @@ class NativeAgentConfig(BaseAgentConfig):
     Docs: https://phil65.github.io/agentpool/YAML%20Configuration/model_configuration/
     """
 
-    tools: list[ToolConfig | str] = Field(
+    tools: list[AnyToolConfig | str] = Field(
         default_factory=list,
         examples=[
             ["webbrowser:open", "builtins:print"],
@@ -87,46 +91,30 @@ class NativeAgentConfig(BaseAgentConfig):
                     "type": "import",
                     "import_path": "webbrowser:open",
                     "name": "web_browser",
-                }
-            ],
-        ],
-        title="Tool configurations",
-        json_schema_extra={
-            "documentation_url": "https://phil65.github.io/agentpool/YAML%20Configuration/tool_configuration/"
-        },
-    )
-    """A list of tools to register with this agent.
-
-    Docs: https://phil65.github.io/agentpool/YAML%20Configuration/tool_configuration/
-    """
-
-    toolsets: list[ToolsetConfig] = Field(
-        default_factory=list,
-        examples=[
-            [
+                },
                 {
-                    "type": "openapi",
-                    "spec": "https://api.example.com/openapi.json",
-                    "namespace": "api",
+                    "type": "bash",
+                    "timeout": 30.0,
                 },
                 {
                     "type": "file_access",
                 },
                 {
-                    "type": "composio",
-                    "user_id": "user123@example.com",
-                    "toolsets": ["github", "slack"],
+                    "type": "process_management",
                 },
             ],
         ],
-        title="Toolset configurations",
+        title="Tool configurations",
         json_schema_extra={
-            "documentation_url": "https://phil65.github.io/agentpool/YAML%20Configuration/toolset_configuration/"
+            "documentation_url": "https://phil65.github.io/agentpool/YAML%20Configuration/tool_configuration/"
         },
     )
-    """Toolset configurations for extensible tool collections.
+    """A list of tools and toolsets to register with this agent.
+
+    Supports both single tools (bash, import, web_search, etc.) and
+    toolsets (file_access, process_management, code, etc.).
 
-    Docs: https://phil65.github.io/agentpool/YAML%20Configuration/toolset_configuration/
+    Docs: https://phil65.github.io/agentpool/YAML%20Configuration/tool_configuration/
     """
 
     session: str | SessionQuery | MemoryConfig | None = Field(
@@ -230,6 +218,18 @@ class NativeAgentConfig(BaseAgentConfig):
     usage_limits: UsageLimits | None = Field(default=None, title="Usage limits")
     """Usage limits for this agent."""
 
+    model_providers: list[ProviderType] | None = Field(
+        default=None,
+        examples=[["models.dev"], ["anthropic", "openai"]],
+        title="Model providers",
+    )
+    """List of model providers to use for model discovery.
+
+    When set, the agent's get_available_models() will return models from these
+    providers. Common values: "openai", "anthropic", "gemini", "mistral", etc.
+    If not set, defaults to ["models.dev"].
+    """
+
     tool_mode: ToolMode | None = Field(
         default=None,
         examples=["codemode"],
@@ -240,17 +240,6 @@ class NativeAgentConfig(BaseAgentConfig):
     - "codemode": Tools are wrapped in a Python execution environment
     """
 
-    auto_cache: AutoCache = Field(
-        default="off",
-        examples=["off", "5m", "1h"],
-        title="Automatic caching",
-    )
-    """Automatic prompt caching configuration:
-    - "off": No automatic caching
-    - "5m": Add cache point with 5 minute TTL
-    - "1h": Add cache point with 1 hour TTL
-    """
-
     hooks: HooksConfig | None = Field(
         default=None,
         title="Lifecycle hooks",
@@ -295,43 +284,76 @@ class NativeAgentConfig(BaseAgentConfig):
             data["model"] = {"type": "string", "identifier": model}
         return data
 
-    def get_toolsets(self) -> list[ResourceProvider]:
-        """Get all resource providers for this agent."""
-        providers: list[ResourceProvider] = []
-
-        # Add providers from toolsets
-        for toolset_config in self.toolsets:
-            try:
-                provider = toolset_config.get_provider()
-                providers.append(provider)
-            except Exception as e:
-                msg = "Failed to create provider for toolset"
-                logger.exception(msg, toolset_config)
-                raise ValueError(msg) from e
+    def get_tool_providers(self) -> list[ResourceProvider]:
+        """Get all resource providers for this agent's tools.
 
-        return providers
+        Processes the unified tools list, separating:
+        - Toolsets: Each becomes its own ResourceProvider
+        - Single tools: Aggregated into a single StaticResourceProvider
 
-    def get_tool_provider(self) -> ResourceProvider | None:
-        """Get tool provider for this agent."""
+        Returns:
+            List of ResourceProvider instances
+        """
         from agentpool.tools.base import Tool
 
-        # Create provider for static tools
-        if not self.tools:
-            return None
+        providers: list[ResourceProvider] = []
         static_tools: list[Tool] = []
+
         for tool_config in self.tools:
+            # Skip builtin tools - they're handled via get_builtin_tools()
+            if isinstance(tool_config, BaseBuiltinToolConfig):
+                continue
+
             try:
-                match tool_config:
-                    case str():
-                        tool = Tool.from_callable(tool_config)
-                        static_tools.append(tool)
-                    case BaseToolConfig():
-                        static_tools.append(tool_config.get_tool())
+                if isinstance(tool_config, BaseToolsetConfig):
+                    # Toolset -> get its provider directly
+                    providers.append(tool_config.get_provider())
+                elif isinstance(tool_config, str):
+                    # String import path -> single tool
+                    static_tools.append(Tool.from_callable(tool_config))
+                elif isinstance(tool_config, BaseToolConfig):
+                    # Single tool config -> single tool
+                    static_tools.append(tool_config.get_tool())
             except Exception:
                 logger.exception("Failed to load tool", config=tool_config)
                 continue
 
-        return StaticResourceProvider(name="builtin", tools=static_tools)
+        # Wrap all single tools in one provider
+        if static_tools:
+            providers.append(StaticResourceProvider(name="tools", tools=static_tools))
+
+        return providers
+
+    # Keep old methods for backward compatibility during transition
+    def get_toolsets(self) -> list[ResourceProvider]:
+        """Get toolset providers. Deprecated: use get_tool_providers() instead."""
+        return [
+            p
+            for p in self.get_tool_providers()
+            if not isinstance(p, StaticResourceProvider) or p.name != "tools"
+        ]
+
+    def get_tool_provider(self) -> ResourceProvider | None:
+        """Get single tools provider. Deprecated: use get_tool_providers() instead."""
+        for p in self.get_tool_providers():
+            if isinstance(p, StaticResourceProvider) and p.name == "tools":
+                return p
+        return None
+
+    def get_builtin_tools(self) -> list[Any]:
+        """Get pydantic-ai builtin tools from config.
+
+        Returns:
+            List of AbstractBuiltinTool instances (WebSearchTool, etc.)
+        """
+        builtin_tools: list[Any] = []
+        for tool_config in self.tools:
+            if isinstance(tool_config, BaseBuiltinToolConfig):
+                try:
+                    builtin_tools.append(tool_config.get_builtin_tool())
+                except Exception:
+                    logger.exception("Failed to load builtin tool", config=tool_config)
+        return builtin_tools
 
     def get_session_config(self) -> MemoryConfig:
         """Get resolved memory configuration."""

agentpool/models/agui_agents.py

@@ -6,8 +6,8 @@ from typing import Literal
 
 from pydantic import ConfigDict, Field
 
+from agentpool_config import ToolConfig  # noqa: TC001
 from agentpool_config.nodes import BaseAgentConfig
-from agentpool_config.tools import ToolConfig  # noqa: TC001
 
 
 class AGUIAgentConfig(BaseAgentConfig):