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

agentpool/models/claude_code_agents.py

@@ -6,18 +6,47 @@ from collections.abc import Sequence  # noqa: TC003
 from typing import TYPE_CHECKING, Literal
 
 from pydantic import ConfigDict, Field
-
+from tokonomics.model_names import AnthropicMaxModelName  # noqa: TC002
+
+from agentpool import log
+from agentpool.resource_providers import StaticResourceProvider
+from agentpool_config import (
+    AnyToolConfig,  # noqa: TC001
+    BaseToolConfig,
+)
 from agentpool_config.nodes import BaseAgentConfig
 from agentpool_config.output_types import StructuredResponseConfig  # noqa: TC001
 from agentpool_config.system_prompts import PromptConfig  # noqa: TC001
-from agentpool_config.toolsets import ToolsetConfig  # noqa: TC001
 
 
 if TYPE_CHECKING:
     from agentpool.resource_providers import ResourceProvider
 
+logger = log.get_logger(__name__)
 
 PermissionMode = Literal["default", "acceptEdits", "plan", "bypassPermissions"]
+SettingSource = Literal["user", "project", "local"]
+ToolName = Literal[
+    "Task",
+    "TaskOutput",
+    "Bash",
+    "Glob",
+    "Grep",
+    "ExitPlanMode",
+    "Read",
+    "Edit",
+    "Write",
+    "NotebookEdit",
+    "WebFetch",
+    "TodoWrite",
+    "WebSearch",
+    "KillShell",
+    "AskUserQuestion",
+    "Skill",
+    "EnterPlanMode",
+    "LSP",
+    "Chrome",
+]
 
 
 class ClaudeCodeAgentConfig(BaseAgentConfig):
@@ -67,14 +96,14 @@ class ClaudeCodeAgentConfig(BaseAgentConfig):
     )
     """Working directory for Claude Code operations."""
 
