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

ot/config/secrets.py

@@ -1,190 +1,192 @@
-"""Secrets loading for OneTool.
-
-Loads secrets from secrets.yaml (gitignored) separate from committed configuration.
-Secrets are passed to workers via JSON-RPC, not exposed as environment variables.
-
-The secrets file path is resolved in order:
-1. Explicit path passed to get_secrets()
-2. Config's secrets_file setting (if config loaded and file exists)
-3. Default locations: project (.onetool/config/secrets.yaml) then global (~/.onetool/config/secrets.yaml)
-4. OT_SECRETS_FILE environment variable
-
-Example secrets.yaml:
-
-    BRAVE_API_KEY: "your-brave-api-key"
-    OPENAI_API_KEY: "sk-..."
-    DATABASE_URL: "postgresql://..."
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-import yaml
-from loguru import logger
-
-# Single global secrets cache
-_secrets: dict[str, str] | None = None
-
-
-def load_secrets(secrets_path: Path | str | None = None) -> dict[str, str]:
-    """Load secrets from YAML file.
-
-    Args:
-        secrets_path: Path to secrets file. If None or doesn't exist,
-            returns empty dict (no secrets).
-
-    Returns:
-        Dictionary of secret name -> value
-
-    Raises:
-        ValueError: If YAML is invalid
-    """
-    if secrets_path is None:
-        logger.debug("No secrets path provided")
-        return {}
-
-    secrets_path = Path(secrets_path)
-
-    if not secrets_path.exists():
-        logger.debug(f"Secrets file not found: {secrets_path}")
-        return {}
-
-    logger.debug(f"Loading secrets from {secrets_path}")
-
-    try:
-        with secrets_path.open() as f:
-            raw_data = yaml.safe_load(f)
-    except yaml.YAMLError as e:
-        raise ValueError(f"Invalid YAML in secrets file {secrets_path}: {e}") from e
-    except OSError as e:
-        raise ValueError(f"Error reading secrets file {secrets_path}: {e}") from e
-
-    if raw_data is None:
-        return {}
-
-    if not isinstance(raw_data, dict):
-        raise ValueError(
-            f"Secrets file {secrets_path} must be a YAML mapping, not {type(raw_data).__name__}"
-        )
-
-    # Values are literal - no env var expansion
-    secrets: dict[str, str] = {}
-    for key, value in raw_data.items():
-        if not isinstance(key, str):
-            logger.warning(f"Ignoring non-string secret key: {key}")
-            continue
-
-        if value is None:
-            continue
-
-        # Store as literal string - no ${VAR} expansion
-        secrets[key] = str(value)
-
-    logger.info(f"Loaded {len(secrets)} secrets")
-    return secrets
-
-
-def _load_from_default_locations() -> dict[str, str]:
-    """Load secrets from default project and global locations.
-
-    Searches in order (first found wins):
-    1. Project: {effective_cwd}/.onetool/config/secrets.yaml
-    2. Global: ~/.onetool/config/secrets.yaml
-
-    Returns:
-        Dictionary of secret name -> value (empty if no secrets found)
-    """
-    # Import here to avoid circular imports at module level
-    from ot.paths import CONFIG_SUBDIR, get_effective_cwd, get_global_dir
-
-    # Try project secrets first, then global
-    paths_to_try = [
-        get_effective_cwd() / ".onetool" / CONFIG_SUBDIR / "secrets.yaml",
-        get_global_dir() / CONFIG_SUBDIR / "secrets.yaml",
-    ]
-
-    for secrets_path in paths_to_try:
-        if secrets_path.exists():
-            try:
-                return load_secrets(secrets_path)
-            except ValueError as e:
-                # Silent during bootstrap - don't spam logs
-                logger.debug(f"Error loading secrets from {secrets_path}: {e}")
-                continue
-
-    return {}
-
-
-def get_secrets(
-    secrets_path: Path | str | None = None, reload: bool = False
-) -> dict[str, str]:
-    """Get or load the cached secrets.
-
-    Resolution order (first match wins):
-    1. Explicit secrets_path argument
-    2. Config's secrets_file setting (if config loaded and file exists)
-    3. Default locations (.onetool/config/secrets.yaml)
-    4. OT_SECRETS_FILE environment variable
-
-    Args:
-        secrets_path: Path to secrets file (only used on first load or reload).
-        reload: Force reload secrets from disk.
-
-    Returns:
-        Dictionary of secret name -> value
-    """
-    global _secrets
-
-    if _secrets is None or reload:
-        # Resolution chain: explicit > config (if loaded) > defaults > env var
-        if secrets_path is None:
-            # WARNING: Do NOT call get_config() here!
-            # =========================================
-            # This function is called during config loading via:
-            #   get_config() → load_config() → expand_secrets() → get_early_secret() → get_secrets()
-            #
-            # If we call get_config() here, it triggers config loading again → infinite recursion.
-            # Instead, we check _config directly - if it's None, config is still loading.
-            try:
-                import ot.config.loader
-
-                if ot.config.loader._config is not None:
-                    config_path = ot.config.loader._config.get_secrets_file_path()
-                    if config_path.exists():
-                        secrets_path = config_path
-            except Exception:
-                pass  # Module not loaded yet, fall through
-
-        # Try default locations if still no path
-        if secrets_path is None:
-            loaded = _load_from_default_locations()
-            if loaded:
-                _secrets = loaded
-                return _secrets
-
-        # Final fallback to OT_SECRETS_FILE env var
-        if secrets_path is None:
-            secrets_path = os.getenv("OT_SECRETS_FILE")
-
-        _secrets = load_secrets(secrets_path)
-
-    return _secrets
-
-
-def get_secret(name: str) -> str | None:
-    """Get a single secret value by name.
-
-    Args:
-        name: Secret name (e.g., "BRAVE_API_KEY")
-
-    Returns:
-        Secret value, or None if not found
-    """
-    return get_secrets().get(name)
-
-
-# Alias for backward compatibility and semantic clarity during config loading
-# Both functions now use the same unified cache
-get_early_secret = get_secret
+"""Secrets loading for OneTool.
+
+Loads secrets from secrets.yaml (gitignored) separate from committed configuration.
+Secrets are passed to workers via JSON-RPC, not exposed as environment variables.
+
+The secrets file path is resolved in order:
+1. Explicit path passed to get_secrets()
+2. OT_SECRETS_FILE environment variable
+3. Config's secrets_file setting (if config loaded and file exists)
+4. Default locations: project (.onetool/config/secrets.yaml) then global (~/.onetool/config/secrets.yaml)
+
+Example secrets.yaml:
+
+    BRAVE_API_KEY: "your-brave-api-key"
+    OPENAI_API_KEY: "sk-..."
+    DATABASE_URL: "postgresql://..."
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import yaml
+from loguru import logger
+
+# Single global secrets cache
+_secrets: dict[str, str] | None = None
+
+
+def load_secrets(secrets_path: Path | str | None = None) -> dict[str, str]:
+    """Load secrets from YAML file.
+
+    Args:
+        secrets_path: Path to secrets file. If None or doesn't exist,
+            returns empty dict (no secrets).
+
+    Returns:
+        Dictionary of secret name -> value
+
+    Raises:
+        ValueError: If YAML is invalid
+    """
+    if secrets_path is None:
+        logger.debug("No secrets path provided")
+        return {}
+
+    secrets_path = Path(secrets_path)
+
+    if not secrets_path.exists():
+        logger.debug(f"Secrets file not found: {secrets_path}")
+        return {}
+
+    logger.debug(f"Loading secrets from {secrets_path}")
+
+    try:
+        with secrets_path.open() as f:
+            raw_data = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        raise ValueError(f"Invalid YAML in secrets file {secrets_path}: {e}") from e
+    except OSError as e:
+        raise ValueError(f"Error reading secrets file {secrets_path}: {e}") from e
+
+    if raw_data is None:
+        return {}
+
+    if not isinstance(raw_data, dict):
+        raise ValueError(
+            f"Secrets file {secrets_path} must be a YAML mapping, not {type(raw_data).__name__}"
+        )
+
+    # Values are literal - no env var expansion
+    secrets: dict[str, str] = {}
+    for key, value in raw_data.items():
+        if not isinstance(key, str):
+            logger.warning(f"Ignoring non-string secret key: {key}")
+            continue
+
+        if value is None:
+            continue
+
+        # Store as literal string - no ${VAR} expansion
+        secrets[key] = str(value)
+
+    logger.info(f"Loaded {len(secrets)} secrets")
+    return secrets
+
+
+def _load_from_default_locations() -> dict[str, str]:
+    """Load secrets from default project and global locations.
+
+    Searches in order (first found wins):
+    1. Project: {effective_cwd}/.onetool/config/secrets.yaml
+    2. Global: ~/.onetool/config/secrets.yaml
+
+    Returns:
+        Dictionary of secret name -> value (empty if no secrets found)
+    """
+    # Import here to avoid circular imports at module level
+    from ot.paths import CONFIG_SUBDIR, get_effective_cwd, get_global_dir
+
+    # Try project secrets first, then global
+    paths_to_try = [
+        get_effective_cwd() / ".onetool" / CONFIG_SUBDIR / "secrets.yaml",
+        get_global_dir() / CONFIG_SUBDIR / "secrets.yaml",
+    ]
+
+    for secrets_path in paths_to_try:
+        if secrets_path.exists():
+            try:
+                return load_secrets(secrets_path)
+            except ValueError as e:
+                # Silent during bootstrap - don't spam logs
+                logger.debug(f"Error loading secrets from {secrets_path}: {e}")
+                continue
+
+    return {}
+
+
+def get_secrets(
+    secrets_path: Path | str | None = None, reload: bool = False
+) -> dict[str, str]:
+    """Get or load the cached secrets.
+
+    Resolution order (first match wins):
+    1. Explicit secrets_path argument
+    2. OT_SECRETS_FILE environment variable
+    3. Config's secrets_file setting (if config loaded and file exists)
+    4. Default locations (.onetool/config/secrets.yaml)
+
+    Args:
+        secrets_path: Path to secrets file (only used on first load or reload).
+        reload: Force reload secrets from disk.
+
+    Returns:
+        Dictionary of secret name -> value
+    """
+    global _secrets
+
+    if _secrets is None or reload:
+        # Resolution chain: explicit > env var > config (if loaded) > defaults
+        if secrets_path is None:
+            # Check OT_SECRETS_FILE env var first (highest priority after explicit path)
+            env_path = os.getenv("OT_SECRETS_FILE")
+            if env_path:
+                secrets_path = env_path
+
+        if secrets_path is None:
+            # WARNING: Do NOT call get_config() here!
+            # =========================================
+            # This function is called during config loading via:
+            #   get_config() → load_config() → expand_secrets() → get_early_secret() → get_secrets()
+            #
+            # If we call get_config() here, it triggers config loading again → infinite recursion.
+            # Instead, we check _config directly - if it's None, config is still loading.
+            try:
+                import ot.config.loader
+
+                if ot.config.loader._config is not None:
+                    config_path = ot.config.loader._config.get_secrets_file_path()
+                    if config_path.exists():
+                        secrets_path = config_path
+            except Exception:
+                pass  # Module not loaded yet, fall through
+
+        # Try default locations if still no path
+        if secrets_path is None:
+            loaded = _load_from_default_locations()
+            if loaded:
+                _secrets = loaded
+                return _secrets
+
+        _secrets = load_secrets(secrets_path)
+
+    return _secrets
+
+
+def get_secret(name: str) -> str | None:
+    """Get a single secret value by name.
+
+    Args:
+        name: Secret name (e.g., "BRAVE_API_KEY")
+
+    Returns:
+        Secret value, or None if not found
+    """
+    return get_secrets().get(name)
+
+
+# Alias for backward compatibility and semantic clarity during config loading
+# Both functions now use the same unified cache
+get_early_secret = get_secret

