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

ot/prompts.py

@@ -1,218 +1,228 @@
-"""Prompts loader for externalized MCP server instructions.
-
-Loads prompts from prompts.yaml. File must exist and contain instructions.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Any
-
-import yaml
-from loguru import logger
-from pydantic import BaseModel, Field
-
-
-class ToolPrompt(BaseModel):
-    """Prompt configuration for a specific tool."""
-
-    description: str | None = Field(
-        default=None, description="Override tool description"
-    )
-    examples: list[str] = Field(default_factory=list, description="Usage examples")
-
-
-class PromptsConfig(BaseModel):
-    """Configuration for MCP server prompts and tool descriptions."""
-
-    instructions: str = Field(
-        description="Main server instructions shown to the LLM",
-    )
-    tools: dict[str, ToolPrompt] = Field(
-        default_factory=dict,
-        description="Per-tool prompt overrides",
-    )
-    templates: dict[str, str] = Field(
-        default_factory=dict,
-        description="Reusable prompt templates with {variable} placeholders",
-    )
-    packs: dict[str, str] = Field(
-        default_factory=dict,
-        description="Per-pack instructions (e.g., excel, github)",
-    )
-
-
-class PromptsError(Exception):
-    """Error loading prompts configuration."""
-
-
-def _get_template_prompts_path() -> Path:
-    """Get path to prompts.yaml in global_templates (for development/testing)."""
-    return Path(__file__).parent / "config" / "global_templates" / "prompts.yaml"
-
-
-def load_prompts(prompts_path: Path | str | None = None) -> PromptsConfig:
-    """Load prompts configuration from YAML file.
-
-    Args:
-        prompts_path: Path to prompts file. Falls back to global_templates for development.
-
-    Returns:
-        PromptsConfig with loaded prompts.
-
-    Raises:
-        PromptsError: If file is invalid or has no instructions.
-    """
-    if prompts_path is not None:
-        prompts_path = Path(prompts_path)
-        if not prompts_path.exists():
-            raise PromptsError(f"Prompts file not found: {prompts_path}")
-    else:
-        # Try config/prompts.yaml, fall back to global_templates for development
-        prompts_path = Path("config/prompts.yaml")
-        if not prompts_path.exists():
-            prompts_path = _get_template_prompts_path()
-
-    logger.debug(f"Loading prompts from {prompts_path}")
-
-    try:
-        with prompts_path.open() as f:
-            raw_data = yaml.safe_load(f)
-    except yaml.YAMLError as e:
-        raise PromptsError(f"Invalid YAML in {prompts_path}: {e}") from e
-    except OSError as e:
-        raise PromptsError(f"Error reading {prompts_path}: {e}") from e
-
-    if raw_data is None or not isinstance(raw_data, dict):
-        raise PromptsError(f"Empty or invalid prompts file: {prompts_path}")
-
-    # Handle nested 'prompts:' key (used in template files)
-    if "prompts" in raw_data and isinstance(raw_data["prompts"], dict):
-        raw_data = raw_data["prompts"]
-
-    if "instructions" not in raw_data or not raw_data["instructions"]:
-        raise PromptsError(f"Missing 'instructions' in {prompts_path}")
-
-    try:
-        return PromptsConfig.model_validate(raw_data)
-    except Exception as e:
-        raise PromptsError(f"Invalid prompts configuration: {e}") from e
-
-
-def render_template(
-    config: PromptsConfig, template_name: str, **kwargs: Any
-) -> str | None:
-    """Render a prompt template with variable substitution.
-
-    Args:
-        config: PromptsConfig with templates
-        template_name: Name of the template to render
-        **kwargs: Variables to substitute in the template
-
-    Returns:
-        Rendered template string, or None if template not found.
-    """
-    template = config.templates.get(template_name)
-    if template is None:
-        return None
-
-    try:
-        return template.format(**kwargs)
-    except KeyError as e:
-        logger.warning(f"Missing template variable: {e}")
-        return None
-
-
-def get_tool_description(
-    config: PromptsConfig, tool_name: str, default: str = ""
-) -> str:
-    """Get tool description from prompts config with fallback to docstring.
-
-    Args:
-        config: PromptsConfig with tool prompts
-        tool_name: Name of the tool
-        default: Default description if not in config (typically from docstring)
-
-    Returns:
-        Tool description string.
-    """
-    tool_prompt = config.tools.get(tool_name)
-    if tool_prompt and tool_prompt.description:
-        return tool_prompt.description
-    return default
-
-
-def get_tool_examples(config: PromptsConfig, tool_name: str) -> list[str]:
-    """Get usage examples for a tool.
-
-    Args:
-        config: PromptsConfig with tool prompts
-        tool_name: Name of the tool
-
-    Returns:
-        List of example strings.
-    """
-    tool_prompt = config.tools.get(tool_name)
-    if tool_prompt:
-        return tool_prompt.examples
-    return []
-
-
-def get_pack_instructions(config: PromptsConfig, pack: str) -> str | None:
-    """Get instructions for a pack from prompts config.
-
-    Args:
-        config: PromptsConfig with pack instructions
-        pack: Name of the pack (e.g., "excel", "github")
-
-    Returns:
-        Pack instructions string, or None if not configured.
-    """
-    return config.packs.get(pack)
-
-
-# Global prompts instance
-_prompts: PromptsConfig | None = None
-
-
-def get_prompts(
-    prompts_path: Path | str | None = None,
-    inline_prompts: dict[str, Any] | None = None,
-    reload: bool = False,
-) -> PromptsConfig:
-    """Get or load the global prompts configuration.
-
-    Prompts are loaded with the following priority:
-    1. Inline prompts (if provided)
-    2. prompts_file (from config or explicit path)
-
-    Args:
-        prompts_path: Path to prompts file (only used on first load)
-        inline_prompts: Inline prompts dict from config (overrides file)
-        reload: Force reload configuration
-
-    Returns:
-        PromptsConfig instance
-
-    Raises:
-        PromptsError: If prompts cannot be loaded.
-    """
-    global _prompts
-
-    if _prompts is None or reload:
-        if inline_prompts is not None:
-            # Use inline prompts from config
-            if (
-                "instructions" not in inline_prompts
-                or not inline_prompts["instructions"]
-            ):
-                raise PromptsError("Missing 'instructions' in inline prompts")
-            try:
-                _prompts = PromptsConfig.model_validate(inline_prompts)
-                logger.debug("Using inline prompts from config")
-            except Exception as e:
-                raise PromptsError(f"Invalid inline prompts: {e}") from e
-        else:
-            _prompts = load_prompts(prompts_path)
-
-    return _prompts
+"""Prompts loader for externalized MCP server instructions.
+
+Loads prompts from prompts.yaml. File must exist and contain instructions.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+from loguru import logger
+from pydantic import BaseModel, Field
+
+
+class ToolPrompt(BaseModel):
+    """Prompt configuration for a specific tool."""
+
+    description: str | None = Field(
+        default=None, description="Override tool description"
+    )
+    examples: list[str] = Field(default_factory=list, description="Usage examples")
+
+
+class PromptsConfig(BaseModel):
+    """Configuration for MCP server prompts and tool descriptions."""
+
+    instructions: str = Field(
+        description="Main server instructions shown to the LLM",
+    )
+    tools: dict[str, ToolPrompt] = Field(
+        default_factory=dict,
+        description="Per-tool prompt overrides",
+    )
+    templates: dict[str, str] = Field(
+        default_factory=dict,
+        description="Reusable prompt templates with {variable} placeholders",
+    )
+    packs: dict[str, str] = Field(
+        default_factory=dict,
+        description="Per-pack instructions (e.g., excel, github)",
+    )
+
+
+class PromptsError(Exception):
+    """Error loading prompts configuration."""
+
+
+def _get_template_prompts_path() -> Path:
+    """Get path to prompts.yaml in global_templates (for development/testing)."""
+    return Path(__file__).parent / "config" / "global_templates" / "prompts.yaml"
+
+
+def load_prompts(prompts_path: Path | str | None = None) -> PromptsConfig:
+    """Load prompts configuration from YAML file.
+
+    Args:
+        prompts_path: Path to prompts file. Falls back to global_templates for development.
+
+    Returns:
+        PromptsConfig with loaded prompts.
+
+    Raises:
+        PromptsError: If file is invalid or has no instructions.
+    """
+    if prompts_path is not None:
+        prompts_path = Path(prompts_path)
+        if not prompts_path.exists():
+            raise PromptsError(f"Prompts file not found: {prompts_path}")
+    else:
+        # Try config/prompts.yaml, fall back to global_templates for development
+        prompts_path = Path("config/prompts.yaml")
+        if not prompts_path.exists():
+            prompts_path = _get_template_prompts_path()
+
+    logger.debug(f"Loading prompts from {prompts_path}")
+
+    try:
+        with prompts_path.open() as f:
+            raw_data = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        raise PromptsError(f"Invalid YAML in {prompts_path}: {e}") from e
+    except OSError as e:
+        raise PromptsError(f"Error reading {prompts_path}: {e}") from e
+
+    if raw_data is None or not isinstance(raw_data, dict):
+        raise PromptsError(f"Empty or invalid prompts file: {prompts_path}")
+
+    # Handle nested 'prompts:' key (used in template files)
+    if "prompts" in raw_data and isinstance(raw_data["prompts"], dict):
+        raw_data = raw_data["prompts"]
+
+    if "instructions" not in raw_data or not raw_data["instructions"]:
+        raise PromptsError(f"Missing 'instructions' in {prompts_path}")
+
+    try:
+        return PromptsConfig.model_validate(raw_data)
+    except Exception as e:
+        raise PromptsError(f"Invalid prompts configuration: {e}") from e
+
+
+def render_template(
+    config: PromptsConfig, template_name: str, **kwargs: Any
+) -> str | None:
+    """Render a prompt template with variable substitution.
+
+    Args:
+        config: PromptsConfig with templates
+        template_name: Name of the template to render
+        **kwargs: Variables to substitute in the template
+
+    Returns:
+        Rendered template string, or None if template not found.
+    """
+    template = config.templates.get(template_name)
+    if template is None:
+        return None
+
+    try:
+        return template.format(**kwargs)
+    except KeyError as e:
+        logger.warning(f"Missing template variable: {e}")
+        return None
+
+
+def get_tool_description(
+    config: PromptsConfig, tool_name: str, default: str = ""
+) -> str:
+    """Get tool description from prompts config with fallback to docstring.
+
+    Args:
+        config: PromptsConfig with tool prompts
+        tool_name: Name of the tool
+        default: Default description if not in config (typically from docstring)
+
+    Returns:
+        Tool description string.
+    """
+    tool_prompt = config.tools.get(tool_name)
+    if tool_prompt and tool_prompt.description:
+        return tool_prompt.description
+    return default
+
+
+def get_tool_examples(config: PromptsConfig, tool_name: str) -> list[str]:
+    """Get usage examples for a tool.
+
+    Args:
+        config: PromptsConfig with tool prompts
+        tool_name: Name of the tool
+
+    Returns:
+        List of example strings.
+    """
+    tool_prompt = config.tools.get(tool_name)
+    if tool_prompt:
+        return tool_prompt.examples
+    return []
+
+
+def get_pack_instructions(config: PromptsConfig, pack: str) -> str | None:
+    """Get instructions for a pack from prompts config.
+
+    Args:
+        config: PromptsConfig with pack instructions
+        pack: Name of the pack (e.g., "excel", "github")
+
+    Returns:
+        Pack instructions string, or None if not configured.
+    """
+    return config.packs.get(pack)
+
+
+# Global prompts instance
+_prompts: PromptsConfig | None = None
+
+
+def get_prompts(
+    prompts_path: Path | str | None = None,
+    inline_prompts: dict[str, Any] | None = None,
+    reload: bool = False,
+) -> PromptsConfig:
+    """Get or load the global prompts configuration.
+
+    Prompts are loaded with the following priority:
+    1. Inline prompts (if provided)
+    2. prompts_file (from config or explicit path)
+
+    Args:
+        prompts_path: Path to prompts file (only used on first load)
+        inline_prompts: Inline prompts dict from config (overrides file)
+        reload: Force reload configuration
+
+    Returns:
+        PromptsConfig instance
+
+    Raises:
+        PromptsError: If prompts cannot be loaded.
+    """
+    global _prompts
+
+    if _prompts is None or reload:
+        if inline_prompts is not None:
+            # Use inline prompts from config
+            if (
+                "instructions" not in inline_prompts
+                or not inline_prompts["instructions"]
+            ):
+                raise PromptsError("Missing 'instructions' in inline prompts")
+            try:
+                _prompts = PromptsConfig.model_validate(inline_prompts)
+                logger.debug("Using inline prompts from config")
+            except Exception as e:
+                raise PromptsError(f"Invalid inline prompts: {e}") from e
+        else:
+            _prompts = load_prompts(prompts_path)
+
+    return _prompts
+
+
+def reset() -> None:
+    """Clear prompts cache for reload.
+
+    Use this as part of the config reload flow to force prompts to be
+    reloaded from disk on next access.
+    """
+    global _prompts
+    _prompts = None

