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

agentpool_config/toolsets.py

@@ -5,11 +5,11 @@ from __future__ import annotations
 import os
 from typing import TYPE_CHECKING, Annotated, Literal, cast
 
-from exxec.configs import ExecutionEnvironmentConfig
-from llmling_models.configs.model_configs import AnyModelConfig
+from exxec_config import ExecutionEnvironmentConfig
+from llmling_models_config import AnyModelConfig
 from pydantic import ConfigDict, EmailStr, Field, HttpUrl, SecretStr
 from schemez import Schema
-from searchly.config import (
+from searchly_config import (
     NewsSearchProviderConfig,
     NewsSearchProviderName,
     WebSearchProviderConfig,
@@ -18,8 +18,8 @@ from searchly.config import (
 )
 from tokonomics.model_names import ModelId
 from upathtools import UPath
-from upathtools.configs import FilesystemConfigType
-from upathtools.configs.base import FileSystemConfig
+from upathtools_config import FilesystemConfigType
+from upathtools_config.base import FileSystemConfig
 
 from agentpool_config.converters import ConversionConfig
 from agentpool_config.tools import ImportToolConfig
@@ -33,12 +33,6 @@ if TYPE_CHECKING:
 
 MarkupType = Literal["yaml", "json", "toml"]
 # Tool name literals for statically-defined toolsets
-AgentManagementToolName = Literal[
-    "create_worker_agent",
-    "add_agent",
-    "add_team",
-    "connect_nodes",
-]
 SubagentToolName = Literal[
     "list_available_nodes",
     "delegate_to",
@@ -46,7 +40,7 @@ SubagentToolName = Literal[
 ]
 ExecutionEnvironmentToolName = Literal[
     "execute_code",
-    "execute_command",
+    "bash",
     "start_process",
     "get_process_output",
     "wait_for_process",
@@ -55,13 +49,10 @@ ExecutionEnvironmentToolName = Literal[
     "list_processes",
 ]
 
-ToolManagementToolName = Literal["register_tool", "register_code_tool"]
-UserInteractionToolName = Literal["ask_user",]
-HistoryToolName = Literal["search_history", "show_statistics"]
 SkillsToolName = Literal["load_skill", "list_skills"]
-IntegrationToolName = Literal["add_local_mcp_server", "add_remote_mcp_server"]
 CodeToolName = Literal["format_code", "ast_grep"]
 PlanToolName = Literal["get_plan", "add_plan_entry", "update_plan_entry", "remove_plan_entry"]
+PlanToolMode = Literal["granular", "declarative"]
 
 
 class BaseToolsetConfig(Schema):
@@ -176,37 +167,6 @@ class ComposioToolSetConfig(BaseToolsetConfig):
         return ComposioTools(user_id=self.user_id, toolsets=self.toolsets, api_key=key)
 
 
-class AgentManagementToolsetConfig(BaseToolsetConfig):
-    """Configuration for agent pool building tools."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "x-icon": "octicon:people-16",
-            "x-doc-title": "Agent Management Toolset",
-        }
-    )
-
-    type: Literal["agent_management"] = Field("agent_management", init=False)
-    """Agent pool building toolset (create_worker_agent, add_agent, add_team, connect_nodes)."""
-
-    tools: dict[AgentManagementToolName, bool] | None = Field(
-        default=None,
-        title="Tool filter",
-    )
-    """Optional tool filter to enable/disable specific tools."""
-
-    def get_provider(self) -> ResourceProvider:
-        """Create agent management tools provider."""
-        from agentpool_toolsets.builtin import AgentManagementTools
-
-        provider = AgentManagementTools(name="agent_management")
-        if self.tools is not None:
-            from agentpool.resource_providers import FilteringResourceProvider
-
-            return FilteringResourceProvider(provider, cast(dict[str, bool], self.tools))
-        return provider
-
-
 class SubagentToolsetConfig(BaseToolsetConfig):
     """Configuration for subagent interaction tools."""
 
@@ -274,24 +234,24 @@ class WorkersToolsetConfig(BaseToolsetConfig):
         return WorkersTools(workers=self.workers, name="workers")
 
 
-class ExecutionEnvironmentToolsetConfig(BaseToolsetConfig):
-    """Configuration for execution environment toolset (code + process management)."""
+class ProcessManagementToolsetConfig(BaseToolsetConfig):
+    """Configuration for process management toolset (code + process management)."""
 
     model_config = ConfigDict(
         json_schema_extra={
             "x-icon": "octicon:terminal-16",
-            "x-doc-title": "Execution Environment Toolset",
+            "x-doc-title": "Process management Toolset",
         }
     )
 
-    type: Literal["execution"] = Field("execution", init=False)
-    """Execution environment toolset."""
+    type: Literal["process_management"] = Field("process_management", init=False)
+    """Process management toolset."""
 
     environment: ExecutionEnvironmentConfig | None = Field(
         default=None,
-        title="Execution environment",
+        title="Process management",
     )
-    """Optional execution environment configuration (defaults to local)."""
+    """Optional Process management configuration (defaults to local)."""
 
     tools: dict[ExecutionEnvironmentToolName, bool] | None = Field(
         default=None,
@@ -300,104 +260,11 @@ class ExecutionEnvironmentToolsetConfig(BaseToolsetConfig):
     """Optional tool filter to enable/disable specific tools."""
 
     def get_provider(self) -> ResourceProvider:
-        """Create execution environment tools provider."""
-        from agentpool_toolsets.builtin import ExecutionEnvironmentTools
+        """Create Process management tools provider."""
+        from agentpool_toolsets.builtin import ProcessManagementTools
 
         env = self.environment.get_provider() if self.environment else None
-        provider = ExecutionEnvironmentTools(env=env, name="execution")
-        if self.tools is not None:
-            from agentpool.resource_providers import FilteringResourceProvider
-
-            return FilteringResourceProvider(provider, cast(dict[str, bool], self.tools))
-        return provider
-
-
-class ToolManagementToolsetConfig(BaseToolsetConfig):
-    """Configuration for tool management toolset."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "x-icon": "octicon:tools-16",
-            "x-doc-title": "Tool Management Toolset",
-        }
-    )
-
-    type: Literal["tool_management"] = Field("tool_management", init=False)
-    """Tool management toolset."""
-
-    tools: dict[ToolManagementToolName, bool] | None = Field(
-        default=None,
-        title="Tool filter",
-    )
-    """Optional tool filter to enable/disable specific tools."""
-
-    def get_provider(self) -> ResourceProvider:
-        """Create tool management tools provider."""
-        from agentpool_toolsets.builtin import ToolManagementTools
-
-        provider = ToolManagementTools(name="tool_management")
-        if self.tools is not None:
-            from agentpool.resource_providers import FilteringResourceProvider
-
-            return FilteringResourceProvider(provider, cast(dict[str, bool], self.tools))
-        return provider
-
-
-class UserInteractionToolsetConfig(BaseToolsetConfig):
-    """Configuration for user interaction toolset."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "x-icon": "octicon:comment-discussion-16",
-            "x-doc-title": "User Interaction Toolset",
-        }
-    )
-
-    type: Literal["user_interaction"] = Field("user_interaction", init=False)
-    """User interaction toolset."""
-
-    tools: dict[UserInteractionToolName, bool] | None = Field(
-        default=None,
-        title="Tool filter",
-    )
-    """Optional tool filter to enable/disable specific tools."""
-
-    def get_provider(self) -> ResourceProvider:
-        """Create user interaction tools provider."""
-        from agentpool_toolsets.builtin import UserInteractionTools
-
-        provider = UserInteractionTools(name="user_interaction")
-        if self.tools is not None:
-            from agentpool.resource_providers import FilteringResourceProvider
-
-            return FilteringResourceProvider(provider, cast(dict[str, bool], self.tools))
-        return provider
-
-
-class HistoryToolsetConfig(BaseToolsetConfig):
-    """Configuration for history toolset."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "x-icon": "octicon:history-16",
-            "x-doc-title": "History Toolset",
-        }
-    )
-
-    type: Literal["history"] = Field("history", init=False)
-    """History toolset."""
-
-    tools: dict[HistoryToolName, bool] | None = Field(
-        default=None,
-        title="Tool filter",
-    )
-    """Optional tool filter to enable/disable specific tools."""
-
-    def get_provider(self) -> ResourceProvider:
-        """Create history tools provider."""
-        from agentpool_toolsets.builtin import HistoryTools
-
-        provider = HistoryTools(name="history")
+        provider = ProcessManagementTools(env=env, name="process_management")
         if self.tools is not None:
             from agentpool.resource_providers import FilteringResourceProvider
 
