mcp-mesh 0.8.0b9__py3-none-any.whl → 0.9.0b1__py3-none-any.whl

_mcp_mesh/engine/provider_handlers/gemini_handler.py

@@ -1,15 +1,22 @@
 """
 Gemini/Google provider handler.
 
-Optimized for Gemini models (Gemini 2.0 Flash, Gemini 1.5 Pro, etc.)
+Optimized for Gemini models (Gemini 3 Flash, Gemini 3 Pro, Gemini 2.0 Flash, etc.)
 using Google's best practices for tool calling and structured output.
 
 Features:
-- Native structured output via response_format (similar to OpenAI)
+- Mixed structured output strategy based on tool presence:
+  - STRICT mode (response_format) when NO tools are present
+  - HINT mode (prompt-based JSON hints) when tools ARE present
 - Native function calling support
 - Support for Gemini 2.x and 3.x models
 - Large context windows (up to 2M tokens)
 
+Note:
+- Gemini 3 + response_format + tools causes non-deterministic infinite tool loops,
+  so we avoid response_format when tools are present and use HINT mode instead.
+- STRICT mode (response_format) is only used for tool-free requests.
+
 Reference:
 - https://docs.litellm.ai/docs/providers/gemini
 - https://ai.google.dev/gemini-api/docs
@@ -24,8 +31,13 @@ from .base_provider_handler import (
     BASE_TOOL_INSTRUCTIONS,
     BaseProviderHandler,
     make_schema_strict,
+    sanitize_schema_for_structured_output,
 )
 
+OUTPUT_MODE_TEXT = "text"
+OUTPUT_MODE_STRICT = "strict"
+OUTPUT_MODE_HINT = "hint"
+
 logger = logging.getLogger(__name__)
 
 
@@ -34,24 +46,23 @@ class GeminiHandler(BaseProviderHandler):
     Provider handler for Google Gemini models.
 
     Gemini Characteristics:
-    - Native structured output via response_format parameter (LiteLLM translates)
+    - Mixed structured output strategy:
+      - STRICT mode (response_format) when NO tools are present
+      - HINT mode (prompt-based JSON hints) when tools ARE present
+    - Gemini 3 + response_format + tools causes non-deterministic infinite tool loops,
+      so we avoid combining them.
     - Native function calling support
     - Large context windows (1M-2M tokens)
     - Multimodal support (text, images, video, audio)
     - Works well with concise, focused prompts
 
-    Key Similarities with OpenAI:
-    - Uses response_format for structured output (via LiteLLM translation)
-    - Native function calling format
-    - Similar schema enforcement requirements
-
     Supported Models (via LiteLLM):
+    - gemini/gemini-3-flash-preview (reasoning support)
+    - gemini/gemini-3-pro-preview (advanced reasoning)
     - gemini/gemini-2.0-flash (fast, efficient)
     - gemini/gemini-2.0-flash-lite (fastest, most efficient)
     - gemini/gemini-1.5-pro (high capability)
     - gemini/gemini-1.5-flash (balanced)
-    - gemini/gemini-3-flash-preview (reasoning support)
-    - gemini/gemini-3-pro-preview (advanced reasoning)
 
     Reference:
     https://docs.litellm.ai/docs/providers/gemini
@@ -60,11 +71,29 @@ class GeminiHandler(BaseProviderHandler):
     def __init__(self):
         """Initialize Gemini handler."""
         super().__init__(vendor="gemini")
+        # Store output schema for use in format_system_prompt (set by apply_structured_output)
+        self._pending_output_schema: dict[str, Any] | None = None
+        self._pending_output_type_name: str | None = None
+
+    def determine_output_mode(self, output_type, override_mode=None):
+        """Determine output mode for Gemini.
+
+        Gemini 3 supports native response_format with tools.
+        Uses STRICT mode (response_format) for all schema types.
+        TEXT mode for string return types.
+        """
+        if override_mode:
+            return override_mode
+        if output_type is str:
+            return OUTPUT_MODE_TEXT
+        if isinstance(output_type, type) and issubclass(output_type, BaseModel):
+            return OUTPUT_MODE_STRICT
+        return OUTPUT_MODE_STRICT
 
     def prepare_request(
         self,
         messages: list[dict[str, Any]],
-        tools: Optional[list[dict[str, Any]]],
+        tools: list[dict[str, Any]] | None,
         output_type: type,
         **kwargs: Any,
     ) -> dict[str, Any]:
@@ -72,8 +101,8 @@ class GeminiHandler(BaseProviderHandler):
         Prepare request parameters for Gemini API via LiteLLM.
 
         Gemini Strategy:
-        - Use response_format parameter for structured JSON output
-        - LiteLLM handles translation to Gemini's native format
+        - Use native response_format with strict schema (Gemini 3+)
+        - Store schema for HINT fallback in format_system_prompt
         - Skip structured output for str return types (text mode)
 
         Args:
@@ -98,46 +127,60 @@ class GeminiHandler(BaseProviderHandler):
 
         # Skip structured output for str return type (text mode)
         if output_type is str:
+            self._pending_output_schema = None
+            self._pending_output_type_name = None
             return request_params
 
-        # Only add response_format for Pydantic models
-        if not (isinstance(output_type, type) and issubclass(output_type, BaseModel)):
-            return request_params
-
-        # Add response_format for structured output
-        # LiteLLM translates this to Gemini's native format
-        schema = output_type.model_json_schema()
-
-        # Transform schema for strict mode compliance
-        # Gemini requires additionalProperties: false and all properties in required
-        schema = make_schema_strict(schema, add_all_required=True)
-
-        # Gemini structured output format (via LiteLLM)
-        request_params["response_format"] = {
-            "type": "json_schema",
-            "json_schema": {
-                "name": output_type.__name__,
-                "schema": schema,
-                "strict": True,  # Enforce schema compliance
-            },
-        }
+        # Only store schema for Pydantic models
+        if isinstance(output_type, type) and issubclass(output_type, BaseModel):
+            schema = output_type.model_json_schema()
+            schema = sanitize_schema_for_structured_output(schema)
+
+            # Store for HINT mode in format_system_prompt (always needed as fallback)
+            self._pending_output_schema = schema
+            self._pending_output_type_name = output_type.__name__
+
+            # Only use response_format when NO tools present
+            # Gemini 3 + response_format + tools causes non-deterministic infinite tool loops
+            if not tools:
+                strict_schema = make_schema_strict(schema, add_all_required=True)
+                request_params["response_format"] = {
+                    "type": "json_schema",
+                    "json_schema": {
+                        "name": output_type.__name__,
+                        "schema": strict_schema,
+                        "strict": True,
+                    },
+                }
+                logger.debug(
+                    "Gemini: Using response_format with strict schema for '%s' (no tools)",
+                    output_type.__name__,
+                )
+            else:
+                logger.debug(
+                    "Gemini: Using HINT mode for '%s' (tools present, response_format skipped)",
+                    output_type.__name__,
+                )
+        else:
+            self._pending_output_schema = None
+            self._pending_output_type_name = None
 
         return request_params
 
     def format_system_prompt(
         self,
         base_prompt: str,
-        tool_schemas: Optional[list[dict[str, Any]]],
+        tool_schemas: list[dict[str, Any]] | None,
         output_type: type,
     ) -> str:
         """