ot/proxy/manager.py

@@ -10,16 +10,20 @@ import asyncio
 import contextlib
 import os
 from dataclasses import dataclass
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from fastmcp import Client
-from fastmcp.client.transports import StdioTransport
+from fastmcp.client.auth import BearerAuth, OAuth
+from fastmcp.client.transports import StdioTransport, StreamableHttpTransport
 from loguru import logger
 from mcp import types
 
-from ot.config.mcp import McpServerConfig, expand_secrets, expand_subprocess_env
+from ot.config import expand_vars
 from ot.logging import LogSpan
 
+if TYPE_CHECKING:
+    from ot.config.models import McpServerConfig
+
 
 @dataclass
 class ProxyToolInfo:
@@ -190,6 +194,124 @@ class ProxyManager:
         )
         return future.result(timeout=timeout + 5)
 
+    async def list_resources(self, server: str) -> list[dict[str, Any]]:
+        """List resources from a proxied MCP server.
+
+        Args:
+            server: Name of the server.
+
+        Returns:
+            List of resource metadata dicts. Empty list if server doesn't support resources.
+
+        Raises:
+            ValueError: If server is not connected.
+        """
+        client = self._clients.get(server)
+        if not client:
+            raise ValueError(f"Server '{server}' not connected")
+
+        try:
+            resources = await client.list_resources()
+            return [{"uri": r.uri, "name": r.name, "description": r.description or ""} for r in resources]
+        except (AttributeError, NotImplementedError):
+            # Server doesn't support resources
+            return []
+        except Exception as e:
+            # Check if error indicates unsupported feature
+            error_msg = str(e).lower()
+            if any(x in error_msg for x in ["not found", "not supported", "not implemented"]):
+                return []
+            raise
+
+    async def read_resource(self, server: str, uri: str) -> str:
+        """Read a resource from a proxied MCP server.
+
+        Args:
+            server: Name of the server.
+            uri: Resource URI to read.
+
+        Returns:
+            Resource content as text.
+
+        Raises:
+            ValueError: If server is not connected.
+        """
+        client = self._clients.get(server)
+        if not client:
+            raise ValueError(f"Server '{server}' not connected")
+
+        result = await client.read_resource(uri)
+        # Extract text from resource contents (ReadResourceResult.contents)
+        text_parts = []
+        for content in result.contents:  # type: ignore[attr-defined]
+            if hasattr(content, "text"):
+                text_parts.append(content.text)
+        return "\n".join(text_parts) if text_parts else ""
+
+    async def list_prompts(self, server: str) -> list[dict[str, Any]]:
+        """List prompts from a proxied MCP server.
+
+        Args:
+            server: Name of the server.
+
+        Returns:
+            List of prompt metadata dicts. Empty list if server doesn't support prompts.
+
+        Raises:
+            ValueError: If server is not connected.
+        """
+        client = self._clients.get(server)
+        if not client:
+            raise ValueError(f"Server '{server}' not connected")
+
+        try:
+            prompts = await client.list_prompts()
+            return [{"name": p.name, "description": p.description or ""} for p in prompts]
+        except (AttributeError, NotImplementedError):
+            # Server doesn't support prompts
+            return []
+        except Exception as e:
+            # Check if error indicates unsupported feature
+            error_msg = str(e).lower()
+            if any(x in error_msg for x in ["not found", "not supported", "not implemented"]):
+                return []
+            raise
+
+    async def get_prompt(self, server: str, name: str, arguments: dict[str, Any] | None = None) -> str:
+        """Get a rendered prompt from a proxied MCP server.
+
+        Args:
+            server: Name of the server.
+            name: Prompt name.
+            arguments: Optional arguments for the prompt.
+
+        Returns:
+            Rendered prompt content as text.
+
+        Raises:
+            ValueError: If server is not connected.
+        """
+        client = self._clients.get(server)
+        if not client:
+            raise ValueError(f"Server '{server}' not connected")
+
+        result = await client.get_prompt(name, arguments or {})
+        # Extract text from prompt messages
+        text_parts = []
+        for message in result.messages:
+            if hasattr(message, "content"):
+                content = message.content
+                if isinstance(content, str):
+                    text_parts.append(content)
+                elif isinstance(content, list):
+                    # Content is a list of content parts
+                    for part in content:
+                        if hasattr(part, "text"):
+                            text_parts.append(part.text)
+                elif hasattr(content, "text"):
+                    text_parts.append(content.text)
+        return "\n".join(text_parts) if text_parts else ""
+
     async def connect(self, configs: dict[str, McpServerConfig]) -> None:
         """Connect to all enabled MCP servers.
 
@@ -263,7 +385,11 @@ class ProxyManager:
             raise ValueError(f"Unknown server type: {config.type}")
 
     def _create_http_client(self, name: str, config: McpServerConfig) -> Client:  # type: ignore[type-arg]
-        """Create an HTTP/SSE client."""
+        """Create an HTTP client using Streamable HTTP transport.
+
+        Streamable HTTP is the recommended MCP transport for web-based servers,
+        supporting both batch responses and streaming via SSE.
+        """
         if not config.url:
             raise RuntimeError(f"Server {name}: HTTP server requires url")
 
@@ -277,21 +403,55 @@ class ProxyManager:
         headers = {}
         for key, value in config.headers.items():
             if "${" in value:
-                headers[key] = expand_secrets(value)
+                headers[key] = expand_vars(value)
             else:
                 headers[key] = value
 
-        return Client(url, headers=headers, timeout=float(config.timeout))
+        # Configure authentication
+        auth: OAuth | BearerAuth | None = None
+        if config.auth:
+            if config.auth.type == "oauth":
+                auth = OAuth(
+                    mcp_url=url,
+                    scopes=config.auth.scopes or [],
+                    client_name="OneTool",
+                )
+                logger.debug(f"Configured OAuth for {name} with scopes: {config.auth.scopes}")
+            else:  # bearer
+                token = expand_vars(config.auth.token) if config.auth.token else ""
+                auth = BearerAuth(token)
+                logger.debug(f"Configured bearer auth for {name}")
+
+        transport = StreamableHttpTransport(url=url, headers=headers if headers else None, auth=auth)
+        return Client(transport, timeout=float(config.timeout))
 
     def _create_stdio_client(self, name: str, config: McpServerConfig) -> Client:  # type: ignore[type-arg]
         """Create a stdio client."""
         if not config.command:
             raise RuntimeError(f"Server {name}: stdio server requires command")
 
-        # Build environment: PATH only + explicit config.env
+        # Build environment variables for subprocess
+        # Order: PATH (from host) -> root env -> server-specific env -> expand secrets
         env = {"PATH": os.environ.get("PATH", "")}
+
+        # Get root-level env from config (if available)
+        try:
+            from ot.config import get_config
+            root_config = get_config()
+            root_env = root_config.env
+        except Exception:
+            root_env = {}
+
+        # Merge: root env first, then server-specific env (overrides root)
+        for key, value in root_env.items():
+            env[key] = value
         for key, value in config.env.items():
-            env[key] = expand_subprocess_env(value)
+            env[key] = value
+
+        # Expand ${VAR} patterns from secrets and env: in all env values
+        for key, value in env.items():
+            if "${" in value:
+                env[key] = expand_vars(value)
 
         transport = StdioTransport(
             command=config.command,