mseep-rmcp 0.3.3__py3-none-any.whl

mseep_rmcp-0.3.3.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: mseep-rmcp
+Version: 0.3.3
+Summary: Comprehensive Model Context Protocol server with 33 statistical analysis tools across 8 categories
+Author-email: mseep <support@skydeck.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/gojiplus/rmcp
+Project-URL: Repository, https://github.com/gojiplus/rmcp
+Project-URL: Documentation, https://github.com/gojiplus/rmcp#readme
+Project-URL: Issues, https://github.com/gojiplus/rmcp/issues
+Keywords: mcp,r,statistics,econometrics,model-context-protocol,data-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: R
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.8
+Description-Content-Type: text/plain
+License-File: LICENSE
+Requires-Dist: click>=8.1.0
+Requires-Dist: jsonschema>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+Provides-Extra: http
+Requires-Dist: fastapi>=0.100.0; extra == "http"
+Requires-Dist: uvicorn>=0.20.0; extra == "http"
+Requires-Dist: sse-starlette>=1.6.0; extra == "http"
+Provides-Extra: r
+Requires-Dist: subprocess32>=3.5.0; python_version < "3.3" and extra == "r"
+Dynamic: license-file
+
+Package managed by MseeP.ai

mseep_rmcp-0.3.3.dist-info/RECORD

@@ -0,0 +1,34 @@
+mseep_rmcp-0.3.3.dist-info/licenses/LICENSE,sha256=9vFQ7IesB0PIsHbqsP3NFa2Hoq1dzbavqbN7rpF-RcE,1062
+rmcp/__init__.py,sha256=AitIbW6uioNUS5HvPoKy3lAeMPz9yyoXbiBz-KswMiY,937
+rmcp/cli.py,sha256=_Gwsn8_big6E7KFBwENBJVjK0hOoMB7QZ7bS_g0_JtE,9413
+rmcp/r_integration.py,sha256=I9OdB5Q0jnMEXjrUfsgiN4YfnB_Lgw7aWkz0mFzAuMc,3665
+rmcp/core/__init__.py,sha256=oQPSq-6PQwpdClzIrIYA2lgUGYFRCy66lj_mrxtgKek,419
+rmcp/core/context.py,sha256=HRK1CuH40hq921cHBAU13yDqcX1BKoT5UVuu_oV9PUI,4877
+rmcp/core/schemas.py,sha256=dwcd-yunU49CFM7LPn0_m49Z-BlfqdciVsW3fWttKKw,4383
+rmcp/core/server.py,sha256=0vYNoIa8Q9mraOVhamqq6Fdauz714ucfFjwU_ulDses,9110
+rmcp/r_assets/__init__.py,sha256=TMIhwzg5zTPgIFW-sEui4c8sJ79RmWTqXvjJomlwV0Y,155
+rmcp/registries/__init__.py,sha256=Y099uvTx4bMlKTttxWH5XKRCZghgNkCLGrVhEaSBOtQ,636
+rmcp/registries/prompts.py,sha256=WqvBRw3bap-1etBUui5Xn6WflpLFbM9bHjXqWN_8BjQ,10182
+rmcp/registries/resources.py,sha256=D5AB8xmpdNaOT5tX_aHRuaJleDuM9X4X_8SgRLIXvTA,9027
+rmcp/registries/tools.py,sha256=hVx8joLUUDWk4uQVnYeBbfcWcLrFuhj2hiCHvoPmUds,7188
+rmcp/scripts/__init__.py,sha256=i5_HI3cpEb4afuLt-KSHdsEXYo5aEtEz8y1jSJasJtY,152
+rmcp/security/__init__.py,sha256=IP5q8qpOA7b_ZtVg3zyLweO918SP05_QEF3t04OimoA,313
+rmcp/security/vfs.py,sha256=0VRiKKh9_YX7wpmO-tZem1gWQv5DOf2dNOGpjtt3bWE,8323
+rmcp/tools/descriptive.py,sha256=ge0dIeuXB6Dhb9dxUbV8MBE5RqZ1Pcza8EhkYugXjrM,8749
+rmcp/tools/econometrics.py,sha256=iU8MncE8TkmO4x089lQ10q_ecFzfBAiguzpx-cFz74o,8285
+rmcp/tools/fileops.py,sha256=wvM9uI8pWZVu4QS36XLUBsioRuq7_ZyHF0LGqJU3sGo,9944
+rmcp/tools/machine_learning.py,sha256=PFSi63RFhx7ouTLYCW3s89iH2f5AMn_gTrBGqCvEbVg,9645
+rmcp/tools/regression.py,sha256=4WzF-9Z9dQ-r6u6eXmd2qhykJYxPmuec4Uqiktw-fx8,9768
+rmcp/tools/statistical_tests.py,sha256=PIkt2GWbi3zLvJgoKDxzQCLBpI1lFzR2QAbe-0ATMKE,11190
+rmcp/tools/timeseries.py,sha256=wKUntaCPSxSAaRdIZrw1J6ZwrNryFxB3YaW05GKIs0s,7480
+rmcp/tools/transforms.py,sha256=aqHV-rqWSTOr2eDg1uwgmNxzLNqYu-lvyHaS9cdhMdQ,9156
+rmcp/tools/visualization.py,sha256=7AVReAY23zEsvFI7I1nTgRoNzAAKaVDkaQDA8yz-tfg,20149
+rmcp/transport/__init__.py,sha256=ssvYT6JSBl6Iaas0MnFJfvVb-kwOAIFBmJHkO7xJp6Q,515
+rmcp/transport/base.py,sha256=aWr6qK9iawcpo8SVSqmTUBiciiCnp5QEXIoPCWMxhdQ,4208
+rmcp/transport/jsonrpc.py,sha256=4I-gyXZ_gV6B9BxyPD5OxBTVD14gsMe_M_OuoHed27E,7833
+rmcp/transport/stdio.py,sha256=SkZ2wl0GJolwRp125IL1QNkQPGJ-jj9ziIvKB5-8vto,7571
+mseep_rmcp-0.3.3.dist-info/METADATA,sha256=_xczBCyFykjkTUjX-B94zgTCyoC5k5nINP-9XujUBXI,2209
+mseep_rmcp-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mseep_rmcp-0.3.3.dist-info/entry_points.txt,sha256=GLl2t_fBiIuN5st0RjbPyaLIf6jpeIYbyy7qglOn-Oo,38
+mseep_rmcp-0.3.3.dist-info/top_level.txt,sha256=cQtbyZqL6sY1EKAAp_yOm010hAc6PPMtP1oxyGt5BQc,5
+mseep_rmcp-0.3.3.dist-info/RECORD,,