@@ -441,37 +308,6 @@ class SkillsToolsetConfig(BaseToolsetConfig):
         return provider
 
 
-class IntegrationToolsetConfig(BaseToolsetConfig):
-    """Configuration for integration toolset."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "x-icon": "octicon:link-16",
-            "x-doc-title": "Integration Toolset",
-        }
-    )
-
-    type: Literal["integrations"] = Field("integrations", init=False)
-    """Integration toolset."""
-
-    tools: dict[IntegrationToolName, bool] | None = Field(
-        default=None,
-        title="Tool filter",
-    )
-    """Optional tool filter to enable/disable specific tools."""
-
-    def get_provider(self) -> ResourceProvider:
-        """Create integration tools provider."""
-        from agentpool_toolsets.builtin import IntegrationTools
-
-        provider = IntegrationTools(name="integrations")
-        if self.tools is not None:
-            from agentpool.resource_providers import FilteringResourceProvider
-
-            return FilteringResourceProvider(provider, cast(dict[str, bool], self.tools))
-        return provider
-
-
 class CodeToolsetConfig(BaseToolsetConfig):
     """Configuration for code toolset."""
 
@@ -607,6 +443,32 @@ class FSSpecToolsetConfig(BaseToolsetConfig):
     )
     """Maximum tokens for structure map output when reading large files."""
 
+    edit_tool: Literal["simple", "batch", "agentic"] = Field(
+        default="simple",
+        title="Edit tool variant",
+    )
+    """Which edit tool to expose: "simple" (single replacement),
+    "batch" (multiple replacements), or "agentic" (LLM-driven editing)."""
+
+    max_image_size: int | None = Field(
+        default=2000,
+        ge=100,
+        le=8192,
+        title="Maximum image dimension",
+    )
+    """Max width/height for images in pixels. Larger images are auto-resized
+    for better model compatibility. Set to None to disable resizing."""
+
+    max_image_bytes: int | None = Field(
+        default=None,
+        ge=102400,
+        le=20971520,
+        title="Maximum image file size",
+    )
+    """Max file size for images in bytes. Images exceeding this are compressed
+    using progressive quality/dimension reduction. Default: 4.5MB (Anthropic limit).
+    Set to None to use the default 4.5MB limit."""
+
     def get_provider(self) -> ResourceProvider:
         """Create FSSpec filesystem tools provider."""
         import fsspec
@@ -641,6 +503,9 @@ class FSSpecToolsetConfig(BaseToolsetConfig):
             enable_diagnostics=self.enable_diagnostics,
             large_file_tokens=self.large_file_tokens,
             map_max_tokens=self.map_max_tokens,
+            edit_tool=self.edit_tool,
+            max_image_size=self.max_image_size,
+            max_image_bytes=self.max_image_bytes,
         )
 
 
@@ -747,41 +612,6 @@ class NotificationsToolsetConfig(BaseToolsetConfig):
         return NotificationsTools(channels=self.channels)
 
 
-class SemanticMemoryToolsetConfig(BaseToolsetConfig):
-    """Configuration for semantic memory / knowledge processing toolset."""
-
-    model_config = ConfigDict(
-        json_schema_extra={
-            "x-icon": "octicon:database-16",
-            "x-doc-title": "Semantic Memory Toolset",
-        }
-    )
-
-    type: Literal["semantic_memory"] = Field("semantic_memory", init=False)
-    """Semantic memory toolset using TypeAgent's KnowPro."""
-
-    model: str | ModelId | AnyModelConfig | None = Field(
-        default=None,
-        examples=["openai:gpt-4o", "anthropic:claude-sonnet-4-20250514"],
-        title="Model for LLM sampling",
-    )
-    """Model to use for query translation and answer generation."""
-
-    dbname: str | None = Field(
-        default=None,
-        examples=["knowledge.db", "/path/to/memory.db"],
-        title="Database path",
-    )
-    """SQLite database path for persistent storage, or None for in-memory."""
-
-    def get_provider(self) -> ResourceProvider:
-        """Create semantic memory tools provider."""
-        from agentpool_toolsets.semantic_memory_toolset import SemanticMemoryTools
-
-        model = m if isinstance(m := self.model, str) or m is None else m.get_model()
-        return SemanticMemoryTools(model=model, dbname=self.dbname)
-
-
 class CustomToolsetConfig(BaseToolsetConfig):
     """Configuration for custom toolsets."""
 
