mcp-mesh 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

_mcp_mesh/__init__.py

@@ -31,7 +31,7 @@ from .engine.decorator_registry import (
     get_decorator_stats,
 )
 
-__version__ = "0.4.1"
+__version__ = "0.5.0"
 
 # Store reference to runtime processor if initialized
 _runtime_processor = None
@@ -48,7 +48,7 @@ def initialize_runtime():
         # Legacy processor system has been replaced by pipeline architecture
 
         # Use pipeline-based runtime
-        from .pipeline.startup import start_runtime
+        from .pipeline.mcp_startup import start_runtime
 
         start_runtime()
 
@@ -60,7 +60,18 @@ def initialize_runtime():
 
 # Auto-initialize runtime if enabled
 if os.getenv("MCP_MESH_ENABLED", "true").lower() == "true":
-    initialize_runtime()
+    # Use debounced initialization instead of immediate MCP startup
+    # This allows the system to determine MCP vs API pipeline based on decorators
+    try:
+        from .pipeline.mcp_startup import start_runtime
+
+        # Start the debounced runtime (sets up coordinator, no immediate pipeline execution)
+        start_runtime()
+
+        sys.stderr.write("MCP Mesh debounced runtime initialized\n")
+    except Exception as e:
+        # Log but don't fail - allows graceful degradation
+        sys.stderr.write(f"MCP Mesh runtime initialization failed: {e}\n")
 
 
 __all__ = [

_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/dependency_injector.py

@@ -126,6 +126,9 @@ class DependencyInjector:
                 for func_id in self._dependency_mapping[name]:
                     if func_id in self._function_registry:
                         func = self._function_registry[func_id]
+                        logger.debug(
+                            f"🔄 UPDATING dependency '{name}' for {func_id} -> {func} at {hex(id(func))}"
+                        )
                         if hasattr(func, "_mesh_update_dependency"):
                             func._mesh_update_dependency(name, instance)
 
@@ -279,99 +282,180 @@ class DependencyInjector:
         # Capture logger in local scope to avoid NameError
         wrapper_logger = logger
 
-        @functools.wraps(func)
-        def dependency_wrapper(*args, **kwargs):
-            wrapper_logger.debug(
-                f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
+        # If no mesh positions to inject, create minimal wrapper for tracking
+        if not mesh_positions:
+            logger.debug(
+                f"🔧 No injection positions for {func.__name__}, creating minimal wrapper for tracking"
             )
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}")
-            wrapper_logger.debug(
-                f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+
+            @functools.wraps(func)
+            def minimal_wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+            # Add minimal metadata for compatibility
+            minimal_wrapper._mesh_injected_deps = {}
+            minimal_wrapper._mesh_dependencies = dependencies
+            minimal_wrapper._mesh_positions = mesh_positions
+            minimal_wrapper._mesh_parameter_types = get_agent_parameter_types(func)
+            minimal_wrapper._mesh_original_func = func
+
+            def update_dependency(name: str, instance: Any | None) -> None:
+                """No-op update for functions without injection positions."""
+                pass
+
+            minimal_wrapper._mesh_update_dependency = update_dependency
+
+            # Register this wrapper for dependency updates (even though it won't use them)
+            logger.debug(
+                f"🔧 REGISTERING minimal wrapper: {func_id} -> {minimal_wrapper} at {hex(id(minimal_wrapper))}"
             )
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}")
+            self._function_registry[func_id] = minimal_wrapper
+
+            return minimal_wrapper
 
-            # If no mesh positions to inject into, still do execution logging but call original function
-            if not mesh_positions:
+        # Determine if we need async wrapper
+        need_async_wrapper = inspect.iscoroutinefunction(func)
+
+        if need_async_wrapper:
+
+            @functools.wraps(func)
+            async def dependency_wrapper(*args, **kwargs):
                 wrapper_logger.debug(
-                    "🔧 DEPENDENCY_WRAPPER: No mesh positions, calling original with execution logging"
+                    f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
                 )
-                from ..tracing.execution_tracer import ExecutionTracer
-
-                return ExecutionTracer.trace_original_function(
-                    func._mesh_original_func, args, kwargs, wrapper_logger
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}"
                 )
 
-            # Get function signature
-            sig = inspect.signature(func)
-            params = list(sig.parameters.keys())
-            final_kwargs = kwargs.copy()
+                # We know mesh_positions is not empty since we checked above
 
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: params={params}")
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: original kwargs={kwargs}")
+                # Get function signature
+                sig = inspect.signature(func)
+                params = list(sig.parameters.keys())
+                final_kwargs = kwargs.copy()
 