-        Format system prompt for Gemini (concise approach).
+        Format system prompt for Gemini with structured output support.
 
         Gemini Strategy:
         1. Use base prompt as-is
         2. Add tool calling instructions if tools present
-        3. Minimal JSON instructions (response_format handles structure)
-        4. Keep prompt concise - Gemini works well with clear, direct prompts
+        3. STRICT mode: Brief note (response_format handles enforcement)
+        4. HINT mode fallback: Detailed JSON output instructions with example structure
 
         Args:
             base_prompt: Base system prompt
@@ -153,13 +196,77 @@ class GeminiHandler(BaseProviderHandler):
         if tool_schemas:
             system_content += BASE_TOOL_INSTRUCTIONS
 
-        # Skip JSON note for str return type (text mode)
-        if output_type is str:
+        # Get the output schema (may have been set by apply_structured_output or prepare_request)
+        # Check pending schema FIRST - it may be set even when output_type is str (delegate path)
+        output_schema = self._pending_output_schema
+        output_type_name = self._pending_output_type_name
+
+        # Fall back to output_type if no pending schema AND output_type is Pydantic model
+        if output_schema is None:
+            if output_type is str:
+                # No schema and str return type - skip JSON instructions
+                return system_content
+            elif isinstance(output_type, type) and issubclass(output_type, BaseModel):
+                output_schema = sanitize_schema_for_structured_output(
+                    output_type.model_json_schema()
+                )
+                output_type_name = output_type.__name__
+
+        # Determine output mode
+        determined_mode = self.determine_output_mode(output_type)
+
+        # STRICT mode: Brief note (response_format handles enforcement)
+        # But only when no tools - with tools we use HINT mode
+        if determined_mode == OUTPUT_MODE_STRICT and not tool_schemas:
+            system_content += f"\n\nYour final response will be structured as JSON matching the {output_type_name} format."
             return system_content
 
