mcp-mesh 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

_mcp_mesh/__init__.py

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

_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/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/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/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/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.0.dist-info → mcp_mesh-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.4.0
+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.0.dist-info → mcp_mesh-0.4.2.dist-info}/RECORD

@@ -1,11 +1,11 @@
-_mcp_mesh/__init__.py,sha256=PNSqEqZWQkoWcxSu81zaMowsyvY9td88B1VWLMjTDoc,2103
+_mcp_mesh/__init__.py,sha256=4YFRyw3RwxKNKMPP9rmT4enhGSe8ceAG8AgOKbU5ITY,2103
 _mcp_mesh/engine/__init__.py,sha256=o4axdnjeUnUTsukZFacMNnxd6LRX2D46qJzMzUfEZUI,3259
-_mcp_mesh/engine/async_mcp_client.py,sha256=uD3s9dDWNQ9SZiuiQm0C6BSjtgn1OqgMnh3oc_D6Zz4,7015
+_mcp_mesh/engine/async_mcp_client.py,sha256=IdcCsswl1WXnzIWGb686Morgjf4CROm411EiDeE0cac,6308
 _mcp_mesh/engine/decorator_registry.py,sha256=w_-10yBkgYAu_u-SUrTaZcCOv1t_MqlHPg0vFQGdy2I,15506
 _mcp_mesh/engine/dependency_injector.py,sha256=RbXa9ap1PYRc7G3-ZnJkWQOcibQfecQDGIU-_7O2Raw,17310
-_mcp_mesh/engine/full_mcp_proxy.py,sha256=M6XH5aVPwbZfaRIMY7DPJWm3T-8cmA6maP9fdMrakr0,25134
+_mcp_mesh/engine/full_mcp_proxy.py,sha256=fJyU5mbmvqDXaSgnT00eVb9EnumTHP2QMwAPB_IfIQc,25301
 _mcp_mesh/engine/http_wrapper.py,sha256=NFKCcUPwSLeyLuTc1TwWpBRrlsbgkzBoiZiZixhOias,21453
-_mcp_mesh/engine/mcp_client_proxy.py,sha256=IzWE5uu8rRbaJvDcQvUk6hqeI35Mm5KVSBmJQ1g0Ubo,18336
+_mcp_mesh/engine/mcp_client_proxy.py,sha256=RpHdwCjC6mwiZ5idv7h8OchFRbufyC2NLaHxzU2kKyo,17623
 _mcp_mesh/engine/self_dependency_proxy.py,sha256=OkKt0-B_ADnJlWtHiHItoZCBZ7Su0iz2unEPFfXvrs4,3302
 _mcp_mesh/engine/session_aware_client.py,sha256=mc9eh-aCvUvfllORiXTf_X8_jPqV-32QdWKlr8tHLkU,10600
 _mcp_mesh/engine/session_manager.py,sha256=MCr0_fXBaUjXM51WU5EhDkiGvBdfzYQFVNb9DCXXL0A,10418
@@ -70,7 +70,7 @@ _mcp_mesh/pipeline/startup/__init__.py,sha256=_Y25DgT9eYJ_7Qe7x1Z7y4VFUIaFEmCBS9
 _mcp_mesh/pipeline/startup/configuration.py,sha256=6LRLIxrqFMU76qrBb6GjGknUlKPZZ9iqOlxE7F9ZhLs,2808
 _mcp_mesh/pipeline/startup/decorator_collection.py,sha256=RHC6MHtfP9aP0hZ-IJjISZu72e0Pml3LU0qr7dc284w,2294
 _mcp_mesh/pipeline/startup/fastapiserver_setup.py,sha256=pQIrEc70qeWP732S9LF5A2qWq0CZ5wK-bxls7AjX_2o,33346
