mcp-mesh 0.4.1__tar.gz → 0.4.2__tar.gz

{mcp_mesh-0.4.1 → mcp_mesh-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.4.1
+Version: 0.4.2
 Summary: Kubernetes-native platform for distributed MCP applications
 Project-URL: Homepage, https://github.com/dhyansraj/mcp-mesh
 Project-URL: Documentation, https://github.com/dhyansraj/mcp-mesh/tree/main/docs

{mcp_mesh-0.4.1 → mcp_mesh-0.4.2}/_mcp_mesh/__init__.py

@@ -31,7 +31,7 @@ from .engine.decorator_registry import (
     get_decorator_stats,
 )
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"
 
 # Store reference to runtime processor if initialized
 _runtime_processor = None

{mcp_mesh-0.4.1 → mcp_mesh-0.4.2}/_mcp_mesh/engine/async_mcp_client.py

@@ -6,6 +6,8 @@ import urllib.error
 import urllib.request
 from typing import Any
 
+from ..shared.sse_parser import SSEParser
+
 logger = logging.getLogger(__name__)
 
 
@@ -62,25 +64,10 @@ class AsyncMCPClient:
 
                 response_text = response.text
 
-                # Handle Server-Sent Events format from FastMCP
-                if response_text.startswith("event:"):
-                    # Parse SSE format: extract JSON from "data:" lines
-                    json_data = None
-                    for line in response_text.split("\n"):
-                        if line.startswith("data:"):
-                            json_str = line[5:].strip()  # Remove 'data:' prefix
-                            try:
-                                json_data = json.loads(json_str)
-                                break
-                            except json.JSONDecodeError:
-                                continue
-
-                    if json_data is None:
-                        raise RuntimeError("Could not parse SSE response from FastMCP")
-                    data = json_data
-                else:
-                    # Plain JSON response
-                    data = response.json()
+                # Use shared SSE parser
+                data = SSEParser.parse_sse_response(
+                    response_text, f"AsyncMCPClient.{self.endpoint}"
+                )
 
             # Check for JSON-RPC error
             if "error" in data:

{mcp_mesh-0.4.1 → mcp_mesh-0.4.2}/_mcp_mesh/engine/full_mcp_proxy.py

@@ -7,6 +7,7 @@ import uuid
 from collections.abc import AsyncIterator
 from typing import Any, Optional
 
+from ..shared.sse_parser import SSEStreamProcessor
 from .async_mcp_client import AsyncMCPClient
 from .mcp_client_proxy import MCPClientProxy
 
@@ -103,15 +104,18 @@ class FullMCPProxy(MCPClientProxy):
                         if response.status_code >= 400:
                             raise RuntimeError(f"HTTP error {response.status_code}")
 
-                        async for line in response.aiter_lines():
-                            if line.startswith("data: "):
-                                try:
-                                    data_str = line[6:]  # Remove "data: " prefix
-                                    if data_str.strip():
-                                        chunk = json.loads(data_str)
-                                        yield chunk
-                                except json.JSONDecodeError:
-                                    continue
+                        # Use shared SSE stream processor
+                        sse_processor = SSEStreamProcessor(f"FullMCPProxy.{name}")
+
+                        async for chunk_bytes in response.aiter_bytes(8192):
+                            chunks = sse_processor.process_chunk(chunk_bytes)
+                            for chunk in chunks:
+                                yield chunk
+
+                        # Process any remaining data
+                        final_chunks = sse_processor.finalize()
+                        for chunk in final_chunks:
+                            yield chunk
 
             except ImportError:
                 # Fallback: if httpx not available, use sync call
@@ -588,19 +592,20 @@ class EnhancedFullMCPProxy(FullMCPProxy):
                 ) as response:
                     response.raise_for_status()
 
-                    buffer = ""
-                    async for chunk in response.aiter_bytes(self.buffer_size):
-                        buffer += chunk.decode("utf-8")
+                    # Use shared SSE stream processor
+                    sse_processor = SSEStreamProcessor(f"EnhancedFullMCPProxy.{name}")
 
-                        while "\n" in buffer:
-                            line, buffer = buffer.split("\n", 1)
+                    async for chunk_bytes in response.aiter_bytes(
+                        max(self.buffer_size, 8192)
+                    ):
+                        chunks = sse_processor.process_chunk(chunk_bytes)
+                        for chunk in chunks:
+                            yield chunk
 