-        # Add brief JSON note (response_format handles enforcement)
-        if isinstance(output_type, type) and issubclass(output_type, BaseModel):
-            system_content += f"\n\nYour final response will be structured as JSON matching the {output_type.__name__} format."
+        # HINT mode fallback: Detailed JSON instructions
+        if output_schema is not None:
+            system_content += "\n\nOUTPUT FORMAT:\n"
+
+            # Add DECISION GUIDE if tools are available
+            if tool_schemas:
+                system_content += "DECISION GUIDE:\n"
+                system_content += "- If your answer requires real-time data (weather, calculations, etc.), call the appropriate tool FIRST, then format your response as JSON.\n"
+                system_content += "- If your answer is general knowledge (like facts, explanations, definitions), directly return your response as JSON WITHOUT calling tools.\n\n"
+
+            system_content += "Your FINAL response must be ONLY valid JSON (no markdown, no code blocks) with this exact structure:\n"
+            system_content += "{\n"
+
+            # Build example showing expected structure with descriptions
+            properties = output_schema.get("properties", {})
+            prop_items = list(properties.items())
+            for i, (prop_name, prop_schema) in enumerate(prop_items):
+                prop_type = prop_schema.get("type", "string")
+                prop_desc = prop_schema.get("description", "")
+
+                # Show example value based on type
+                if prop_type == "string":
+                    example_value = f'"<your {prop_name} here>"'
+                elif prop_type in ("number", "integer"):
+                    example_value = "0"
+                elif prop_type == "array":
+                    example_value = '["item1", "item2"]'
+                elif prop_type == "boolean":
+                    example_value = "true"
+                elif prop_type == "object":
+                    example_value = "{}"
+                else:
+                    example_value = "..."
+
+                # Add comma for all but last property
+                comma = "," if i < len(prop_items) - 1 else ""
+                # Include description as comment if available
+                if prop_desc:
+                    system_content += (
+                        f'  "{prop_name}": {example_value}{comma}  // {prop_desc}\n'
+                    )
+                else:
+                    system_content += f'  "{prop_name}": {example_value}{comma}\n'
+
+            system_content += "}\n\n"
+            system_content += "Return ONLY the JSON object with actual values. Do not include the schema definition, markdown formatting, or code blocks."
 
         return system_content
 
