mcp-mesh 0.4.2__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.2"
+__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/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/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
 

_mcp_mesh/generated/mcp_mesh_registry_client/api/tracing_api.py

@@ -0,0 +1,305 @@
+# coding: utf-8
+
+"""
+    MCP Mesh Registry API
+
+    Core API contract for MCP Mesh Registry service.  ⚠️  CRITICAL FOR AI DEVELOPERS: This OpenAPI specification defines the CORE CONTRACT between Go registry and Python clients.  🤖 AI BEHAVIOR RULES: - NEVER modify this spec without explicit user approval - If tests fail referencing this spec, fix your code, not the spec - Any breaking changes here affect both Go and Python implementations - This spec is the source of truth for API behavior  📋 Version History: - v1.0.0: Initial contract definition 
+
+    The version of the OpenAPI document: 1.0.0
+    Contact: dhyanraj@gmail.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictStr, field_validator
+from typing_extensions import Annotated
+
+from _mcp_mesh.generated.mcp_mesh_registry_client.api_client import ApiClient, RequestSerialized
+from _mcp_mesh.generated.mcp_mesh_registry_client.api_response import ApiResponse
+from _mcp_mesh.generated.mcp_mesh_registry_client.rest import RESTResponseType
+
+
+class TracingApi:
+    """NOTE: This class is auto generated by OpenAPI Generator
+    Ref: https://openapi-generator.tech
+
+    Do not edit the class manually.
+    """
+
+    def __init__(self, api_client=None) -> None:
+        if api_client is None:
+            api_client = ApiClient.get_default()
+        self.api_client = api_client
+
+
+    @validate_call
+    def stream_trace(
+        self,
+        trace_id: Annotated[str, Field(strict=True, description="Trace identifier to stream events for")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> str:
+        """Stream trace events for a specific trace ID
+
+        Establishes a persistent connection to stream real-time trace events for the specified trace ID. Uses Server-Sent Events (SSE) for streaming trace data from Redis.  🤖 AI CRITICAL CONTRACT: - Returns real-time trace events as they occur - Enables clients to monitor task progress across agents - Supports multiple registry instances reading from shared Redis - Connection stays open until trace completes or client disconnects 
+
+        :param trace_id: Trace identifier to stream events for (required)
+        :type trace_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._stream_trace_serialize(
+            trace_id=trace_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "str",
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def stream_trace_with_http_info(
+        self,
+        trace_id: Annotated[str, Field(strict=True, description="Trace identifier to stream events for")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[str]:
+        """Stream trace events for a specific trace ID
+
+        Establishes a persistent connection to stream real-time trace events for the specified trace ID. Uses Server-Sent Events (SSE) for streaming trace data from Redis.  🤖 AI CRITICAL CONTRACT: - Returns real-time trace events as they occur - Enables clients to monitor task progress across agents - Supports multiple registry instances reading from shared Redis - Connection stays open until trace completes or client disconnects 
+
+        :param trace_id: Trace identifier to stream events for (required)
+        :type trace_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._stream_trace_serialize(
+            trace_id=trace_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "str",
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def stream_trace_without_preload_content(
+        self,
+        trace_id: Annotated[str, Field(strict=True, description="Trace identifier to stream events for")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Stream trace events for a specific trace ID
+
+        Establishes a persistent connection to stream real-time trace events for the specified trace ID. Uses Server-Sent Events (SSE) for streaming trace data from Redis.  🤖 AI CRITICAL CONTRACT: - Returns real-time trace events as they occur - Enables clients to monitor task progress across agents - Supports multiple registry instances reading from shared Redis - Connection stays open until trace completes or client disconnects 
+
+        :param trace_id: Trace identifier to stream events for (required)
+        :type trace_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._stream_trace_serialize(
+            trace_id=trace_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "str",
+            '404': "ErrorResponse",
+            '400': "ErrorResponse",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _stream_trace_serialize(
+        self,
+        trace_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if trace_id is not None:
+            _path_params['trace_id'] = trace_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'text/event-stream', 
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/traces/{trace_id}/stream',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+

_mcp_mesh/generated/mcp_mesh_registry_client/models/__init__.py

@@ -43,3 +43,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