agentpool 2.1.9__py3-none-any.whl → 2.2.3__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
 
@@ -67,6 +66,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 +90,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 +105,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 +144,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 +173,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 +200,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 +229,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 +274,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 +370,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 +510,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 +611,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 +651,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 +710,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 +732,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 +767,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 +895,5 @@ RegularACPAgentConfigTypes = (
     | MistralACPAgentConfig
     | VTCodeACPAgentConfig
     | CursorACPAgentConfig
+    | GeminiACPAgentConfig
 )

agentpool/models/agents.py

@@ -12,6 +12,7 @@ from llmling_models.configs 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,6 +20,7 @@ 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.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
@@ -37,7 +39,6 @@ if TYPE_CHECKING:
 
 
 ToolMode = Literal["codemode"]
-AutoCache = Literal["off", "5m", "1h"]
 
 logger = log.get_logger(__name__)
 
@@ -230,6 +231,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 +253,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",
@@ -312,7 +314,7 @@ class NativeAgentConfig(BaseAgentConfig):
         return providers
 
     def get_tool_provider(self) -> ResourceProvider | None:
-        """Get tool provider for this agent."""
+        """Get tool provider for this agent (excludes builtin tools)."""
         from agentpool.tools.base import Tool
 
         # Create provider for static tools
@@ -320,6 +322,9 @@ class NativeAgentConfig(BaseAgentConfig):
             return None
         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():
@@ -331,8 +336,25 @@ class NativeAgentConfig(BaseAgentConfig):
                 logger.exception("Failed to load tool", config=tool_config)
                 continue
 
+        if not static_tools:
+            return None
         return StaticResourceProvider(name="builtin", tools=static_tools)
 
+    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."""
         match self.session:

agentpool/models/claude_code_agents.py

@@ -18,6 +18,26 @@ if TYPE_CHECKING:
 
 
 PermissionMode = Literal["default", "acceptEdits", "plan", "bypassPermissions"]
+ToolName = Literal[
+    "Task",
+    "TaskOutput",
+    "Bash",
+    "Glob",
+    "Grep",
+    "ExitPlanMode",
+    "Read",
+    "Edit",
+    "Write",
+    "NotebookEdit",
+    "WebFetch",
+    "TodoWrite",
+    "WebSearch",
+    "KillShell",
+    "AskUserQuestion",
+    "Skill",
+    "EnterPlanMode",
+    "LSP",
+]
 
 
 class ClaudeCodeAgentConfig(BaseAgentConfig):
@@ -74,7 +94,7 @@ class ClaudeCodeAgentConfig(BaseAgentConfig):
     )
     """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 +105,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 +152,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",

agentpool/models/manifest.py

@@ -17,6 +17,7 @@ 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 +39,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 +79,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=[
@@ -272,6 +280,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",
@@ -583,6 +615,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 +665,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),
                 }

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,11 @@
 """Resource provider implementations."""
 
-from agentpool.resource_providers.base import ResourceProvider
+from agentpool.resource_providers.base import (
+    ProviderKind,
+    ResourceChangeEvent,
+    ResourceProvider,
+    ResourceType,
+)
 from agentpool.resource_providers.static import StaticResourceProvider
 from agentpool.resource_providers.filtering import FilteringResourceProvider
 from agentpool.resource_providers.aggregating import AggregatingResourceProvider
@@ -12,6 +17,9 @@ __all__ = [
     "FilteringResourceProvider",
     "MCPResourceProvider",
     "PlanProvider",
+    "ProviderKind",
+    "ResourceChangeEvent",
     "ResourceProvider",
+    "ResourceType",
     "StaticResourceProvider",
 ]

agentpool/resource_providers/aggregating.py

@@ -4,7 +4,7 @@ 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:
@@ -14,9 +14,17 @@ if TYPE_CHECKING:
     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,9 +34,50 @@ 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
 
+    @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) -> list[Tool]:
         """Get tools from all providers."""
         return [t for provider in self.providers for t in await provider.get_tools()]