ot/decorators.py

@@ -1,116 +1,116 @@
-"""Tool decorators for enhanced metadata.
-
-The @tool decorator attaches metadata to tool functions for better
-LLM comprehension. Plain functions work without decorators.
-
-Example:
-    @tool(
-        description="Search the web using Brave Search",
-        examples=["search(query='Python news')"],
-        tags=["search", "web"],
-    )
-    def brave_search(query: str, count: int = 10) -> str:
-        '''Search the web.'''
-        ...
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass, field
-from typing import Any, TypeVar
-
-F = TypeVar("F", bound=Callable[..., Any])
-
-
-@dataclass
-class ToolMetadata:
-    """Metadata attached to tool functions by the @tool decorator."""
-
-    description: str | None = None
-    examples: list[str] = field(default_factory=list)
-    tags: list[str] = field(default_factory=list)
-    enabled: bool = True
-    deprecated: bool = False
-    deprecated_message: str | None = None
-
-
-# Attribute name used to store metadata on decorated functions
-TOOL_METADATA_ATTR = "_tool_metadata"
-
-
-def tool(
-    description: str | None = None,
-    examples: list[str] | None = None,
-    tags: list[str] | None = None,
-    enabled: bool = True,
-    deprecated: bool = False,
-    deprecated_message: str | None = None,
-) -> Callable[[F], F]:
-    """Decorator to add metadata to a tool function.
-
-    Attaches a ToolMetadata instance to the function for the registry
-    to extract and use for enhanced descriptions.
-
-    Args:
-        description: Override the docstring description
-        examples: List of usage examples
-        tags: Categorization tags
-        enabled: Whether the tool is enabled (default True)
-        deprecated: Mark as deprecated
-        deprecated_message: Message shown when deprecated
-
-    Returns:
-        Decorator function
-
-    Example:
-        @tool(
-            description="Search the web using Brave Search API",
-            examples=[
-                'brave_search(query="Python news", count=5)',
-                'brave_search(query="weather today")',
-            ],
-            tags=["search", "web"],
-        )
-        def brave_search(query: str, count: int = 10) -> str:
-            '''Search the web.'''
-            ...
-    """
-
-    def decorator(func: F) -> F:
-        metadata = ToolMetadata(
-            description=description,
-            examples=examples or [],
-            tags=tags or [],
-            enabled=enabled,
-            deprecated=deprecated,
-            deprecated_message=deprecated_message,
-        )
-        setattr(func, TOOL_METADATA_ATTR, metadata)
-        return func
-
-    return decorator
-
-
-def get_tool_metadata(func: Callable[..., Any]) -> ToolMetadata | None:
-    """Extract ToolMetadata from a function if present.
-
-    Args:
-        func: Function to check for metadata
-
-    Returns:
-        ToolMetadata if decorated with @tool, None otherwise
-    """
-    return getattr(func, TOOL_METADATA_ATTR, None)
-
-
-def has_tool_metadata(func: Callable[..., Any]) -> bool:
-    """Check if a function has @tool decorator metadata.
-
-    Args:
-        func: Function to check
-
-    Returns:
-        True if function has ToolMetadata
-    """
-    return hasattr(func, TOOL_METADATA_ATTR)
+"""Tool decorators for enhanced metadata.
+
+The @tool decorator attaches metadata to tool functions for better
+LLM comprehension. Plain functions work without decorators.
+
+Example:
+    @tool(
+        description="Search the web using Brave Search",
+        examples=["search(query='Python news')"],
+        tags=["search", "web"],
+    )
+    def brave_search(query: str, count: int = 10) -> str:
+        '''Search the web.'''
+        ...
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any, TypeVar
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+@dataclass
+class ToolMetadata:
+    """Metadata attached to tool functions by the @tool decorator."""
+
+    description: str | None = None
+    examples: list[str] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+    enabled: bool = True
+    deprecated: bool = False
+    deprecated_message: str | None = None
+
+
+# Attribute name used to store metadata on decorated functions
+TOOL_METADATA_ATTR = "_tool_metadata"
+
+
+def tool(
+    description: str | None = None,
+    examples: list[str] | None = None,
+    tags: list[str] | None = None,
+    enabled: bool = True,
+    deprecated: bool = False,
+    deprecated_message: str | None = None,
+) -> Callable[[F], F]:
+    """Decorator to add metadata to a tool function.
+
+    Attaches a ToolMetadata instance to the function for the registry
+    to extract and use for enhanced descriptions.
+
+    Args:
+        description: Override the docstring description
+        examples: List of usage examples
+        tags: Categorization tags
+        enabled: Whether the tool is enabled (default True)
+        deprecated: Mark as deprecated
+        deprecated_message: Message shown when deprecated
+
+    Returns:
+        Decorator function
+
+    Example:
+        @tool(
+            description="Search the web using Brave Search API",
+            examples=[
+                'brave_search(query="Python news", count=5)',
+                'brave_search(query="weather today")',
+            ],
+            tags=["search", "web"],
+        )
+        def brave_search(query: str, count: int = 10) -> str:
+            '''Search the web.'''
+            ...
+    """
+
+    def decorator(func: F) -> F:
+        metadata = ToolMetadata(
+            description=description,
+            examples=examples or [],
+            tags=tags or [],
+            enabled=enabled,
+            deprecated=deprecated,
+            deprecated_message=deprecated_message,
+        )
+        setattr(func, TOOL_METADATA_ATTR, metadata)
+        return func
+
+    return decorator
+
+
+def get_tool_metadata(func: Callable[..., Any]) -> ToolMetadata | None:
+    """Extract ToolMetadata from a function if present.
+
+    Args:
+        func: Function to check for metadata
+
+    Returns:
+        ToolMetadata if decorated with @tool, None otherwise
+    """
+    return getattr(func, TOOL_METADATA_ATTR, None)
+
+
+def has_tool_metadata(func: Callable[..., Any]) -> bool:
+    """Check if a function has @tool decorator metadata.
+
+    Args:
+        func: Function to check
+
+    Returns:
+        True if function has ToolMetadata
+    """
+    return hasattr(func, TOOL_METADATA_ATTR)