-            # Inject dependencies as kwargs
-            injected_count = 0
-            for dep_index, param_position in enumerate(mesh_positions):
-                if dep_index < len(dependencies):
-                    dep_name = dependencies[dep_index]
-                    param_name = params[param_position]
+                wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: params={params}")
+                wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: original kwargs={kwargs}")
 
-                    wrapper_logger.debug(
-                        f"🔧 DEPENDENCY_WRAPPER: Processing dep {dep_index}: {dep_name} -> {param_name}"
-                    )
+                # Inject dependencies as kwargs
+                injected_count = 0
+                for dep_index, param_position in enumerate(mesh_positions):
+                    if dep_index < len(dependencies):
+                        dep_name = dependencies[dep_index]
+                        param_name = params[param_position]
 
-                    # Only inject if the parameter wasn't explicitly provided
-                    if (
-                        param_name not in final_kwargs
-                        or final_kwargs.get(param_name) is None
-                    ):
-                        # Get the dependency from wrapper's storage
-                        dependency = dependency_wrapper._mesh_injected_deps.get(
-                            dep_name
-                        )
                         wrapper_logger.debug(
-                            f"🔧 DEPENDENCY_WRAPPER: From wrapper storage: {dependency}"
+                            f"🔧 DEPENDENCY_WRAPPER: Processing dep {dep_index}: {dep_name} -> {param_name}"
                         )
 
-                        if dependency is None:
-                            dependency = self.get_dependency(dep_name)
+                        # Only inject if the parameter wasn't explicitly provided
+                        if (
+                            param_name not in final_kwargs
+                            or final_kwargs.get(param_name) is None
+                        ):
+                            # Get the dependency from wrapper's storage
+                            dependency = dependency_wrapper._mesh_injected_deps.get(
+                                dep_name
+                            )
                             wrapper_logger.debug(
-                                f"🔧 DEPENDENCY_WRAPPER: From global storage: {dependency}"
+                                f"🔧 DEPENDENCY_WRAPPER: From wrapper storage: {dependency}"
                             )
 
-                        final_kwargs[param_name] = dependency
-                        injected_count += 1
-                        wrapper_logger.debug(
-                            f"🔧 DEPENDENCY_WRAPPER: Injected {dep_name} as {param_name}"
-                        )
-                    else:
-                        wrapper_logger.debug(
-                            f"🔧 DEPENDENCY_WRAPPER: Skipping {param_name} - already provided"
-                        )
+                            if dependency is None:
+                                dependency = self.get_dependency(dep_name)
+                                wrapper_logger.debug(
+                                    f"🔧 DEPENDENCY_WRAPPER: From global storage: {dependency}"
+                                )
 
-            wrapper_logger.debug(
-                f"🔧 DEPENDENCY_WRAPPER: Injected {injected_count} dependencies"
-            )
-            wrapper_logger.debug(f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}")
-
-            # ===== EXECUTE WITH DEPENDENCY INJECTION AND TRACING =====
-            from ..tracing.execution_tracer import ExecutionTracer
-
-            # Use helper class for clean execution tracing
-            result = ExecutionTracer.trace_function_execution(
-                func._mesh_original_func,
-                args,
-                final_kwargs,
-                dependencies,
-                mesh_positions,
-                injected_count,
-                wrapper_logger,
-            )
+                            final_kwargs[param_name] = dependency
+                            injected_count += 1
+                            wrapper_logger.debug(
+                                f"🔧 DEPENDENCY_WRAPPER: Injected {dep_name} as {param_name}"
+                            )
+                        else:
+                            wrapper_logger.debug(
+                                f"🔧 DEPENDENCY_WRAPPER: Skipping {param_name} - already provided"
+                            )
 
