onetool-mcp 1.0.0rc2__py3-none-any.whl → 1.0.0rc3__py3-none-any.whl

ot/registry/__init__.py

@@ -1,189 +1,199 @@
-"""Tool registry package with auto-discovery for user-defined Python tools.
-
-The registry scans the `src/ot_tools/` directory, extracts function signatures and
-docstrings using AST parsing, and provides formatted context for LLM code generation.
-"""
-
-from __future__ import annotations
-
-import inspect
-from typing import TYPE_CHECKING, Any
-
-from docstring_parser import parse as parse_docstring
-
-from .models import ArgInfo, ToolInfo
-from .registry import ToolRegistry
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from pathlib import Path
-
-__all__ = [
-    "ArgInfo",
-    "ToolInfo",
-    "ToolRegistry",
-    "describe_tool",
-    "get_registry",
-    "list_tools",
-]
-
-# Global registry instance
-_registry: ToolRegistry | None = None
-
-
-def _build_tool_info_from_callable(
-    name: str,
-    func: Callable[..., Any],
-    pack: str | None = None,
-) -> ToolInfo:
-    """Build ToolInfo from a callable using inspect.
-
-    Args:
-        name: Full tool name (e.g., "ot.tools").
-        func: The function object.
-        pack: Pack name if applicable.
-
-    Returns:
-        ToolInfo with extracted signature and docstring info.
-    """
-    # Get signature
-    try:
-        sig = inspect.signature(func)
-        signature = f"{name}{sig}"
-    except (ValueError, TypeError):
-        signature = f"{name}(...)"
-
-    # Parse docstring
-    doc = func.__doc__ or ""
-    parsed = parse_docstring(doc)
-
-    # Build args list
-    args: list[ArgInfo] = []
-    for param_name, param in sig.parameters.items():
-        if param_name in ("self", "cls"):
-            continue
-
-        # Get type annotation
-        if param.annotation != inspect.Parameter.empty:
-            param_type = (
-                param.annotation.__name__
-                if hasattr(param.annotation, "__name__")
-                else str(param.annotation)
-            )
-        else:
-            param_type = "Any"
-
-        # Get default value
-        default = None
-        if param.default != inspect.Parameter.empty:
-            default = repr(param.default)
-
-        # Get description from parsed docstring
-        description = ""
-        for doc_param in parsed.params:
-            if doc_param.arg_name == param_name:
-                description = doc_param.description or ""
-                break
-
-        args.append(
-            ArgInfo(
-                name=param_name,
-                type=param_type,
-                default=default,
-                description=description,
-            )
-        )
-
-    # Get return description
-    returns = (parsed.returns.description or "") if parsed.returns else ""
-
-    return ToolInfo(
-        name=name,
-        pack=pack,
-        module=func.__module__,
-        signature=signature,
-        description=parsed.short_description or "",
-        args=args,
-        returns=returns,
-    )
-
-
-def _register_ot_pack(registry: ToolRegistry) -> None:
-    """Register the ot pack tools in the registry.
-
-    The ot pack provides introspection functions that need parameter
-    shorthand support like other tools.
-    """
-    from ot.meta import PACK_NAME, get_ot_pack_functions
-
-    ot_functions = get_ot_pack_functions()
-
-    for func_name, func in ot_functions.items():
-        full_name = f"{PACK_NAME}.{func_name}"
-        tool_info = _build_tool_info_from_callable(full_name, func, pack=PACK_NAME)
-        registry.register_tool(tool_info)
-
-
-def get_registry(tools_path: Path | None = None, rescan: bool = False) -> ToolRegistry:
-    """Get or create the global tool registry.
-
-    Uses config's tools_dir glob patterns if available, otherwise falls back
-    to the provided tools_path or default 'src/ot_tools/' directory.
-
-    Args:
-        tools_path: Path to tools directory (fallback if no config).
-        rescan: If True, rescan even if registry exists.
-
-    Returns:
-        ToolRegistry instance with discovered tools.
-    """
-    from ot.config.loader import get_config
-
-    global _registry
-
-    if _registry is None:
-        _registry = ToolRegistry(tools_path)
-        # Use config's tool files if available
-        config = get_config()
-        tool_files = config.get_tool_files()
-        if tool_files:
-            _registry.scan_files(tool_files)
-        else:
-            _registry.scan_directory()
-        # Register ot pack tools for param shorthand support
-        _register_ot_pack(_registry)
-    elif rescan:
-        # Rescan using config's tool files
-        config = get_config()
-        tool_files = config.get_tool_files()
-        if tool_files:
-            _registry.scan_files(tool_files)
-        else:
-            _registry.scan_directory()
-        # Re-register ot pack tools after rescan
-        _register_ot_pack(_registry)
-
-    return _registry
-
-
-def list_tools() -> str:
-    """List all registered tools.
-
-    Returns:
-        Summary of all registered tools.
-    """
-    registry = get_registry(rescan=True)
-    return registry.format_summary()
-
-
-def describe_tool(name: str) -> str:
-    """Describe a specific tool.
-
-    Args:
-        name: Tool function name.
-
-    Returns:
-        Detailed tool description.
-    """
-    registry = get_registry()
-    return registry.describe_tool(name)
+"""Tool registry package with auto-discovery for user-defined Python tools.
+
+The registry scans the `src/ot_tools/` directory, extracts function signatures and
+docstrings using AST parsing, and provides formatted context for LLM code generation.
+"""
+
+from __future__ import annotations
+
+import inspect
+from typing import TYPE_CHECKING, Any
+
+from docstring_parser import parse as parse_docstring
+
+from .models import ArgInfo, ToolInfo
+from .registry import ToolRegistry
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pathlib import Path
+
+__all__ = [
+    "ArgInfo",
+    "ToolInfo",
+    "ToolRegistry",
+    "describe_tool",
+    "get_registry",
+    "list_tools",
+]
+
+# Global registry instance
+_registry: ToolRegistry | None = None
+
+
+def _build_tool_info_from_callable(
+    name: str,
+    func: Callable[..., Any],
+    pack: str | None = None,
+) -> ToolInfo:
+    """Build ToolInfo from a callable using inspect.
+
+    Args:
+        name: Full tool name (e.g., "ot.tools").
+        func: The function object.
+        pack: Pack name if applicable.
+
+    Returns:
+        ToolInfo with extracted signature and docstring info.
+    """
+    # Get signature
+    try:
+        sig = inspect.signature(func)
+        signature = f"{name}{sig}"
+    except (ValueError, TypeError):
+        signature = f"{name}(...)"
+
+    # Parse docstring
+    doc = func.__doc__ or ""
+    parsed = parse_docstring(doc)
+
+    # Build args list
+    args: list[ArgInfo] = []
+    for param_name, param in sig.parameters.items():
+        if param_name in ("self", "cls"):
+            continue
+
+        # Get type annotation
+        if param.annotation != inspect.Parameter.empty:
+            param_type = (
+                param.annotation.__name__
+                if hasattr(param.annotation, "__name__")
+                else str(param.annotation)
+            )
+        else:
+            param_type = "Any"
+
+        # Get default value
+        default = None
+        if param.default != inspect.Parameter.empty:
+            default = repr(param.default)
+
+        # Get description from parsed docstring
+        description = ""
+        for doc_param in parsed.params:
+            if doc_param.arg_name == param_name:
+                description = doc_param.description or ""
+                break
+
+        args.append(
+            ArgInfo(
+                name=param_name,
+                type=param_type,
+                default=default,
+                description=description,
+            )
+        )
+
+    # Get return description
+    returns = (parsed.returns.description or "") if parsed.returns else ""
+
+    return ToolInfo(
+        name=name,
+        pack=pack,
+        module=func.__module__,
+        signature=signature,
+        description=parsed.short_description or "",
+        args=args,
+        returns=returns,
+    )
+
+
+def _register_ot_pack(registry: ToolRegistry) -> None:
+    """Register the ot pack tools in the registry.
+
+    The ot pack provides introspection functions that need parameter
+    shorthand support like other tools.
+    """
+    from ot.meta import PACK_NAME, get_ot_pack_functions
+
+    ot_functions = get_ot_pack_functions()
+
+    for func_name, func in ot_functions.items():
+        full_name = f"{PACK_NAME}.{func_name}"
+        tool_info = _build_tool_info_from_callable(full_name, func, pack=PACK_NAME)
+        registry.register_tool(tool_info)
+
+
+def get_registry(tools_path: Path | None = None, rescan: bool = False) -> ToolRegistry:
+    """Get or create the global tool registry.
+
+    Uses config's tools_dir glob patterns if available, otherwise falls back
+    to the provided tools_path or default 'src/ot_tools/' directory.
+
+    Args:
+        tools_path: Path to tools directory (fallback if no config).
+        rescan: If True, rescan even if registry exists.
+
+    Returns:
+        ToolRegistry instance with discovered tools.
+    """
+    from ot.config.loader import get_config
+
+    global _registry
+
+    if _registry is None:
+        _registry = ToolRegistry(tools_path)
+        # Use config's tool files if available
+        config = get_config()
+        tool_files = config.get_tool_files()
+        if tool_files:
+            _registry.scan_files(tool_files)
+        else:
+            _registry.scan_directory()
+        # Register ot pack tools for param shorthand support
+        _register_ot_pack(_registry)
+    elif rescan:
+        # Rescan using config's tool files
+        config = get_config()
+        tool_files = config.get_tool_files()
+        if tool_files:
+            _registry.scan_files(tool_files)
+        else:
+            _registry.scan_directory()
+        # Re-register ot pack tools after rescan
+        _register_ot_pack(_registry)
+
+    return _registry
+
+
+def reset() -> None:
+    """Clear registry cache for reload.
+
+    Use this as part of the config reload flow to force registry to be
+    rescanned on next access.
+    """
+    global _registry
+    _registry = None
+
+
+def list_tools() -> str:
+    """List all registered tools.
+
+    Returns:
+        Summary of all registered tools.
+    """
+    registry = get_registry(rescan=True)
+    return registry.format_summary()
+
+
+def describe_tool(name: str) -> str:
+    """Describe a specific tool.
+
+    Args:
+        name: Tool function name.
+
+    Returns:
+        Detailed tool description.
+    """
+    registry = get_registry()
+    return registry.describe_tool(name)

