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

agentpool/models/acp_agents/non_mcp.py

@@ -13,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.
 

agentpool/models/agents.py

@@ -4,11 +4,11 @@ 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
@@ -20,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 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
@@ -27,8 +28,7 @@ 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
 
 
@@ -42,6 +42,12 @@ ToolMode = Literal["codemode"]
 
 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.
@@ -62,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={
@@ -79,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"],
@@ -88,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.
 
-    Docs: https://phil65.github.io/agentpool/YAML%20Configuration/toolset_configuration/
+    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/tool_configuration/
     """
 
     session: str | SessionQuery | MemoryConfig | None = Field(
@@ -297,48 +284,61 @@ 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 (excludes builtin tools)."""
+        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
 
-        if not static_tools:
-            return None
-        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.

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):

agentpool/models/claude_code_agents.py

@@ -6,18 +6,26 @@ 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",
@@ -37,6 +45,7 @@ ToolName = Literal[
     "Skill",
     "EnterPlanMode",
     "LSP",
+    "Chrome",
 ]
 
 
@@ -87,7 +96,7 @@ 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"],
@@ -219,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"],
@@ -240,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,14 +5,15 @@ 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
@@ -220,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."""
 
@@ -421,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,
@@ -469,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.
@@ -693,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/resource_providers/__init__.py

@@ -6,6 +6,7 @@ from agentpool.resource_providers.base import (
     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
@@ -19,6 +20,7 @@ __all__ = [
     "PlanProvider",
     "ProviderKind",
     "ResourceChangeEvent",
+    "ResourceInfo",
     "ResourceProvider",
     "ResourceType",
     "StaticResourceProvider",