-            wrapper_logger.debug(
-                f"🔧 DEPENDENCY_WRAPPER: Original returned: {type(result)}"
-            )
-            return result
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: Injected {injected_count} dependencies"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: final_kwargs={final_kwargs}"
+                )
+
+                # ===== EXECUTE WITH DEPENDENCY INJECTION =====
+                # Call the original function with injected dependencies
+                original_func = func._mesh_original_func
+
+                # Check if the function is async and handle accordingly
+                if inspect.iscoroutinefunction(original_func):
+                    # For async functions, await the result directly
+                    result = await original_func(*args, **final_kwargs)
+                else:
+                    # For sync functions, call directly
+                    result = original_func(*args, **final_kwargs)
+
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: Original returned: {type(result)}"
+                )
+                return result
+
+        else:
+            # Create sync wrapper for sync functions without dependencies
+            @functools.wraps(func)
+            def dependency_wrapper(*args, **kwargs):
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: Function {func.__name__} called"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: args={args}, kwargs={kwargs}"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: mesh_positions={mesh_positions}"
+                )
+                wrapper_logger.debug(
+                    f"🔧 DEPENDENCY_WRAPPER: dependencies={dependencies}"
+                )
+
+                # We know mesh_positions is not empty since we checked above
+
+                # Handle dependency injection for sync functions
+                sig = inspect.signature(func)
+                params = list(sig.parameters.keys())
+                final_kwargs = kwargs.copy()
+
+                # Inject dependencies as kwargs
+                injected_count = 0
+                for dep_index, param_position in enumerate(mesh_positions):
+                    if dep_index < len(dependencies):
+                        dep_name = dependencies[dep_index]
+                        param_name = params[param_position]
+
+                        # Only inject if the parameter wasn't explicitly provided
+                        if (
+                            param_name not in final_kwargs
+                            or final_kwargs.get(param_name) is None
+                        ):
+                            # Get the dependency from wrapper's storage
+                            dependency = dependency_wrapper._mesh_injected_deps.get(
+                                dep_name
+                            )
+
+                            if dependency is None:
+                                dependency = self.get_dependency(dep_name)
+
+                            final_kwargs[param_name] = dependency
+                            injected_count += 1
+
+                # Call the original function with injected dependencies
+                return func._mesh_original_func(*args, **final_kwargs)
 
         # Store dependency state on wrapper
         dependency_wrapper._mesh_injected_deps = {}
@@ -399,6 +483,9 @@ class DependencyInjector:
         dependency_wrapper._mesh_original_func = func
 
         # Register this wrapper for dependency updates
+        logger.debug(
+            f"🔧 REGISTERING in function_registry: {func_id} -> {dependency_wrapper} at {hex(id(dependency_wrapper))}"
+        )
         self._function_registry[func_id] = dependency_wrapper
 
         # Return the wrapper (which FastMCP will register)

_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/generated/.openapi-generator/FILES

@@ -2,6 +2,7 @@ mcp_mesh_registry_client/__init__.py
 mcp_mesh_registry_client/api/__init__.py
 mcp_mesh_registry_client/api/agents_api.py
 mcp_mesh_registry_client/api/health_api.py
+mcp_mesh_registry_client/api/tracing_api.py
 mcp_mesh_registry_client/api_client.py
 mcp_mesh_registry_client/api_response.py
 mcp_mesh_registry_client/configuration.py
@@ -35,5 +36,6 @@ mcp_mesh_registry_client/models/registration_response.py
 mcp_mesh_registry_client/models/rich_dependency.py
 mcp_mesh_registry_client/models/root_response.py
 mcp_mesh_registry_client/models/standardized_dependency.py
+mcp_mesh_registry_client/models/trace_event.py
 mcp_mesh_registry_client/py.typed
 mcp_mesh_registry_client/rest.py

_mcp_mesh/generated/mcp_mesh_registry_client/__init__.py

@@ -36,6 +36,7 @@ __version__ = "1.0.0"
 # import apis into sdk package
 from _mcp_mesh.generated.mcp_mesh_registry_client.api.agents_api import AgentsApi
 from _mcp_mesh.generated.mcp_mesh_registry_client.api.health_api import HealthApi
+from _mcp_mesh.generated.mcp_mesh_registry_client.api.tracing_api import TracingApi
 
 # import ApiClient
 from _mcp_mesh.generated.mcp_mesh_registry_client.api_response import ApiResponse
@@ -77,3 +78,4 @@ from _mcp_mesh.generated.mcp_mesh_registry_client.models.registration_response i
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.rich_dependency import RichDependency
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.root_response import RootResponse
 from _mcp_mesh.generated.mcp_mesh_registry_client.models.standardized_dependency import StandardizedDependency
+from _mcp_mesh.generated.mcp_mesh_registry_client.models.trace_event import TraceEvent

_mcp_mesh/generated/mcp_mesh_registry_client/api/__init__.py

@@ -3,4 +3,5 @@
 # import apis into api package
 from _mcp_mesh.generated.mcp_mesh_registry_client.api.agents_api import AgentsApi
 from _mcp_mesh.generated.mcp_mesh_registry_client.api.health_api import HealthApi
+from _mcp_mesh.generated.mcp_mesh_registry_client.api.tracing_api import TracingApi