-    model: str | None = Field(
+    model: AnthropicMaxModelName | str | None = Field(
         default=None,
         title="Model",
         examples=["claude-sonnet-4-5", "claude-opus-4", "claude-haiku-3-5"],
     )
     """Model to use for this agent. Defaults to Claude's default model."""
 
-    allowed_tools: list[str] | None = Field(
+    allowed_tools: list[ToolName | str] | None = Field(
         default=None,
         title="Allowed Tools",
         examples=[["Read", "Write", "Bash"], ["Read", "Grep", "Glob"]],
@@ -85,7 +114,7 @@ class ClaudeCodeAgentConfig(BaseAgentConfig):
     Common tools: Read, Write, Edit, Bash, Glob, Grep, Task, WebFetch, etc.
     """
 
-    disallowed_tools: list[str] | None = Field(
+    disallowed_tools: list[ToolName | str] | None = Field(
         default=None,
         title="Disallowed Tools",
         examples=[["Bash", "Write"], ["Task"]],
@@ -132,6 +161,17 @@ class ClaudeCodeAgentConfig(BaseAgentConfig):
     )
     """Maximum number of conversation turns before stopping."""
 
+    max_budget_usd: float | None = Field(
+        default=None,
+        title="Max Budget (USD)",
+        ge=0.0,
+        examples=[1.0, 5.0, 10.0],
+    )
+    """Maximum budget in USD before stopping.
+
+    When set, the agent will stop once the estimated cost exceeds this limit.
+    """
+
     max_thinking_tokens: int | None = Field(
         default=None,
         title="Max Thinking Tokens",
@@ -188,15 +228,23 @@ class ClaudeCodeAgentConfig(BaseAgentConfig):
     builtin_tools: list[str] | None = Field(
         default=None,
         title="Built-in Tools",
-        examples=[["Bash", "Edit", "Read"], []],
+        examples=[["Bash", "Edit", "Read"], ["Read", "Write", "LSP"], ["Bash", "Chrome"]],
     )
     """Available tools from Claude Code's built-in set.
 
     Empty list disables all tools. If not specified, all tools are available.
     Different from allowed_tools which filters an already-available set.
+
+    Special tools:
+    - "LSP": Enable Language Server Protocol support for code intelligence
+      (go to definition, find references, symbol info, etc.)
+    - "Chrome": Enable Claude in Chrome integration for browser control
+      (opens, navigates, interacts with browser tabs)
+
+    Both LSP and Chrome require additional setup in your environment.
     """
 
-    fallback_model: str | None = Field(
+    fallback_model: AnthropicMaxModelName | str | None = Field(
         default=None,
         title="Fallback Model",
         examples=["claude-sonnet-4-5", "claude-haiku-3-5"],
@@ -209,30 +257,107 @@ class ClaudeCodeAgentConfig(BaseAgentConfig):
     )
     """Bypass all permission checks. Only for sandboxed environments."""
 
-    toolsets: list[ToolsetConfig] = Field(
+    setting_sources: list[SettingSource] | None = Field(
+        default=None,
+        title="Setting Sources",
+        examples=[["user", "project"], ["local"], ["user", "project", "local"]],
+    )
+    """Setting sources to load configuration from.
+
+    Controls which Claude Code settings files are loaded:
+    - "user": User-level settings (~/.config/claude/settings.json)
+    - "project": Project-level settings (.claude/settings.json in project root)
+    - "local": Local settings (.claude/settings.local.json, git-ignored)
+
+    If not specified, Claude Code will load all available settings.
+    """
+
+    use_subscription: bool = Field(
+        default=False,
+        title="Use Claude Subscription",
+    )
+    """Force usage of Claude subscription instead of API key.
+
+    When True, sets ANTHROPIC_API_KEY to empty string, forcing Claude Code
+    to use your Claude.ai subscription for authentication instead of an API key.
+
+    This is useful when:
+    - You have a Claude Pro/Team subscription with higher rate limits
+    - You want to use subscription credits instead of API credits
+    - You're using features only available to subscribers
+
+    Note: Requires an active Claude subscription and logged-in session.
+    """
+
+    tools: list[AnyToolConfig | str] = Field(
         default_factory=list,
-        title="Toolsets",
+        title="Tools",
         examples=[
             [
                 {"type": "subagent"},
                 {"type": "agent_management"},
+                "webbrowser:open",
+                {
+                    "type": "import",
+                    "import_path": "webbrowser:open",
+                    "name": "web_browser",
+                },
             ],
         ],
     )
-    """Toolsets to expose to this Claude Code agent via MCP bridge.
+    """Tools and toolsets to expose to this Claude Code agent via MCP bridge.
 
-    These toolsets will be started as an in-process MCP server and made
-    available to Claude Code. This allows Claude Code to use internal
-    agentpool toolsets like subagent delegation, agent management, etc.
+    Supports both single tools and toolsets. These will be started as an
+    in-process MCP server and made available to Claude Code.
 
-    The toolsets are exposed using the Claude SDK's native MCP support,
-    which passes the FastMCP server instance directly without HTTP overhead.
+    Docs: https://phil65.github.io/agentpool/YAML%20Configuration/tool_configuration/
     """
 
-    def get_toolset_providers(self) -> list[ResourceProvider]:
-        """Get resource providers for all configured toolsets.
+    def get_tool_providers(self) -> list[ResourceProvider]:
+        """Get all resource providers for this agent's tools.
+
+        Processes the unified tools list, separating:
+        - Toolsets: Each becomes its own ResourceProvider
+        - Single tools: Aggregated into a single StaticResourceProvider
 
         Returns:
-            List of initialized ResourceProvider instances
+            List of ResourceProvider instances
         """
-        return [toolset.get_provider() for toolset in self.toolsets]
+        from agentpool.tools.base import Tool
+        from agentpool_config.toolsets import BaseToolsetConfig
+
+        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:
+                logger.exception("Failed to load tool", config=tool_config)
+                continue
+
+        if static_tools:
+            providers.append(StaticResourceProvider(name="tools", tools=static_tools))
+
+        return providers
+
+    # Backward compatibility
+    def get_toolset_providers(self) -> list[ResourceProvider]:
+        """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:
+        """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

agentpool/models/file_parsing.py

@@ -41,7 +41,6 @@ PERMISSION_MODE_MAP: dict[str, Literal["always", "never", "per_tool"]] = {
 
 # Fields that pass through directly to NativeAgentConfig
 PASSTHROUGH_FIELDS = {
-    "inherits",
     "toolsets",
     "session",
     "output_type",

agentpool/models/manifest.py

@@ -5,18 +5,20 @@ from __future__ import annotations
 from functools import cached_property
 from typing import TYPE_CHECKING, Annotated, Any, Self
 
+from llmling_models_config import AnyModelConfig, StringModelConfig
 from pydantic import ConfigDict, Field, model_validator
 from schemez import Schema
-from upathtools.configs import FilesystemConfigType
-from upathtools.configs.base import URIFileSystemConfig
+from upathtools_config import FilesystemConfigType
+from upathtools_config.base import URIFileSystemConfig
 
 from agentpool import log
 from agentpool.models.acp_agents import ACPAgentConfigTypes
-from agentpool.models.agents import NativeAgentConfig
+from agentpool.models.agents import AnyToolConfig, NativeAgentConfig  # noqa: F401
 from agentpool.models.agui_agents import AGUIAgentConfig
 from agentpool.models.claude_code_agents import ClaudeCodeAgentConfig
 from agentpool.models.file_agents import FileAgentConfig
 from agentpool_config.commands import CommandConfig, StaticCommandConfig
+from agentpool_config.compaction import CompactionConfig
 from agentpool_config.converters import ConversionConfig
 from agentpool_config.mcp_server import BaseMCPServerConfig, MCPServerConfig
 from agentpool_config.observability import ObservabilityConfig
@@ -38,6 +40,7 @@ from agentpool_config.workers import (
 if TYPE_CHECKING:
     from upathtools import JoinablePathLike
 
+    from agentpool.messaging.compaction import CompactionPipeline
     from agentpool.models.acp_agents import BaseACPAgentConfig
     from agentpool.prompts.manager import PromptManager
     from agentpool.vfs_registry import VFSRegistry
@@ -77,6 +80,12 @@ class AgentsManifest(Schema):
     INHERIT: str | list[str] | None = None
     """Inheritance references."""
 
+    name: str | None = None
+    """Optional name for this manifest.
+
+    Useful for identification when working with multiple configurations.
+    """
+
     resources: dict[str, ResourceConfig] = Field(
         default_factory=dict,
         examples=[
@@ -212,6 +221,52 @@ class AgentsManifest(Schema):
     Docs: https://phil65.github.io/agentpool/YAML%20Configuration/response_configuration/
     """
 
+    model_variants: dict[str, AnyModelConfig] = Field(
+        default_factory=dict,
+        examples=[
+            {
+                "thinking_high": {
+                    "type": "anthropic",
+                    "model": "claude-sonnet-4-5",
+                    "max_thinking_tokens": 10000,
+                },
+                "fast_gpt": {
+                    "type": "string",
+                    "model": "openai:gpt-4o-mini",
+                    "temperature": 0.3,
+                },
+            }
+        ],
+    )
+    """Named model variants with pre-configured settings.
+
+    Define reusable model configurations that can be referenced by name
+    in agent configs. Each variant specifies a base model and its settings.
+
+    Note: Currently only applies to native agents.
+
+    Example:
+        ```yaml
+        model_variants:
+          thinking_high:
+            type: anthropic
+            model: claude-sonnet-4-5
+            max_thinking_tokens: 10000
+
+          fast_gpt:
+            type: string
+            model: openai:gpt-4o-mini
+            temperature: 0.3
+        ```
+
+    Then use in agents:
+        ```yaml
+        agents:
+          assistant:
+            model: thinking_high  # References the variant
+        ```
+    """
+
     jobs: dict[str, Job[Any]] = Field(default_factory=dict)
     """Pre-defined jobs, ready to be used by nodes."""
 
@@ -272,6 +327,30 @@ class AgentsManifest(Schema):
             path: "./prompts/analysis.md"
     """
 
+    compaction: CompactionConfig | None = None
+    """Compaction configuration for message history management.
+
+    Controls how conversation history is compacted/summarized to manage context size.
+    Can use a preset or define custom steps:
+        compaction:
+          preset: balanced  # or: minimal, summarizing
+
+    Or custom steps:
+        compaction:
+          steps:
+            - type: filter_thinking
+            - type: summarize
+              model: openai:gpt-4o-mini
+              threshold: 15
+    """
+
+    config_file_path: str | None = Field(default=None, exclude=True)
+    """Path to the configuration file this manifest was loaded from.
+
+    Set automatically by `from_file()`. Used for resolving relative paths.
+    Excluded from serialization.
+    """
+
     model_config = ConfigDict(
         json_schema_extra={
             "x-icon": "octicon:file-code-16",
@@ -389,6 +468,25 @@ class AgentsManifest(Schema):
             registry.register_from_config(name, config)
         return registry
 
+    def resolve_model(self, model: AnyModelConfig | str) -> AnyModelConfig:
+        """Resolve a model specification to a model config.
+
+        If model is a string, checks model_variants first, then wraps in StringModelConfig.
+        If model is already an AnyModelConfig, returns it unchanged.
+
+        Args:
+            model: Model identifier, variant name, or config
+
+        Returns:
+            AnyModelConfig
+        """
+        if isinstance(model, str):
+            if model in self.model_variants:
+                return self.model_variants[model]
+            return StringModelConfig(identifier=model)
+        # Already a config
+        return model
+
     def clone_agent_config(
         self,
         name: str,
@@ -437,52 +535,6 @@ class AgentsManifest(Schema):
         self.agents[actual_name] = config
         return actual_name
 
-    @model_validator(mode="before")
-    @classmethod
-    def resolve_inheritance(cls, data: dict[str, Any]) -> dict[str, Any]:
-        """Resolve agent inheritance chains."""
-        nodes = data.get("agents", {})
-        resolved: dict[str, dict[str, Any]] = {}
-        seen: set[str] = set()
-
-        def resolve_node(name: str) -> dict[str, Any] | Any:
-            if name in resolved:
-                return resolved[name]
-
-            node = nodes[name]
-            # Skip model instances - they're already validated
-            if not isinstance(node, dict):
-                return node
-
-            if name in seen:
-                msg = f"Circular inheritance detected: {name}"
-                raise ValueError(msg)
-
-            seen.add(name)
-            config = node.copy()
-            inherit = config.get("inherits")
-            if inherit:
-                if inherit not in nodes:
-                    msg = f"Parent agent {inherit} not found"
-                    raise ValueError(msg)
-
-                parent = resolve_node(inherit)  # Get resolved parent config
-                if isinstance(parent, dict):
-                    merged = parent.copy()
-                    merged.update(config)
-                    config = merged
-
-            seen.remove(name)
-            resolved[name] = config
-            return config
-
-        for name in nodes:
-            resolved[name] = resolve_node(name)
-
-        # Update nodes with resolved configs
-        data["agents"] = resolved
-        return data
-
     @cached_property
     def _loaded_file_agents(self) -> dict[str, NativeAgentConfig]:
         """Load and cache file-based agent configurations.
@@ -583,6 +635,16 @@ class AgentsManifest(Schema):
 
         return PromptManager(self.prompts)
 
+    def get_compaction_pipeline(self) -> CompactionPipeline | None:
+        """Get the configured compaction pipeline, if any.
+
+        Returns:
+            CompactionPipeline instance or None if not configured
+        """
+        if self.compaction is None:
+            return None
+        return self.compaction.build()
+
     # @model_validator(mode="after")
     # def validate_response_types(self) -> AgentsManifest:
     #     """Ensure all agent output_types exist in responses or are inline."""
@@ -623,6 +685,7 @@ class AgentsManifest(Schema):
 
             return agent_def.model_copy(
                 update={
+                    "config_file_path": path_str,
                     "agents": update_with_path(agent_def.agents),
                     "teams": update_with_path(agent_def.teams),
                 }
@@ -650,7 +713,7 @@ class AgentsManifest(Schema):
 
 
 if __name__ == "__main__":
-    from llmling_models.configs import InputModelConfig
+    from llmling_models_config import InputModelConfig
 
     model = InputModelConfig()
     agent_cfg = NativeAgentConfig(name="test_agent", model=model)

agentpool/prompts/conversion_manager.py

@@ -87,7 +87,7 @@ class ConversionManager:
 
 
 if __name__ == "__main__":
-    from docler.configs.converter_configs import MarkItDownConfig
+    from docler_config.converter_configs import MarkItDownConfig
 
     from agentpool_config.converters import ConversionConfig
 

agentpool/prompts/prompts.py

@@ -8,7 +8,6 @@ import inspect
 import os
 from typing import TYPE_CHECKING, Annotated, Any, Literal, Self, assert_never
 
-from mcp.types import Prompt as MCPPrompt, PromptArgument
 from pydantic import ConfigDict, Field
 from pydantic_ai import BinaryContent, ImageUrl, SystemPromptPart, UserPromptPart
 from schemez import Schema
@@ -24,9 +23,9 @@ if TYPE_CHECKING:
     from collections.abc import Mapping
 
     from fastmcp.prompts.prompt import FunctionPrompt, Prompt as FastMCPPrompt
+    from mcp.types import Prompt as MCPPrompt, PromptArgument
     from pydantic_ai import ModelRequestPart
 
-
 logger = get_logger(__name__)
 
 MessageContentType = Literal["text", "resource", "image_url", "image_base64"]
@@ -421,6 +420,8 @@ class MCPClientPrompt(BasePrompt):
 
     def to_mcp_prompt(self) -> MCPPrompt:
         """Convert to MCP Prompt."""
+        from mcp.types import Prompt as MCPPrompt, PromptArgument
+
         args = [
             PromptArgument(name=i["name"], description=i["description"], required=i["required"])
             for i in self.arguments
@@ -516,6 +517,8 @@ class FilePrompt(BasePrompt):
 
     def to_mcp_prompt(self) -> MCPPrompt:
         """Convert to MCP Prompt."""
+        from mcp.types import Prompt as MCPPrompt
+
         return MCPPrompt(
             name=self.name or to_upath(self.path).name,
             description=self.description,

agentpool/repomap.py

@@ -1109,7 +1109,7 @@ def get_file_map_from_content(  # noqa: PLR0915
 
     header = (
         f"# File: {filename} ({lines} lines)\n"
-        f"# Structure map (~{tokens_approx} tokens). Use read_file with line/limit for details.\n\n"
+        f"# Structure map (~{tokens_approx} tokens). Use read with line/limit for details.\n\n"
     )
 
     result = header + f"{filename}:\n" + tree_output

agentpool/resource_providers/__init__.py

@@ -1,6 +1,12 @@
 """Resource provider implementations."""
 
-from agentpool.resource_providers.base import ResourceProvider
+from agentpool.resource_providers.base import (
+    ProviderKind,
+    ResourceChangeEvent,
+    ResourceProvider,
+    ResourceType,
+)
+from agentpool.resource_providers.resource_info import ResourceInfo
 from agentpool.resource_providers.static import StaticResourceProvider
 from agentpool.resource_providers.filtering import FilteringResourceProvider
 from agentpool.resource_providers.aggregating import AggregatingResourceProvider
@@ -12,6 +18,10 @@ __all__ = [
     "FilteringResourceProvider",
     "MCPResourceProvider",
     "PlanProvider",
+    "ProviderKind",
+    "ResourceChangeEvent",
+    "ResourceInfo",
     "ResourceProvider",
+    "ResourceType",
     "StaticResourceProvider",
 ]

agentpool/resource_providers/aggregating.py

@@ -4,19 +4,29 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from agentpool.resource_providers import ResourceProvider
+from agentpool.resource_providers.base import ResourceChangeEvent, ResourceProvider
 
 
 if TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from pydantic_ai import ModelRequestPart
 
     from agentpool.prompts.prompts import BasePrompt
+    from agentpool.resource_providers.resource_info import ResourceInfo
     from agentpool.tools.base import Tool
-    from agentpool_config.resources import ResourceInfo
+
+_ = ResourceChangeEvent  # Used at runtime in method signatures
 
 
 class AggregatingResourceProvider(ResourceProvider):
-    """Provider that combines resources from multiple providers."""
+    """Provider that combines resources from multiple providers.
+
+    Automatically forwards change signals from child providers.
+    When a child emits tools_changed, this provider re-emits it.
+    """
+
+    kind = "aggregating"
 
     def __init__(self, providers: list[ResourceProvider], name: str = "aggregating") -> None:
         """Initialize provider with list of providers to aggregate.
@@ -26,10 +36,51 @@ class AggregatingResourceProvider(ResourceProvider):
             name: Name for this provider
         """
         super().__init__(name=name)
-        # Store reference to the providers list for dynamic updates
+        self._providers: list[ResourceProvider] = []
+        # Use property setter to set up signal forwarding
         self.providers = providers
 
-    async def get_tools(self) -> list[Tool]:
+    @property
+    def providers(self) -> list[ResourceProvider]:
+        """Get the list of child providers."""
+        return self._providers
+
+    @providers.setter
+    def providers(self, value: list[ResourceProvider]) -> None:
+        """Set the list of child providers and set up signal forwarding."""
+        # Disconnect from old providers
+        for provider in self._providers:
+            provider.tools_changed.disconnect(self._forward_tools_changed)
+            provider.prompts_changed.disconnect(self._forward_prompts_changed)
+            provider.resources_changed.disconnect(self._forward_resources_changed)
+            provider.skills_changed.disconnect(self._forward_skills_changed)
+
+        self._providers = value
+
+        # Connect to new providers
+        for provider in self._providers:
+            provider.tools_changed.connect(self._forward_tools_changed)
+            provider.prompts_changed.connect(self._forward_prompts_changed)
+            provider.resources_changed.connect(self._forward_resources_changed)
+            provider.skills_changed.connect(self._forward_skills_changed)
+
+    async def _forward_tools_changed(self, event: ResourceChangeEvent) -> None:
+        """Forward tools_changed signal from child provider."""
+        await self.tools_changed.emit(event)
+
+    async def _forward_prompts_changed(self, event: ResourceChangeEvent) -> None:
+        """Forward prompts_changed signal from child provider."""
+        await self.prompts_changed.emit(event)
+
+    async def _forward_resources_changed(self, event: ResourceChangeEvent) -> None:
+        """Forward resources_changed signal from child provider."""
+        await self.resources_changed.emit(event)
+
+    async def _forward_skills_changed(self, event: ResourceChangeEvent) -> None:
+        """Forward skills_changed signal from child provider."""
+        await self.skills_changed.emit(event)
+
+    async def get_tools(self) -> Sequence[Tool]:
         """Get tools from all providers."""
         return [t for provider in self.providers for t in await provider.get_tools()]