mseep_rmcp-0.3.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mseep_rmcp-0.3.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rmcp = rmcp.cli:cli

mseep_rmcp-0.3.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 goji+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mseep_rmcp-0.3.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+rmcp

rmcp/__init__.py

@@ -0,0 +1,31 @@
+"""
+RMCP MCP Server - A Model Context Protocol server for R-based statistical analysis.
+
+This package implements a production-ready MCP server following established patterns:
+- Spec correctness by construction using official SDK
+- Clean separation of concerns (protocol/registries/domain)
+- Security by default (VFS, allowlists, sandboxing)
+- Transport-agnostic design (stdio primary, HTTP optional)
+- Explicit schemas and typed context objects
+"""
+
+from .core.context import Context
+from .core.server import create_server
+from .registries.tools import ToolsRegistry, tool
+from .registries.resources import ResourcesRegistry, resource
+from .registries.prompts import PromptsRegistry, prompt
+
+__version__ = "0.3.2"
+__author__ = "Gaurav Sood"
+__email__ = "gsood07@gmail.com"
+
+__all__ = [
+    "Context",
+    "create_server", 
+    "ToolsRegistry",
+    "ResourcesRegistry", 
+    "PromptsRegistry",
+    "tool",
+    "resource", 
+    "prompt",
+]

rmcp/cli.py