-                            if line.startswith("data: "):
-                                try:
-                                    data = json.loads(line[6:])
-                                    yield data
-                                except json.JSONDecodeError:
-                                    continue
+                    # Process any remaining data
+                    final_chunks = sse_processor.finalize()
+                    for chunk in final_chunks:
+                        yield chunk
 
         except httpx.TimeoutException:
             raise Exception(f"Streaming timeout after {self.stream_timeout}s")

{mcp_mesh-0.4.1 → mcp_mesh-0.4.2}/_mcp_mesh/engine/mcp_client_proxy.py

@@ -10,6 +10,7 @@ import uuid
 from typing import Any, Optional
 
 from ..shared.content_extractor import ContentExtractor
+from ..shared.sse_parser import SSEParser
 from .async_mcp_client import AsyncMCPClient
 
 logger = logging.getLogger(__name__)
@@ -113,25 +114,10 @@ class MCPClientProxy:
             with urllib.request.urlopen(req, timeout=30.0) as response:
                 response_data = response.read().decode("utf-8")
 
-                # Handle Server-Sent Events format from FastMCP
-                if response_data.startswith("event:"):
-                    # Parse SSE format: extract JSON from "data:" lines
-                    json_data = None
-                    for line in response_data.split("\n"):
-                        if line.startswith("data:"):
-                            json_str = line[5:].strip()  # Remove 'data:' prefix
-                            try:
-                                json_data = json.loads(json_str)
-                                break
-                            except json.JSONDecodeError:
-                                continue
-
-                    if json_data is None:
-                        raise RuntimeError("Could not parse SSE response from FastMCP")
-                    data = json_data
-                else:
-                    # Plain JSON response
-                    data = json.loads(response_data)
+                # Use shared SSE parser
+                data = SSEParser.parse_sse_response(
+                    response_data, f"MCPClientProxy.{self.function_name}"
+                )
 
             # Check for JSON-RPC error
             if "error" in data:

{mcp_mesh-0.4.1 → mcp_mesh-0.4.2}/_mcp_mesh/pipeline/startup/fastmcpserver_discovery.py

@@ -41,7 +41,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
             server_info = []
             total_registered_functions = 0
 
-            for server_name, server_instance in discovered_servers.items():
+            for server_name, server_instance in list(discovered_servers.items()):
                 info = self._extract_server_info(server_name, server_instance)
                 server_info.append(info)
                 total_registered_functions += info.get("function_count", 0)
@@ -119,7 +119,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
                 "pkgutil",
             }
 
