mcpower-proxy 0.0.58__py3-none-any.whl

modules/utils/json.py

@@ -0,0 +1,120 @@
+"""
+JSON utilities for safe serialization and JSONC parsing
+"""
+import json
+from dataclasses import is_dataclass, asdict
+from enum import Enum
+from typing import Any
+
+from jsonc_parser.parser import JsoncParser
+from pydantic import BaseModel, AnyUrl
+
+
+def to_dict(value: Any) -> Any:
+    """
+    Convert any value to a dict/primitive structure suitable for JSON serialization.
+    Handles dataclasses, Pydantic models, dicts, lists, Enums, and nested structures.
+    
+    Args:
+        value: Any value to convert
+        
+    Returns:
+        Dict, list, or primitive value ready for JSON serialization
+    """
+    if value is None:
+        return None
+    elif isinstance(value, (str, int, float, bool)):
+        return value
+    elif isinstance(value, Enum):
+        # Convert Enum to its value for JSON serialization
+        return value.value
+    elif isinstance(value, dict):
+        return {k: to_dict(v) for k, v in value.items()}
+    elif isinstance(value, (list, tuple)):
+        return [to_dict(item) for item in value]
+    elif is_dataclass(value):
+        # Use asdict and recursively convert Enums to their values
+        return to_dict(asdict(value))
+    elif hasattr(value, 'model_dump'):
+        return value.model_dump()
+    elif hasattr(value, '__dict__'):
+        # Extract __dict__ for objects, excluding private attrs only
+        return {k: to_dict(v) for k, v in value.__dict__.items() if not k.startswith('_')}
+    else:
+        # Last resort - convert to string
+        return str(value)
+
+
+def safe_json_dumps(obj: Any, **kwargs) -> str:
+    """
+    Safely serialize objects to JSON, using Pydantic's built-in serialization when available
+    """
+    # If it's a Pydantic BaseModel, use its built-in JSON serialization
+    if isinstance(obj, BaseModel):
+        return obj.model_dump_json(**kwargs)
+    
+    # If it's a dict or list that might contain Pydantic objects, use custom serializer
+    def default_serializer(o):
+        if isinstance(o, BaseModel):
+            return o.model_dump()
+        if isinstance(o, AnyUrl):
+            return str(o)
+        # Handle Enums by converting to their value
+        if isinstance(o, Enum):
+            return o.value
+        # Handle dataclasses properly - recursively convert via to_dict to handle nested Enums
+        if is_dataclass(o):
+            return to_dict(o)
+        # Handle other objects with dict method
+        if hasattr(o, 'dict') and callable(o.dict):
+            return o.dict()
+        if hasattr(o, '__dict__'):
+            return o.__dict__
+        # Fallback to string representation
+        return str(o)
+    
+    return json.dumps(obj, default=default_serializer, **kwargs)
+
+
+def stringify_jsonc(obj: Any, **kwargs) -> str:
+    """
+    Serialize object to JSONC format when possible, falling back to regular JSON
+    
+    Args:
+        obj: The object to serialize
+        **kwargs: Additional arguments passed to the serializer
+        
+    Returns:
+        JSONC string representation
+    """
+    try:
+        # Use regular JSON for serialization
+        return json.dumps(obj, **kwargs)
+    except Exception:
+        # Fallback to safe_json_dumps if regular json.dumps fails
+        return safe_json_dumps(obj, **kwargs)
+
+
+def parse_jsonc(text: str) -> Any:
+    """
+    Parse JSONC (JSON with Comments) text using jsonc-parser, falling back to regular JSON if parsing fails
+    
+    Args:
+        text: The JSONC/JSON string to parse
+        
+    Returns:
+        Parsed object
+        
+    Raises:
+        json.JSONDecodeError: If parsing fails with both JSONC and JSON parsers
+    """
+    try:
+        # Use jsonc-parser for JSONC handling (comments support)
+        return JsoncParser.parse_str(text)
+    except Exception as e:
+        # If JSONC parsing fails, try regular JSON as fallback
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError:
+            # Re-raise the original JSONC error if JSON also fails
+            raise json.JSONDecodeError(f"JSONC parsing failed: {str(e)}", text, 0)

modules/utils/mcp_configs.py

@@ -0,0 +1,48 @@
+from fastmcp import mcp_config
+
+
+def extract_wrapped_server_info(wrapper_server_name, logger, configs: dict) -> tuple[str, str]:
+    """
+    Extract wrapped server name and transport using FastMCP utilities
+
+    Returns:
+        tuple: (server_name, transport_name)
+    """
+    try:
+        # Parse config using FastMCP's built-in utilities
+        parsed_config = mcp_config.MCPConfig.from_dict(configs)
+
+        # Get the first server (the most common case - single wrapped server)
+        first_server = list(parsed_config.mcpServers.values())[0]
+        first_server_key = list(parsed_config.mcpServers.keys())[0]
+
+        # Extract server name
+        # If the key is "default" (from raw config conversion) - use the wrapper name
+        if first_server_key == "default":
+            server_name = wrapper_server_name
+        else:
+            server_name = first_server_key
+
+        # Extract transport using FastMCP's transport resolution
+        transport_obj = first_server.to_transport()
+        transport_class = type(transport_obj).__name__
+
+        # Map FastMCP transport classes to simple string names
+        transport_mapping = {
+            'StdioTransport': 'stdio',
+            'StreamableHttpTransport': 'streamable-http',
+            'SSETransport': 'sse',
+            'WSTransport': 'ws',
+        }
+
+        wrapped_server_transport_name = transport_mapping.get(transport_class,
+                                                              transport_class.lower().replace('transport', ''))
+
+        logger.debug(f"Extracted wrapped server info: name={server_name}, "
+                     f"transport={wrapped_server_transport_name}")
+
+        return server_name, wrapped_server_transport_name
+
+    except Exception as e:
+        logger.error(f"Failed to extract wrapped server info: {e}")
+        raise e

wrapper/__init__.py

@@ -0,0 +1 @@
+# MCP Wrapper package

wrapper/__version__.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+"""
+Wrapper MCP Server Version
+"""
+
+__version__ = "0.0.58"