@@ -0,0 +1,317 @@
+"""
+Command-line interface for RMCP MCP Server.
+
+Provides entry points for running the server with different transports
+and configurations, following the principle of "multiple deployment targets."
+"""
+
+import asyncio
+import click
+import logging
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from .core.server import create_server
+from .transport.stdio import StdioTransport
+from .registries.tools import register_tool_functions  
+from .registries.resources import ResourcesRegistry
+from .registries.prompts import register_prompt_functions, statistical_workflow_prompt, model_diagnostic_prompt
+
+# Configure logging to stderr only
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    stream=sys.stderr
+)
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+@click.version_option(version="0.3.2")
+def cli():
+    """RMCP MCP Server - Comprehensive statistical analysis with 33 tools across 8 categories."""
+    pass
+
+
+@cli.command()
+@click.option(
+    "--log-level",
+    type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR"]),
+    default="INFO",
+    help="Logging level"
+)
+def start(log_level: str):
+    """Start RMCP MCP server (default stdio transport)."""
+    
+    # Set logging level
+    logging.getLogger().setLevel(getattr(logging, log_level))
+    
+    logger.info("Starting RMCP MCP Server")
+    
+    try:
+        # Create and configure server
+        server = create_server()
+        config = {"allowed_paths": [str(Path.cwd())], "read_only": True}
+        server.configure(**config)
+        
+        # Register built-in statistical tools
+        _register_builtin_tools(server)
+        
+        # Register built-in prompts
+        register_prompt_functions(
+            server.prompts,
+            statistical_workflow_prompt,
+            model_diagnostic_prompt
+        )
+        
+        # Set up stdio transport
+        transport = StdioTransport()
+        transport.set_message_handler(server.handle_request)
+        
+        # Run the server
+        asyncio.run(transport.run())
+        
+    except KeyboardInterrupt:
+        logger.info("Server interrupted by user")
+    except Exception as e:
+        logger.error(f"Server error: {e}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.option(
+    "--allowed-paths", 
+    multiple=True, 
+    help="Allowed file system paths (can be specified multiple times)"
+)
+@click.option(
+    "--cache-root",
+    type=click.Path(),
+    help="Root directory for content caching"
+)
+@click.option(
+    "--read-only/--read-write",
+    default=True,
+    help="File system access mode (default: read-only)"
+)
+@click.option(
+    "--log-level",
+    type=click.Choice(["DEBUG", "INFO", "WARNING", "ERROR"]),
+    default="INFO",
+    help="Logging level"
+)
+@click.option(
+    "--config-file",
+    type=click.Path(exists=True),
+    help="Configuration file path"
+)
+def serve(
+    allowed_paths: List[str],
+    cache_root: Optional[str],
+    read_only: bool,
+    log_level: str,
+    config_file: Optional[str],
+):
+    """Run MCP server with advanced configuration options."""
+    
+    # Set logging level
+    logging.getLogger().setLevel(getattr(logging, log_level))
+    
+    logger.info("Starting RMCP MCP Server")
+    
+    try:
+        # Load configuration
+        config = _load_config(config_file) if config_file else {}
+        
+        # Override with CLI options
+        if allowed_paths:
+            config["allowed_paths"] = list(allowed_paths)
+        if cache_root:
+            config["cache_root"] = cache_root
+        config["read_only"] = read_only
+        
+        # Set defaults if not specified
+        if "allowed_paths" not in config:
+            config["allowed_paths"] = [str(Path.cwd())]
+        
+        # Create and configure server
+        server = create_server()
+        server.configure(**config)
+        
+        # Register built-in statistical tools
+        _register_builtin_tools(server)
+        
+        # Register built-in prompts
+        register_prompt_functions(
+            server.prompts,
+            statistical_workflow_prompt,
+            model_diagnostic_prompt
+        )
+        
+        # Set up stdio transport
+        transport = StdioTransport()
+        transport.set_message_handler(server.handle_request)
+        
+        # Run the server
+        asyncio.run(transport.run())
+        
+    except KeyboardInterrupt:
+        logger.info("Server interrupted by user")
+    except Exception as e:
+        logger.error(f"Server error: {e}")
+        sys.exit(1)
+
+
+@cli.command()
+@click.option("--host", default="localhost", help="Host to bind to")
+@click.option("--port", default=8000, help="Port to bind to")
+def serve_http(host: str, port: int):
+    """Run MCP server over HTTP transport (requires fastapi extras)."""
+    try:
+        from .transport.http import HTTPTransport
+    except ImportError:
+        click.echo("HTTP transport requires 'fastapi' extras. Install with: pip install rmcp-mcp[http]")
+        sys.exit(1)
+    
+    logger.info(f"HTTP transport not yet implemented")
+    # TODO: Implement HTTP transport
+    click.echo("HTTP transport coming soon!")
+
+
+@cli.command()
+@click.option(
+    "--allowed-paths",
+    multiple=True,
+    help="Allowed file system paths"
+)
+@click.option("--output", type=click.Path(), help="Output file for capabilities")
+def list_capabilities(allowed_paths: List[str], output: Optional[str]):
+    """List server capabilities (tools, resources, prompts)."""
+    
+    # Create server to inspect capabilities
+    server = create_server()
+    if allowed_paths:
+        server.configure(allowed_paths=list(allowed_paths))
+    
+    _register_builtin_tools(server)
+    register_prompt_functions(server.prompts, statistical_workflow_prompt, model_diagnostic_prompt)
+    
+    async def _list():
+        from .core.context import Context, LifespanState
+        
+        context = Context.create("list", "list", server.lifespan_state)
+        
+        # Get capabilities
+        tools = await server.tools.list_tools(context)
+        resources = await server.resources.list_resources(context) 
+        prompts = await server.prompts.list_prompts(context)
+        
+        capabilities = {
+            "server": {
+                "name": server.name,
+                "version": server.version,
+                "description": server.description
+            },
+            "tools": tools,
+            "resources": resources,
+            "prompts": prompts
+        }
+        
+        import json
+        json_output = json.dumps(capabilities, indent=2)
+        
+        if output:
+            with open(output, 'w') as f:
+                f.write(json_output)
+            click.echo(f"Capabilities written to {output}")
+        else:
+            click.echo(json_output)
+    
+    asyncio.run(_list())
+
+
+@cli.command()
+def validate_config():
+    """Validate server configuration."""
+    click.echo("Configuration validation not yet implemented")
+    # TODO: Add config validation
+
+
+def _load_config(config_file: str) -> dict:
+    """Load configuration from file."""
+    import json
+    
+    try:
+        with open(config_file, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        logger.error(f"Failed to load config file {config_file}: {e}")
+        return {}
+
+
+def _register_builtin_tools(server):
+    """Register built-in statistical tools."""
+    from .tools.regression import linear_model, correlation_analysis, logistic_regression
+    from .tools.timeseries import arima_model, decompose_timeseries, stationarity_test
+    from .tools.transforms import lag_lead, winsorize, difference, standardize
+    from .tools.statistical_tests import t_test, anova, chi_square_test, normality_test
+    from .tools.descriptive import summary_stats, outlier_detection, frequency_table
+    from .tools.fileops import read_csv, write_csv, data_info, filter_data
+    from .tools.econometrics import panel_regression, instrumental_variables, var_model
+    from .tools.machine_learning import kmeans_clustering, decision_tree, random_forest
+    from .tools.visualization import scatter_plot, histogram, boxplot, time_series_plot, correlation_heatmap, regression_plot
+    
+    # Register all statistical tools
+    register_tool_functions(
+        server.tools,
+        # Original regression tools
+        linear_model,
+        correlation_analysis, 
+        logistic_regression,
+        # Time series analysis
+        arima_model,
+        decompose_timeseries,
+        stationarity_test,
+        # Data transformations
+        lag_lead,
+        winsorize,
+        difference,
+        standardize,
+        # Statistical tests
+        t_test,
+        anova,
+        chi_square_test,
+        normality_test,
+        # Descriptive statistics
+        summary_stats,
+        outlier_detection,
+        frequency_table,
+        # File operations
+        read_csv,
+        write_csv,
+        data_info,
+        filter_data,
+        # Econometrics
+        panel_regression,
+        instrumental_variables,
+        var_model,
+        # Machine learning
+        kmeans_clustering,
+        decision_tree,
+        random_forest,
+        # Visualization
+        scatter_plot,
+        histogram,
+        boxplot,
+        time_series_plot,
+        correlation_heatmap,
+        regression_plot
+    )
+    
+    logger.info("Registered comprehensive statistical analysis tools (30 total)")
+
+
+if __name__ == "__main__":
+    cli()

rmcp/core/__init__.py

@@ -0,0 +1,14 @@
+"""
+Core MCP server components.
+
+This module contains the fundamental building blocks:
+- Context: Typed context for request + lifespan state
+- Server: MCP app shell with lifecycle hooks
+- Schemas: JSON Schema validation helpers
+"""
+
+from .context import Context
+from .server import create_server
+from .schemas import validate_schema, SchemaError
+
+__all__ = ["Context", "create_server", "validate_schema", "SchemaError"]

rmcp/core/context.py

@@ -0,0 +1,150 @@
+"""
+Typed context object for MCP requests.
+
+The Context object provides:
+- Per-request state (request ID, progress token, cancellation)
+- Lifespan state (settings, caches, resources)
+- Cross-cutting features (logging, progress, security)
+
+Following the principle: "Makes cross-cutting features universal without globals."
+"""
+
+from typing import Any, Dict, Optional, Callable, Awaitable
+from dataclasses import dataclass, field
+import asyncio
+import logging
+from pathlib import Path
+
+
+@dataclass
+class RequestState:
+    """Per-request state passed to tool handlers."""
+    
+    request_id: str
+    method: str
+    progress_token: Optional[str] = None
+    cancelled: bool = False
+    
+    def is_cancelled(self) -> bool:
+        """Check if request has been cancelled."""
+        return self.cancelled
+    
+    def cancel(self) -> None:
+        """Mark request as cancelled."""
+        self.cancelled = True
+
+
+@dataclass 
+class LifespanState:
+    """Lifespan state shared across requests."""
+    
+    # Configuration
+    settings: Dict[str, Any] = field(default_factory=dict)
+    
+    # Security
+    allowed_paths: list[Path] = field(default_factory=list)
+    read_only: bool = True
+    
+    # Caching
+    cache_root: Optional[Path] = None
+    content_cache: Dict[str, Any] = field(default_factory=dict)
+    
+    # Resources
+    resource_mounts: Dict[str, Path] = field(default_factory=dict)
+
+
+@dataclass
+class Context:
+    """
+    Typed context passed to all tool handlers.
+    
+    Provides both per-request state and shared lifespan state,
+    plus helpers for logging, progress, and cancellation.
+    """
+    
+    request: RequestState
+    lifespan: LifespanState
+    
+    # Progress/logging callbacks
+    _progress_callback: Optional[Callable[[str, int, int], Awaitable[None]]] = None
+    _log_callback: Optional[Callable[[str, str, Dict[str, Any]], Awaitable[None]]] = None
+    
+    @classmethod
+    def create(
+        cls,
+        request_id: str,
+        method: str,
+        lifespan_state: LifespanState,
+        progress_token: Optional[str] = None,
+        progress_callback: Optional[Callable[[str, int, int], Awaitable[None]]] = None,
+        log_callback: Optional[Callable[[str, str, Dict[str, Any]], Awaitable[None]]] = None,
+    ) -> "Context":
+        """Create a new context for a request."""
+        request_state = RequestState(
+            request_id=request_id,
+            method=method,
+            progress_token=progress_token
+        )
+        
+        return cls(
+            request=request_state,
+            lifespan=lifespan_state,
+            _progress_callback=progress_callback,
+            _log_callback=log_callback,
+        )
+    
+    # Cross-cutting feature helpers
+    
+    async def progress(self, message: str, current: int, total: int) -> None:
+        """Send progress notification if progress token is available."""
+        if self.request.progress_token and self._progress_callback:
+            await self._progress_callback(message, current, total)
+    
+    async def log(self, level: str, message: str, **kwargs: Any) -> None:
+        """Send structured log notification."""
+        if self._log_callback:
+            await self._log_callback(level, message, kwargs)
+    
+    async def info(self, message: str, **kwargs: Any) -> None:
+        """Log info message."""
+        await self.log("info", message, **kwargs)
+    
+    async def warn(self, message: str, **kwargs: Any) -> None:
+        """Log warning message."""
+        await self.log("warning", message, **kwargs)
+    
+    async def error(self, message: str, **kwargs: Any) -> None:
+        """Log error message."""
+        await self.log("error", message, **kwargs)
+    
+    def check_cancellation(self) -> None:
+        """Check if request has been cancelled, raise if so."""
+        if self.request.is_cancelled():
+            raise asyncio.CancelledError("Request was cancelled")
+    
+    # Security helpers
+    
+    def is_path_allowed(self, path: Path) -> bool:
+        """Check if path access is allowed."""
+        try:
+            resolved_path = path.resolve()
+            return any(
+                resolved_path.is_relative_to(allowed_root.resolve())
+                for allowed_root in self.lifespan.allowed_paths
+            )
+        except (OSError, ValueError):
+            return False
+    
+    def require_path_access(self, path: Path) -> None:
+        """Require path access, raise if denied."""
+        if not self.is_path_allowed(path):
+            raise PermissionError(
+                f"Path access denied: {path}. "
+                f"Allowed roots: {[str(p) for p in self.lifespan.allowed_paths]}"
+            )
+    
+    def get_cache_path(self, key: str) -> Optional[Path]:
+        """Get cache path for key if caching is enabled."""
+        if self.lifespan.cache_root:
+            return self.lifespan.cache_root / key
+        return None