ot/config/dynamic.py

@@ -1,121 +0,0 @@
-"""Dynamic tool configuration building.
-
-This module provides dynamic configuration building for tools based on
-discovered Config classes in tool files. Instead of hardcoding tool configs
-in loader.py, each tool declares its own Config(BaseModel) class which is
-discovered and used for validation.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, cast
-
-from loguru import logger
-from pydantic import BaseModel, Field, create_model
-
-if TYPE_CHECKING:
-    from ot.executor.pep723 import ToolFileInfo
-
-
-def build_tools_config_model(
-    tool_files: list[ToolFileInfo],
-) -> type[BaseModel]:
-    """Generate a dynamic ToolsConfig model from discovered tool schemas.
-
-    Creates a Pydantic model where each pack with a Config class gets
-    a corresponding field. Packs without Config classes are not included.
-
-    Args:
-        tool_files: List of analyzed tool files with config_class_source
-
-    Returns:
-        A dynamically generated Pydantic model class
-
-    Example:
-        If brave_search.py has:
-            class Config(BaseModel):
-                timeout: float = Field(default=60.0, ge=1.0, le=300.0)
-
-        Then build_tools_config_model returns a model with:
-            class DynamicToolsConfig(BaseModel):
-                brave: BraveConfig = Field(default_factory=BraveConfig)
-    """
-    fields: dict[str, Any] = {}
-    config_classes: dict[str, type[BaseModel]] = {}
-
-    for tool_file in tool_files:
-        if not tool_file.pack or not tool_file.config_class_source:
-            continue
-
-        pack_name = tool_file.pack
-
-        # Skip if we already processed this pack
-        if pack_name in config_classes:
-            continue
-
-        try:
-            # Execute the config class source to get the actual class
-            config_class = _compile_config_class(
-                pack_name, tool_file.config_class_source
-            )
-            if config_class:
-                config_classes[pack_name] = config_class
-                fields[pack_name] = (
-                    config_class,
-                    Field(default_factory=config_class),
-                )
-                logger.debug(f"Registered config for pack '{pack_name}'")
-        except Exception as e:
-            logger.warning(f"Failed to compile config for pack '{pack_name}': {e}")
-
-    return create_model("DynamicToolsConfig", **fields)
-
-
-def _compile_config_class(
-    _pack_name: str, config_source: str
-) -> type[BaseModel] | None:
-    """Compile a Config class source into an actual class.
-
-    Args:
-        pack_name: Pack name for context
-        config_source: Source code of the Config class
-
-    Returns:
-        The compiled Config class, or None if compilation fails
-    """
-    # Create a namespace with required imports
-    namespace: dict[str, Any] = {
-        "BaseModel": BaseModel,
-        "Field": Field,
-    }
-
-    try:
-        exec(config_source, namespace)
-        config_class = namespace.get("Config")
-        if config_class and isinstance(config_class, type) and issubclass(
-            config_class, BaseModel
-        ):
-            return cast("type[BaseModel]", config_class)
-    except Exception:
-        pass
-
-    return None
-
-
-def get_pack_config_raw(pack: str) -> dict[str, Any]:
-    """Get raw config dict for a pack from loaded configuration.
-
-    Args:
-        pack: Pack name (e.g., "brave", "ground")
-
-    Returns:
-        Raw config dict for the pack, or empty dict if not configured
-    """
-    from ot.config.loader import get_config
-
-    config = get_config()
-
-    # Try to get from tools section as raw dict
-    tools_dict = config.model_dump().get("tools", {})
-    result: dict[str, Any] = tools_dict.get(pack, {})
-    return result

ot/config/mcp.py

@@ -1,149 +0,0 @@
-"""MCP server configuration for OneTool proxy.
-
-Defines configuration for connecting to external MCP servers that are
-proxied through OneTool's single `run` tool.
-"""
-
-from __future__ import annotations
-
-import re
-from typing import Literal
-
-from pydantic import BaseModel, Field, field_validator
-
-# Use canonical early secrets loader from secrets.py (eliminates duplication)
-from ot.config.secrets import get_early_secret
-
-
-def expand_secrets(value: str) -> str:
-    """Expand ${VAR} patterns using secrets.yaml ONLY.
-
-    Use this for configuration values that MUST be in secrets.yaml.
-    This enforces that sensitive values are stored in the gitignored secrets file,
-    not in environment variables that might leak into logs or process lists.
-
-    Supports ${VAR_NAME} and ${VAR_NAME:-default} syntax.
-
-    When to use:
-        - Config file values (URLs, API keys, database connections)
-        - Anywhere secrets should be explicit and fail loudly if missing
-
-    When NOT to use:
-        - Subprocess environment pass-through (use expand_subprocess_env instead)
-
-    Args:
-        value: String potentially containing ${VAR} patterns.
-
-    Returns:
-        String with variables expanded from secrets.
-
-    Raises:
-        ValueError: If variable not found in secrets and no default provided.
-    """
-    pattern = re.compile(r"\$\{([^}:]+)(?::-([^}]*))?\}")
-    missing_vars: list[str] = []
-
-    def replace(match: re.Match[str]) -> str:
-        var_name = match.group(1)
-        default_value = match.group(2)
-        # Read from secrets only - no os.environ
-        secret_value = get_early_secret(var_name)
-        if secret_value is not None:
-            return secret_value
-        if default_value is not None:
-            return default_value
-        missing_vars.append(var_name)
-        return match.group(0)
-
-    result = pattern.sub(replace, value)
-
-    if missing_vars:
-        raise ValueError(
-            f"Missing variables in secrets.yaml: {', '.join(missing_vars)}. "
-            f"Add them to .onetool/config/secrets.yaml or use ${{VAR:-default}} syntax."
-        )
-
-    return result
-
-
-def expand_subprocess_env(value: str) -> str:
-    """Expand ${VAR} for subprocess environment variables.
-
-    Use this ONLY for subprocess env configuration where pass-through is needed.
-    Searches: secrets.yaml first, then os.environ. Returns empty string if not found.
-
-    This is the ONLY place where reading os.environ is allowed. This enables
-    explicit pass-through of system environment variables like ${HOME}, ${PATH},
-    or ${USER} to subprocesses without requiring them to be in secrets.yaml.
-
-    When to use:
-        - MCP server 'env' configuration (subprocess environment)
-        - Any subprocess that needs access to system env vars
-
-    When NOT to use:
-        - Config file values (use expand_secrets instead - it enforces secrets.yaml)
-        - Anything that should fail if the secret is missing
-
-    Args:
-        value: String potentially containing ${VAR} patterns.
-
-    Returns:
-        String with variables expanded. Empty string if not found (silent failure).
-    """
-    import os
-
-    pattern = re.compile(r"\$\{([^}:]+)(?::-([^}]*))?\}")
-
-    def replace(match: re.Match[str]) -> str:
-        var_name = match.group(1)
-        default_value = match.group(2)
-        # Secrets first
-        secret_value = get_early_secret(var_name)
-        if secret_value is not None:
-            return secret_value
-        # Then os.environ (for pass-through like ${HOME})
-        env_val = os.environ.get(var_name)
-        if env_val is not None:
-            return env_val
-        # Use default if provided
-        if default_value is not None:
-            return default_value
-        # Empty string if not found
-        return ""
-
-    return pattern.sub(replace, value)
-
-
-class McpServerConfig(BaseModel):
-    """Configuration for an MCP server connection.
-
-    Compatible with bench ServerConfig format, with additional
-    `enabled` field for toggling servers without removing config.
-    """
-
-    type: Literal["http", "stdio"] = Field(description="Server connection type")
-    enabled: bool = Field(default=True, description="Whether this server is enabled")
-    url: str | None = Field(default=None, description="URL for HTTP servers")
-    headers: dict[str, str] = Field(
-        default_factory=dict, description="Headers for HTTP servers"
-    )
-    command: str | None = Field(default=None, description="Command for stdio servers")
-    args: list[str] = Field(
-        default_factory=list, description="Arguments for stdio command"
-    )
-    env: dict[str, str] = Field(
-        default_factory=dict, description="Environment variables for stdio servers"
-    )
-    timeout: int = Field(default=30, description="Connection timeout in seconds")
-    instructions: str | None = Field(
-        default=None,
-        description="Agent instructions for using this server's tools (surfaced in MCP instructions)",
-    )
-
-    @field_validator("url", "command", mode="before")
-    @classmethod
-    def expand_secrets_validator(cls, v: str | None) -> str | None:
-        """Expand ${VAR} from secrets.yaml in URL and command."""
-        if v is None:
-            return None
-        return expand_secrets(v)