@@ -949,6 +779,17 @@ class PlanToolsetConfig(BaseToolsetConfig):
     type: Literal["plan"] = Field("plan", init=False)
     """Plan toolset."""
 
+    mode: PlanToolMode = Field(
+        default="declarative",
+        title="Plan tool mode",
+    )
+    """Tool mode:
+    - 'declarative': Single set_plan tool with full list (default, recommended)
+      - Fewer calls, better UX with parallel updates
+    - 'granular': Separate tools (get/add/update/remove)
+      - For simpler models or fine-grained control
+    """
+
     tools: dict[PlanToolName, bool] | None = Field(
         default=None,
         title="Tool filter",
@@ -959,7 +800,7 @@ class PlanToolsetConfig(BaseToolsetConfig):
         """Create plan tools provider."""
         from agentpool.resource_providers import PlanProvider
 
-        provider = PlanProvider()
+        provider = PlanProvider(mode=self.mode)
         if self.tools is not None:
             from agentpool.resource_providers import FilteringResourceProvider
 
@@ -987,19 +828,59 @@ class DebugToolsetConfig(BaseToolsetConfig):
     type: Literal["debug"] = Field("debug", init=False)
     """Debug toolset."""
 
-    install_log_handler: bool = Field(
-        default=True,
-        title="Install log handler",
-    )
-    """Whether to install the memory log handler for log inspection."""
-
     def get_provider(self) -> ResourceProvider:
         """Create debug tools provider."""
         from agentpool_toolsets.builtin.debug import DebugTools
 
-        return DebugTools(
-            name=self.namespace or "debug",
-            install_log_handler=self.install_log_handler,
+        return DebugTools(name=self.namespace or "debug")
+
+
+class MCPDiscoveryToolsetConfig(BaseToolsetConfig):
+    """Configuration for MCP discovery toolset.
+
+    Enables dynamic discovery and use of MCP servers without preloading tools.
+    Uses semantic search over 1000+ indexed servers for intelligent matching.
+
+    Requires the `mcp-discovery` extra: `pip install agentpool[mcp-discovery]`
+    """
+
+    model_config = ConfigDict(
+        json_schema_extra={
+            "x-icon": "octicon:search-16",
+            "x-doc-title": "MCP Discovery Toolset",
+        }
+    )
+
+    type: Literal["mcp_discovery"] = Field("mcp_discovery", init=False)
+    """MCP discovery toolset."""
+
+    registry_url: str = Field(
+        default="https://registry.modelcontextprotocol.io",
+        title="Registry URL",
+    )
+    """Base URL for the MCP registry API."""
+
+    allowed_servers: list[str] | None = Field(
+        default=None,
+        title="Allowed servers",
+    )
+    """If set, only these server names can be used."""
+
+    blocked_servers: list[str] | None = Field(
+        default=None,
+        title="Blocked servers",
+    )
+    """Server names that cannot be used."""
+
+    def get_provider(self) -> ResourceProvider:
+        """Create MCP discovery tools provider."""
+        from agentpool_toolsets.mcp_discovery.toolset import MCPDiscoveryToolset
+
+        return MCPDiscoveryToolset(
+            name=self.namespace or "mcp_discovery",
+            registry_url=self.registry_url,
+            allowed_servers=self.allowed_servers,
+            blocked_servers=self.blocked_servers,
         )
 
 
@@ -1007,13 +888,8 @@ ToolsetConfig = Annotated[
     OpenAPIToolsetConfig
     | EntryPointToolsetConfig
     | ComposioToolSetConfig
-    | AgentManagementToolsetConfig
-    | ExecutionEnvironmentToolsetConfig
-    | ToolManagementToolsetConfig
-    | UserInteractionToolsetConfig
-    | HistoryToolsetConfig
+    | ProcessManagementToolsetConfig
     | SkillsToolsetConfig
-    | IntegrationToolsetConfig
     | CodeToolsetConfig
     | FSSpecToolsetConfig
     | VFSToolsetConfig
@@ -1023,11 +899,11 @@ ToolsetConfig = Annotated[
     | RemoteCodeModeToolsetConfig
     | SearchToolsetConfig
     | NotificationsToolsetConfig
-    | SemanticMemoryToolsetConfig
     | ConfigCreationToolsetConfig
     | ImportToolsToolsetConfig
     | PlanToolsetConfig
     | DebugToolsetConfig
+    | MCPDiscoveryToolsetConfig
     | CustomToolsetConfig,
     Field(discriminator="type"),
 ]