-            for module_name, module in sys.modules.items():
+            for module_name, module in list(sys.modules.items()):
                 if (
                     module
                     and not module_name.startswith("_")
@@ -166,7 +166,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
             module_globals = vars(module)
             # Only log if we find FastMCP instances to reduce noise
 
-            for var_name, var_value in module_globals.items():
+            for var_name, var_value in list(module_globals.items()):
                 if self._is_fastmcp_instance(var_value):
                     instance_key = f"{module_name}.{var_name}"
                     found[instance_key] = var_value
@@ -230,7 +230,7 @@ class FastMCPServerDiscoveryStep(PipelineStep):
                     info["function_count"] += len(tools)
 
                     self.logger.debug(f"Server '{server_name}' has {len(tools)} tools:")
-                    for tool_name, tool in tools.items():
+                    for tool_name, tool in list(tools.items()):
                         function_ptr = getattr(tool, "fn", None)
                         self.logger.debug(f"  - {tool_name}: {function_ptr}")
 

mcp_mesh-0.4.2/_mcp_mesh/shared/sse_parser.py

@@ -0,0 +1,217 @@
+"""Server-Sent Events (SSE) parsing utilities for MCP responses."""
+
+import json
+import logging
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class SSEParser:
+    """Utility class for parsing Server-Sent Events responses from FastMCP servers.
+
+    Handles the common issue where large JSON responses get split across multiple
+    SSE 'data:' lines, which would cause JSON parsing failures if processed line-by-line.
+    """
+
+    @staticmethod
+    def parse_sse_response(
+        response_text: str, context: str = "unknown"
+    ) -> dict[str, Any]:
+        """
+        Parse SSE response text and extract JSON data.
+
+        Handles multi-line JSON responses by accumulating all 'data:' lines
+        before attempting to parse JSON.
+
+        Args:
+            response_text: Raw SSE response text
+            context: Context string for error logging
+
+        Returns:
+            Parsed JSON data as dictionary
+
+        Raises:
+            RuntimeError: If SSE response cannot be parsed
+        """
+        logger.debug(f"🔧 SSEParser.parse_sse_response called from {context}")
+        logger.debug(
+            f"🔧 Response text length: {len(response_text)}, starts with 'event:': {response_text.startswith('event:')}"
+        )
+        logger.debug(f"🔧 Response preview: {repr(response_text[:100])}...")
+
+        # Check if this is SSE format (can be malformed and not start with "event:")
+        is_sse_format = (
+            response_text.startswith("event:")
+            or "event: message" in response_text
+            or "data: " in response_text
+        )
+
+        if not is_sse_format:
+            # Not an SSE response, try parsing as plain JSON
+            logger.debug(f"🔧 {context}: Parsing as plain JSON (not SSE format)")
+            logger.debug(
+                f"🔧 {context}: Response preview: {repr(response_text[:200])}..."
+            )
+            try:
+                result = json.loads(response_text)
+                logger.debug(f"🔧 {context}: Plain JSON parsed successfully")
+                return result
+            except json.JSONDecodeError as e:
+                logger.error(f"🔧 {context}: Plain JSON parse failed: {e}")
+                logger.error(
+                    f"🔧 {context}: Invalid response content (first 500 chars): {repr(response_text[:500])}"
+                )
+                raise RuntimeError(f"Invalid JSON response in {context}: {e}")
+
+        # Parse SSE format: find first valid JSON in data lines
+        logger.debug(f"🔧 {context}: Parsing SSE format - looking for first valid JSON")
+        data_line_count = 0
+        first_valid_json = None
+
+        for line in response_text.split("\n"):
+            if line.startswith("data:"):
+                data_content = line[5:].strip()  # Remove 'data:' prefix and whitespace
+                if data_content:
+                    data_line_count += 1
+                    try:
+                        # Try to parse this line as JSON
+                        parsed_json = json.loads(data_content)
+                        if first_valid_json is None:
+                            first_valid_json = parsed_json
+                            logger.debug(f"🔧 {context}: Found first valid JSON in data line {data_line_count}")
+                    except json.JSONDecodeError:
+                        # Skip invalid JSON lines - this is expected behavior
+                        logger.debug(f"🔧 {context}: Skipping invalid JSON in data line {data_line_count}: {data_content[:50]}...")
+                        continue
+
+        logger.debug(
+            f"🔧 {context}: Processed {data_line_count} data lines"
+        )
+
+        # Return first valid JSON found
+        if first_valid_json is None:
+            logger.error(f"🔧 {context}: No valid JSON found in SSE response")
+            raise RuntimeError(f"Could not parse SSE response from FastMCP")
+
+        logger.debug(
+            f"🔧 {context}: SSE parsing successful! Result type: {type(first_valid_json)}"
+        )
+        return first_valid_json
+
+    @staticmethod
+    def parse_streaming_sse_chunk(chunk_data: str) -> Optional[dict[str, Any]]:
+        """
+        Parse a single streaming SSE chunk.
+
+        Used for processing individual chunks in streaming responses.
+
+        Args:
+            chunk_data: Single data line content (without 'data:' prefix)
+
+        Returns:
+            Parsed JSON if valid and complete, None if should be skipped
+        """
+        if not chunk_data.strip():
+            return None
+
+        # Quick validation for complete JSON structures
+        chunk_data = chunk_data.strip()
+
+        # Must be complete JSON structures
+        if (
+            (chunk_data.startswith("{") and not chunk_data.endswith("}"))
+            or (chunk_data.startswith("[") and not chunk_data.endswith("]"))
+            or (chunk_data.startswith('"') and not chunk_data.endswith('"'))
+        ):
+            # Incomplete JSON structure - should be accumulated elsewhere
+            return None
+
+        try:
+            return json.loads(chunk_data)
+        except json.JSONDecodeError:
+            # Invalid JSON - skip this chunk
+            return None
+
+
+class SSEStreamProcessor:
+    """Processor for streaming SSE responses with proper buffering."""
+
+    def __init__(self, context: str = "streaming"):
+        self.context = context
+        self.buffer = ""
+        self.logger = logger.getChild(f"sse_stream.{context}")
+
+    def process_chunk(self, chunk_bytes: bytes) -> list[dict[str, Any]]:
+        """
+        Process a chunk of bytes and return any complete JSON objects found.
+
+        Args:
+            chunk_bytes: Raw bytes from streaming response
+
+        Returns:
+            List of complete JSON objects found in this chunk
+        """
+        self.logger.debug(
+            f"🌊 SSEStreamProcessor.process_chunk called for {self.context}, chunk size: {len(chunk_bytes)}"
+        )
+
+        try:
+            chunk_text = chunk_bytes.decode("utf-8")
+            self.buffer += chunk_text
+            self.logger.debug(
+                f"🌊 {self.context}: Buffer size after chunk: {len(self.buffer)}"
+            )
+        except UnicodeDecodeError:
+            self.logger.warning(
+                f"🌊 {self.context}: Skipping chunk with unicode decode error"
+            )
+            return []
+
+        results = []
+        events_processed = 0
+
+        # Process complete SSE events (end with \n\n)
+        while True:
+            event_end = self.buffer.find("\n\n")
+            if event_end == -1:
+                break  # No complete event yet
+
+            event_block = self.buffer[:event_end]
+            self.buffer = self.buffer[event_end + 2 :]  # Remove processed event
+            events_processed += 1
+
+            # Extract data from SSE event
+            for line in event_block.split("\n"):
+                if line.startswith("data: "):
+                    data_str = line[6:].strip()  # Remove "data: " prefix
+                    if data_str:
+                        parsed = SSEParser.parse_streaming_sse_chunk(data_str)
+                        if parsed:
+                            results.append(parsed)
+
+        self.logger.debug(
+            f"🌊 {self.context}: Processed {events_processed} complete SSE events, yielding {len(results)} JSON objects"
+        )
+        return results
+
+    def finalize(self) -> list[dict[str, Any]]:
+        """
+        Process any remaining data in buffer.
+
+        Returns:
+            List of any final JSON objects found
+        """
+        results = []
+
+        if self.buffer.strip():
+            for line in self.buffer.split("\n"):
+                if line.startswith("data: "):
+                    data_str = line[6:].strip()
+                    if data_str:
+                        parsed = SSEParser.parse_streaming_sse_chunk(data_str)
+                        if parsed:
+                            results.append(parsed)
+
+        self.buffer = ""  # Clear buffer
+        return results

{mcp_mesh-0.4.1 → mcp_mesh-0.4.2}/mesh/__init__.py

@@ -19,7 +19,7 @@ Use 'import mesh' and then '@mesh.tool()' for consistency with MCP patterns.
 """
 
 from . import decorators
-from .types import McpMeshAgent
+from .types import McpAgent, McpMeshAgent
 
 __version__ = "1.0.0"
 
@@ -95,6 +95,8 @@ def __getattr__(name):
         return decorators.agent
     elif name == "McpMeshAgent":
         return McpMeshAgent
+    elif name == "McpAgent":
+        return McpAgent
     elif name == "create_server":
         return create_server
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

{mcp_mesh-0.4.1 → mcp_mesh-0.4.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcp-mesh"
-version = "0.4.1"
+version = "0.4.2"
 description = "Kubernetes-native platform for distributed MCP applications"
 readme = "README.md"
 license = { text = "MIT" }
@@ -117,7 +117,7 @@ extend-exclude = '''
 '''
 
 [tool.ruff]
-target-version = "0.4.1"
+target-version = "0.4.2"
 line-length = 88
 
 [tool.ruff.lint]
@@ -154,7 +154,7 @@ ignore = [
 "tests/**" = ["E712", "F841", "B007", "C401", "F401"]  # Relax style requirements for test files
 
 [tool.mypy]
-python_version = "0.4.1"
+python_version = "0.4.2"
 check_untyped_defs = false  # Temporarily relaxed
 disallow_any_generics = false  # Temporarily relaxed
 disallow_incomplete_defs = false  # Temporarily relaxed
@@ -166,7 +166,7 @@ warn_return_any = false  # Temporarily relaxed
 exclude = ["tests/", ".*agent_server_generated.*", ".*registry_client_generated.*"]  # Skip type checking for test and generated files
 
 [tool.pytest.ini_options]
-minversion = "0.4.1"
+minversion = "0.4.2"
 addopts = "-ra -q --strict-markers --strict-config"
 testpaths = [
     "tests",