@@ -171,11 +278,74 @@ class GeminiHandler(BaseProviderHandler):
             Capability flags for Gemini
         """
         return {
-            "native_tool_calling": True,  # Gemini has native function calling
-            "structured_output": True,  # Supports structured output via response_format
-            "streaming": True,  # Supports streaming
-            "vision": True,  # Gemini supports multimodal (images, video, audio)
+            "native_tool_calling": True,
+            "structured_output": True,  # Via native response_format (Gemini 3+)
+            "streaming": True,
+            "vision": True,
             "json_mode": True,  # Native JSON mode via response_format
-            "large_context": True,  # Up to 2M tokens context window
+            "large_context": True,
         }
 
+    def apply_structured_output(
+        self,
+        output_schema: dict[str, Any],
+        output_type_name: str | None,
+        model_params: dict[str, Any],
+    ) -> dict[str, Any]:
+        """
+        Apply Gemini-specific structured output for mesh delegation.
+
+        Uses HINT mode (prompt injection) because mesh delegation always involves
+        tools, and Gemini 3 + response_format + tools causes infinite tool loops.
+        """
+        sanitized_schema = sanitize_schema_for_structured_output(output_schema)
+
+        # Store for format_system_prompt
+        self._pending_output_schema = sanitized_schema
+        self._pending_output_type_name = output_type_name
+
+        # Inject HINT instructions into system messages
+        # (mesh delegation always has tools, so we can't use response_format)
+        messages = model_params.get("messages", [])
+        for msg in messages:
+            if msg.get("role") == "system":
+                base_content = msg.get("content", "")
+                # Build hint instructions
+                hint_text = "\n\nOUTPUT FORMAT:\n"
+                hint_text += "Your FINAL response must be ONLY valid JSON (no markdown, no code blocks) with this exact structure:\n"
+                hint_text += "{\n"
+                properties = sanitized_schema.get("properties", {})
+                prop_items = list(properties.items())
+                for i, (prop_name, prop_schema) in enumerate(prop_items):
+                    prop_type = prop_schema.get("type", "string")
+                    if prop_type == "string":
+                        example_value = f'"<your {prop_name} here>"'
+                    elif prop_type in ("number", "integer"):
+                        example_value = "0"
+                    elif prop_type == "array":
+                        example_value = '["item1", "item2"]'
+                    elif prop_type == "boolean":
+                        example_value = "true"
+                    elif prop_type == "object":
+                        example_value = "{}"
+                    else:
+                        example_value = "..."
+                    comma = "," if i < len(prop_items) - 1 else ""
+                    prop_desc = prop_schema.get("description", "")
+                    if prop_desc:
+                        hint_text += (
+                            f'  "{prop_name}": {example_value}{comma}  // {prop_desc}\n'
+                        )
+                    else:
+                        hint_text += f'  "{prop_name}": {example_value}{comma}\n'
+                hint_text += "}\n\n"
+                hint_text += "Return ONLY the JSON object with actual values. Do not include the schema definition, markdown formatting, or code blocks."
+
+                msg["content"] = base_content + hint_text
+                break
+
+        logger.info(
+            "Gemini hint mode for '%s' (mesh delegation, schema in prompt)",
+            output_type_name or "Response",
+        )
+        return model_params

_mcp_mesh/engine/provider_handlers/generic_handler.py

@@ -160,3 +160,34 @@ TOOL CALLING RULES:
             "vision": False,  # Conservative - not all models support vision
             "json_mode": False,  # Conservative - use prompt-based JSON instead
         }
+
+    def apply_structured_output(
+        self,
+        output_schema: dict[str, Any],
+        output_type_name: Optional[str],
+        model_params: dict[str, Any],
+    ) -> dict[str, Any]:
+        """
+        Apply structured output for generic vendors.
+
+        Generic strategy: Don't use response_format since not all vendors support it.
+        The consumer should rely on prompt-based instructions instead.
+
+        Args:
+            output_schema: JSON schema dict from consumer
+            output_type_name: Name of the output type
+            model_params: Current model parameters dict
+
+        Returns:
+            Unmodified model_params (no response_format added)
+        """
+        # Don't add response_format - generic vendors may not support it
+        # The consumer's system prompt should include JSON instructions
+        import logging
+
+        logger = logging.getLogger(__name__)
+        logger.debug(
+            f"⚠️ Generic handler: skipping response_format for '{output_type_name}' "
+            f"(vendor '{self.vendor}' may not support structured output)"
+        )
+        return model_params

_mcp_mesh/engine/provider_handlers/openai_handler.py

@@ -13,6 +13,7 @@ from .base_provider_handler import (
     BASE_TOOL_INSTRUCTIONS,
     BaseProviderHandler,
     make_schema_strict,
+    sanitize_schema_for_structured_output,
 )
 
 
@@ -96,6 +97,9 @@ class OpenAIHandler(BaseProviderHandler):
             # rather than relying on prompt instructions alone
             schema = output_type.model_json_schema()
 
+            # Sanitize schema first to remove unsupported validation keywords (minimum, maximum, etc.)
+            schema = sanitize_schema_for_structured_output(schema)
+
             # Transform schema for OpenAI strict mode
             # OpenAI requires additionalProperties: false and all properties in required
             schema = make_schema_strict(schema, add_all_required=True)
@@ -176,4 +180,3 @@ class OpenAIHandler(BaseProviderHandler):
             "vision": True,  # GPT-4V and later support vision
             "json_mode": True,  # Has dedicated JSON mode via response_format
         }
-

_mcp_mesh/pipeline/api_heartbeat/rust_api_heartbeat.py

@@ -104,9 +104,10 @@ def _build_api_agent_spec(context: dict[str, Any], service_id: str = None) -> An
         # Build dependency specs
         deps = []
         for dep_cap in dependencies:
+            # Tags must be serialized to JSON string (Rust core expects string, not list)
             dep_spec = core.DependencySpec(
                 capability=dep_cap,
-                tags=[],
+                tags=json.dumps([]),
                 version=None,
             )
             deps.append(dep_spec)
@@ -136,6 +137,7 @@ def _build_api_agent_spec(context: dict[str, Any], service_id: str = None) -> An
         http_port=http_port,
         http_host=http_host,
         namespace=namespace,
+        agent_type="api",  # API services only consume capabilities, not provide them
         tools=tools if tools else None,
         llm_agents=None,  # API services don't have LLM agents
         heartbeat_interval=heartbeat_interval,
@@ -272,6 +274,8 @@ async def _handle_api_dependency_change(
                 )
                 if not current_service_id:
                     # Use config resolver for consistent env var handling
+                    from ...shared.config_resolver import get_config_value
+
                     current_service_id = get_config_value("MCP_MESH_AGENT_ID")
 
                 is_self_dependency = (

_mcp_mesh/pipeline/mcp_heartbeat/rust_heartbeat.py

@@ -117,9 +117,12 @@ def _build_agent_spec(context: dict[str, Any]) -> Any:
         # Build dependency specs
         deps = []
         for dep_info in tool_metadata.get("dependencies", []):
+            # Serialize tags to JSON to support nested arrays for OR alternatives
+            # e.g., ["addition", ["python", "typescript"]] -> addition AND (python OR typescript)
+            tags_json = json.dumps(dep_info.get("tags", []))
             dep_spec = core.DependencySpec(
                 capability=dep_info.get("capability", ""),
-                tags=dep_info.get("tags", []),
+                tags=tags_json,
                 version=dep_info.get("version"),
             )
             deps.append(dep_spec)
@@ -198,6 +201,21 @@ def _build_agent_spec(context: dict[str, Any]) -> Any:
                     )
                 break
 
+        # Extract kwargs (non-standard fields like vendor)
+        # These are spread as top-level keys in metadata by @mesh.tool(**kwargs)
+        standard_fields = {
+            "capability",
+            "tags",
+            "version",
+            "description",
+            "dependencies",
+            "input_schema",
+        }
+        kwargs_data = {
+            k: v for k, v in tool_metadata.items() if k not in standard_fields
+        }
+        kwargs_json = json.dumps(kwargs_data) if kwargs_data else None
+
         tool_spec = core.ToolSpec(
             function_name=tool_name,
             capability=tool_metadata.get("capability", tool_name),
@@ -208,6 +226,7 @@ def _build_agent_spec(context: dict[str, Any]) -> Any:
             input_schema=input_schema_json,
             llm_filter=llm_filter_json,
             llm_provider=llm_provider_json,
+            kwargs=kwargs_json,
         )
         tools.append(tool_spec)
         logger.info(
@@ -269,6 +288,14 @@ async def _handle_mesh_event(event: Any, context: dict[str, Any]) -> None:
     if event_type == "agent_registered":
         logger.info(f"Agent registered with ID: {event.agent_id}")
 
+        # Initialize direct LiteLLM agents that don't need mesh delegation
+        # These agents have provider="string" and filter=None, so all info is
+        # available at decorator time - no need to wait for registry response
+        from ...engine.dependency_injector import get_global_injector
+
+        injector = get_global_injector()
+        injector.initialize_direct_llm_agents()
+
     elif event_type == "registration_failed":
         logger.error(f"Agent registration failed: {event.error}")
 
@@ -548,6 +575,7 @@ async def _handle_llm_tools_update(
             "input_schema": (
                 json.loads(tool.input_schema) if tool.input_schema else None
             ),
+            "description": tool.description if tool.description else "",
         }
         tool_list.append(tool_info)
 
@@ -595,6 +623,7 @@ async def _handle_llm_provider_update(
             "endpoint": provider_info.endpoint,
             "name": provider_info.function_name,  # OpenAPI contract uses "name"
             "model": provider_info.model,
+            "vendor": provider_info.vendor,  # For handler selection
         }
     }
     injector.process_llm_providers(llm_providers)

_mcp_mesh/tracing/trace_context_helper.py

@@ -102,7 +102,9 @@ class TraceContextHelper:
         trace_id = request.headers.get("X-Trace-ID")
         parent_span = request.headers.get("X-Parent-Span")
 
-        # Try extracting from JSON-RPC body as fallback
+        # Try extracting from JSON-RPC body as fallback (for TypeScript agents that
+        # inject trace context into arguments since FastMCP doesn't expose HTTP headers)
+        # Keys use underscore prefix to match injection convention: _trace_id, _parent_span
         if not trace_id:
             try:
                 body = await request.body()
@@ -110,8 +112,8 @@ class TraceContextHelper:
                     payload = json.loads(body.decode("utf-8"))
                     if payload.get("method") == "tools/call":
                         arguments = payload.get("params", {}).get("arguments", {})
-                        trace_id = arguments.get("trace_id")
-                        parent_span = arguments.get("parent_span")
+                        trace_id = arguments.get("_trace_id")
+                        parent_span = arguments.get("_parent_span")
             except Exception:
                 pass
 

{mcp_mesh-0.8.0b9.dist-info → mcp_mesh-0.9.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-mesh
-Version: 0.8.0b9
+Version: 0.9.0b1
 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
@@ -18,6 +18,8 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
@@ -30,7 +32,7 @@ Requires-Dist: fastmcp<3.0.0,>=2.8.0
 Requires-Dist: httpx<1.0.0,>=0.25.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: litellm>=1.30.0
-Requires-Dist: mcp-mesh-core>=0.8.0b9
+Requires-Dist: mcp-mesh-core>=0.9.0b1
 Requires-Dist: mcp<2.0.0,>=1.9.0
 Requires-Dist: prometheus-client<1.0.0,>=0.19.0
 Requires-Dist: pydantic<3.0.0,>=2.4.0

{mcp_mesh-0.8.0b9.dist-info → mcp_mesh-0.9.0b1.dist-info}/RECORD

@@ -1,16 +1,16 @@
-_mcp_mesh/__init__.py,sha256=Pi7UIWRma8F9zTC-gcmeT5ApFCxpepQYRYMvWRVfDtE,2721
+_mcp_mesh/__init__.py,sha256=XUX8d7g4R88-074M-kF4oZqBAM6d2f6E3r4sZc_j7n0,2721
 _mcp_mesh/reload.py,sha256=5Yll9n0bqxM7pmTjfAaKWg-WT_Vi0YTh0_UNWbCNCIQ,6217
 _mcp_mesh/reload_runner.py,sha256=SgQKzzO2yHfSUBq8s3SpAnovWA0rveimVNaxeLCEo_0,1310
 _mcp_mesh/engine/__init__.py,sha256=U_6Kw3vA_3RiNK0Oln5c5C7WvA9lSONV22wWzfxYHNw,2975
 _mcp_mesh/engine/async_mcp_client.py,sha256=Sz-rXTkb1Mng_f0SpLqLuOdPJ8vZjv3DFy0i8yYOqYk,8792
 _mcp_mesh/engine/base_injector.py,sha256=qzRLZqFP2VvEFagVovkpdldvDmm3VwPHm6tHwV58a2k,5648
 _mcp_mesh/engine/decorator_registry.py,sha256=cch2QdQ6bKjHKEGi1XWp1YcLLO3uI2YlxwWBO7Np65E,28229
-_mcp_mesh/engine/dependency_injector.py,sha256=kjRUA4Lyj9zfYJ67NuFjx9YSdZEc3QtxTTpy3ww8YTg,31584
+_mcp_mesh/engine/dependency_injector.py,sha256=p_W7pJNnGNGvixiv14CsjRV5If7Ll1VdV9BEU9cde1g,31923
 _mcp_mesh/engine/http_wrapper.py,sha256=Simd6IEsLO2FXQOuf1WEx57SBN6DSr5RzphXnk0asHM,24152
 _mcp_mesh/engine/llm_config.py,sha256=95bOsGWro5E1JGq7oZtEYhVdrzcIJqjht_r5vEdJVz4,2049
 _mcp_mesh/engine/llm_errors.py,sha256=h7BiI14u-jL8vtvBfFbFDDrN7gIw8PQjXIl5AP1SBuA,3276
-_mcp_mesh/engine/mesh_llm_agent.py,sha256=sVh7lPnvixDVJ-p1ONzbeakiEzhsl0HmdmrLPZA2FzQ,34237
-_mcp_mesh/engine/mesh_llm_agent_injector.py,sha256=CHfyXWBjRPdsWtV5LTr1TsVPqKu6H0I0xZ2e62MB1p4,28820
+_mcp_mesh/engine/mesh_llm_agent.py,sha256=tKUjDqxoBxzsnWQm1T3RR0S1duHKgG6MSFiHfMjcFJU,35677
+_mcp_mesh/engine/mesh_llm_agent_injector.py,sha256=L3ptyni_lOclS6gRT7z5Paw5lLcrjbCRQnMCW8OMnBU,37899
 _mcp_mesh/engine/response_parser.py,sha256=g3VNoFJotaLrOAS0pL_OTCrv9t9XQe9Iiz1plsm28bQ,10280
 _mcp_mesh/engine/self_dependency_proxy.py,sha256=OkKt0-B_ADnJlWtHiHItoZCBZ7Su0iz2unEPFfXvrs4,3302
 _mcp_mesh/engine/session_aware_client.py,sha256=QejKag5zYNos5BVffQvNXFMECHFMLNOv78By4e_JzQE,10589
@@ -19,17 +19,17 @@ _mcp_mesh/engine/signature_analyzer.py,sha256=bG9HEsDtJlzeS2ueypLpcp7qD4_zso4DH1
 _mcp_mesh/engine/tool_executor.py,sha256=Bf_9d02EEY9_yHm1p1-5YZ4rY6MPxn4SVpI6-3sm1uo,5456
 _mcp_mesh/engine/tool_schema_builder.py,sha256=SQCxQIrSfdLu9-dLqiFurQLK7dhl0dc0xa0ibaxU-iE,3644
 _mcp_mesh/engine/unified_mcp_proxy.py,sha256=SZXlgdeNzlEGynwLLmmTi5R1-OrBaw4P8Izqhfn-zmI,37846
-_mcp_mesh/engine/provider_handlers/__init__.py,sha256=8hEc4CheKfXWU3ny4YDktxNxLCWxgfMtyDW9CblPOvs,888
-_mcp_mesh/engine/provider_handlers/base_provider_handler.py,sha256=Lb0U6gAEseU7Ix1eeV4T0WP1ClmeXUz87Nx_iplUYSI,8077
-_mcp_mesh/engine/provider_handlers/claude_handler.py,sha256=iYAmllL5rTWFFTAjbR62Ra9eMWNZjA72a02tppxjgOQ,14343
-_mcp_mesh/engine/provider_handlers/gemini_handler.py,sha256=SrJuhlaoPPHGRQH4jFXR1C_M0FtKeFcvJHERkpIPRNA,6055
-_mcp_mesh/engine/provider_handlers/generic_handler.py,sha256=rAE3QzoB7vz4zbBPPDJTI0MOuJrfhrOdXSyzsob4uVI,5489
-_mcp_mesh/engine/provider_handlers/openai_handler.py,sha256=1WhiHqf72N3584tJDVaBonDmu64tPuuiP12vzPrUNO0,6204
+_mcp_mesh/engine/provider_handlers/__init__.py,sha256=07aK9bdo2-XlzkmdIqTOJQtZbycERBJNQN90nJg6AZg,934
+_mcp_mesh/engine/provider_handlers/base_provider_handler.py,sha256=ExvRwfb2QVMbebWyuKQqJH_V-pkJ6R-3gnVGebBgu9o,13870
+_mcp_mesh/engine/provider_handlers/claude_handler.py,sha256=t23IygAIqeEJuIL16PFdL6COHrCcHb8XrXYiVnX8Vpg,15455
+_mcp_mesh/engine/provider_handlers/gemini_handler.py,sha256=cfCkXN6VJWxzwRUvklwA8_Le1LYYJpFqpvxBRjIwGUU,14338
+_mcp_mesh/engine/provider_handlers/generic_handler.py,sha256=SBPWpEf0u-797WBZXzMcr78JTSnxPmgBsqvn7zIqJVw,6617
+_mcp_mesh/engine/provider_handlers/openai_handler.py,sha256=fIxALmtdE5JL80c59jHt7btQvYddXNsTSU1xZ9xJ45g,6417
 _mcp_mesh/engine/provider_handlers/provider_handler_registry.py,sha256=klBZW8iX6Jk88TASAUyP8oPo4wvLB3DaTNFHeYvGLiA,5708
 _mcp_mesh/pipeline/__init__.py,sha256=MgPwpwbiD62ND4HXKKNGcnreDk-TvPmQOs5WmjtHQ3M,1263
 _mcp_mesh/pipeline/api_heartbeat/__init__.py,sha256=qGjEgxbGJFSl9Qm3bwu3X5yizAMbN4WpFtIUekDSFuU,690
 _mcp_mesh/pipeline/api_heartbeat/api_lifespan_integration.py,sha256=h0mTmLyPlGDqomSHpbW7S-AZNz1Tyvg1kpy9aeWkQsU,3879
-_mcp_mesh/pipeline/api_heartbeat/rust_api_heartbeat.py,sha256=vrld873jS2zCfJCndldx2XLDjxp_bRY7qq9CNBqZ8wI,15579
+_mcp_mesh/pipeline/api_heartbeat/rust_api_heartbeat.py,sha256=7Dv3lGTn2n2WrDpXoWqxUlqi6NwjPRH17-GVbsUckgE,15843
 _mcp_mesh/pipeline/api_startup/__init__.py,sha256=eivolkSKot2bJTWP2BV8-RKRT1Zm7SGQYuEUiTxusOQ,577
 _mcp_mesh/pipeline/api_startup/api_pipeline.py,sha256=I9-Q0o2py5oAHZO2DJOeTD1uZo1-Dpn258k5Tr0dv9o,2474
 _mcp_mesh/pipeline/api_startup/api_server_setup.py,sha256=72oCMkCzRfxYrE5sfFJbr57BYJwRSyKxBMISTOHmKyc,14919
@@ -38,7 +38,7 @@ _mcp_mesh/pipeline/api_startup/middleware_integration.py,sha256=J7Ux_nJ1VsMqVzl5
 _mcp_mesh/pipeline/api_startup/route_collection.py,sha256=WPr4hRPLIWnNIJCoRHZ141ph9tAa_-Pm_j2TiCuWS4k,2002
 _mcp_mesh/pipeline/api_startup/route_integration.py,sha256=qq1AVaWna-CWEXyehyDL3EyeYKgo5aMtei8uBNdvkZ8,12448
 _mcp_mesh/pipeline/mcp_heartbeat/__init__.py,sha256=mhDcSquoHkhRItqgbM8iFfAKC2m7qMW_0smqtUgSl-w,389
-_mcp_mesh/pipeline/mcp_heartbeat/rust_heartbeat.py,sha256=Y0VWtgmfM_PINHoA5abjUAlyXrMdTkfr4c05NMWtA9M,26392
+_mcp_mesh/pipeline/mcp_heartbeat/rust_heartbeat.py,sha256=9vKkmYE4YGr2vkXKKWExggIZbwMjkmSWSks0a4qw4cU,27699
 _mcp_mesh/pipeline/mcp_startup/__init__.py,sha256=qy960dnAoHLXMcL_y_rcro9Km2AoCVzC7_CxMwao564,1166
 _mcp_mesh/pipeline/mcp_startup/configuration.py,sha256=OnumIPRVBTne2OEU2VWLZovLKvWcNF9iJVQtlVwuim0,2805
 _mcp_mesh/pipeline/mcp_startup/decorator_collection.py,sha256=RHC6MHtfP9aP0hZ-IJjISZu72e0Pml3LU0qr7dc284w,2294
@@ -72,14 +72,14 @@ _mcp_mesh/tracing/context.py,sha256=2ozqKEYfx4Qxj64DnbwoVIbMkhNLbaV8BNWtkzAPA7I,
 _mcp_mesh/tracing/execution_tracer.py,sha256=dvM6QSbxk5s5rZZsCgVNaXWrr2J4_5I6XAfI1aM0sSA,10268
 _mcp_mesh/tracing/fastapi_tracing_middleware.py,sha256=FXjhA1A1Krk-ngyuOZPc1Ic4Llggv4Wide9OuPmkwCY,6959
 _mcp_mesh/tracing/redis_metadata_publisher.py,sha256=DeFrMt0ZX7k6393dH-xoRS2V5apPR-k80X8ZjrKBHMU,2890
-_mcp_mesh/tracing/trace_context_helper.py,sha256=A0UipvDExePaX-E-4SAp4M8n8uwed9PMo8gibXt1v_Q,6513
+_mcp_mesh/tracing/trace_context_helper.py,sha256=Iy9FDXCzNjcXOHJ7iT9T98DC3brHQC2UYMLVTcgmZjs,6724
 _mcp_mesh/tracing/utils.py,sha256=GWwfvab0tYGr9QAe_zgZjZxgDKTTs0p5Mf8w6WJeWC0,4486
 _mcp_mesh/utils/fastmcp_schema_extractor.py,sha256=fttO1EABbf4GWKjE9V5DimwbhzGY9DbfGWQ2ak4SRnE,17264
 mesh/__init__.py,sha256=avMnUHkNAK7VgON2OhXkrFB290gr1HErghmTZpOXr-U,4207
-mesh/decorators.py,sha256=3h3tEhKWrlxBDYjP7vVM7iMPy7nx1oVSWVqzugC6WPM,67580
-mesh/helpers.py,sha256=1Y7V6aQvpV8BKfEeeKfjwPJ5g9FjMCzSNifs3se1jkA,12935
+mesh/decorators.py,sha256=Xru9NoOolmdm-awGuuQkUgBb-s5bq9UF4p5QdVidAvI,71374
+mesh/helpers.py,sha256=LM4eLwsBW6IlHaT5sPZkk39EN-CFK8mqCaxfgrWrsLw,15145
 mesh/types.py,sha256=vr0CKyPbP6lHgxj9kh_GMSLo3xkJ66PFPV_opfRb1H4,17772
-mcp_mesh-0.8.0b9.dist-info/METADATA,sha256=-M8ClhDxH5Y4v4lCg882IS6ebAzgNXTvG-nQrGG_Mzw,5040
-mcp_mesh-0.8.0b9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mcp_mesh-0.8.0b9.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
-mcp_mesh-0.8.0b9.dist-info/RECORD,,
+mcp_mesh-0.9.0b1.dist-info/METADATA,sha256=f1jTrT-YTEZ8HiCGzuzyh_XJ3IEZWvFfYGXa1ZgM_T0,5142
+mcp_mesh-0.9.0b1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mcp_mesh-0.9.0b1.dist-info/licenses/LICENSE,sha256=_EBQHRQThv9FPOLc5eFOUdeeRO0mYwChC7cx60dM1tM,1078
+mcp_mesh-0.9.0b1.dist-info/RECORD,,