-_mcp_mesh/pipeline/startup/fastmcpserver_discovery.py,sha256=fl-ZvCFySfs49NF6DQO1U-msNPcs2NBIzDI1UWQYiEc,10246
+_mcp_mesh/pipeline/startup/fastmcpserver_discovery.py,sha256=ktsE9EZYdyZbCtCKB6HVdzGFMQ0E9n0-7I55LRO99sE,10270
 _mcp_mesh/pipeline/startup/heartbeat_loop.py,sha256=0IX2Q-OJvTVsNILUKxl7v3-BM8DdAW3UB-W-Z2gAWrc,3861
 _mcp_mesh/pipeline/startup/heartbeat_preparation.py,sha256=v3Fl0PvW5s7Ib_Cy7WtXA7gDvsFGiz54a-IlQRTcLPg,10410
 _mcp_mesh/pipeline/startup/startup_orchestrator.py,sha256=r0po5cQKe9F5nO6ey5PmYGjYKHe5u8pNEFy7Da0Lh5w,17835
@@ -83,16 +83,17 @@ _mcp_mesh/shared/fast_heartbeat_status.py,sha256=OquEsX9ZTbxY1lIsll0Mbb2KDzSJD76
 _mcp_mesh/shared/host_resolver.py,sha256=ycs6gXnI1zJX5KiqiLJPX5GkHX8r4j8NMHQOlG2J2X8,2964
 _mcp_mesh/shared/logging_config.py,sha256=m_eW5ub01mjjoLdF55lv9JwSK9y52rqpVTRN8jNz_6s,2381
 _mcp_mesh/shared/registry_client_wrapper.py,sha256=d8yL-MiCrQr_WYdRFStOd531qaLv9kZjh0zJAmCJ-Cc,16976
+_mcp_mesh/shared/sse_parser.py,sha256=OEPnfL9xL3rsjQrbyvfUO82WljPSDeO6Z61uUwN1NAo,8035
 _mcp_mesh/shared/support_types.py,sha256=k-ICF_UwDkHxQ1D5LwFZrp-UrNb4E5dzw02CRuLW9iI,7264
 _mcp_mesh/tracing/agent_context_helper.py,sha256=XR3OyVT40lWyXaSWYBWdOhs0ZqTj3Xa49BSG8EUzrjI,4595
 _mcp_mesh/tracing/context.py,sha256=yZtTZXVKltX2BUBrWeeNfQ8Y4n6L_2ywFVlFP-wU9og,2353
 _mcp_mesh/tracing/execution_tracer.py,sha256=rAyAhSMy7Mr5KpZcQUfDcQ5QW8bj-g-H6wVB3tvkkR4,6852
 _mcp_mesh/tracing/redis_metadata_publisher.py,sha256=5U5GojBFYZdxJJ1RvmdxXHC-VuPQz4kMla6n0xdZxKc,5371
 _mcp_mesh/tracing/trace_context_helper.py,sha256=xPDygKrXcoJbrr7013Av_I0ajammWEq68ihdP7DZ-Zo,6072
-mesh/__init__.py,sha256=yU-xxDxSBNW2eVXIo0DazPIctkkUc-YGLV0k-liPD4g,3108
+mesh/__init__.py,sha256=XtquSwwLeVJwQZjg8jO4_vRNSQZtWo_Mv2tixI1_Yzg,3171
 mesh/decorators.py,sha256=_WLqfMXQgi_4Xarci-sRa3zxqKWIf-2HYELh9MAitYY,18397
 mesh/types.py,sha256=cR8oRKHZjZXNkbHPYdRfLNDyCE4yEz_Fbrmdc08NY6k,8775
-mcp_mesh-0.4.0.dist-info/METADATA,sha256=xKBoxssSk35hneJgSRyztXSIH-Ei3OHPtMixJsB4nqs,4879
-mcp_mesh-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_mesh-0.4.0.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.4.0.dist-info/RECORD,,
+mcp_mesh-0.4.2.dist-info/METADATA,sha256=clX_rcn6hz6Q3wSbA4Wx2fkqNSm4LWmbOVL0nhojKA8,4879
+mcp_mesh-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_mesh-0.4.2.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
+mcp_mesh-0.4.2.dist-info/RECORD,,

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}'")