mcp-mesh 0.8.1__py3-none-any.whl → 0.9.0b2__py3-none-any.whl

mesh/helpers.py

@@ -6,7 +6,7 @@ mesh decorators to simplify common patterns like zero-code LLM providers.
 """
 
 import logging
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 from _mcp_mesh.shared.logging_config import format_log_value
 
@@ -214,62 +214,55 @@ def llm_provider(
                             f"(requested by consumer)"
                         )
 
+            # Get vendor handler once - used for both structured output and system prompt formatting
+            from _mcp_mesh.engine.provider_handlers import ProviderHandlerRegistry
+
+            handler = ProviderHandlerRegistry.get_handler(vendor)
+
             # Issue #459: Handle output_schema for vendor-specific structured output
-            # Convert to response_format for vendors that support it
+            # Use provider handler pattern for vendor-specific behavior
             output_schema = model_params_copy.pop("output_schema", None)
             output_type_name = model_params_copy.pop("output_type_name", None)
 
-            # Vendors that support structured output via response_format
-            supported_structured_output_vendors = (
-                "openai",
-                "azure",  # Azure OpenAI uses same format as OpenAI
-                "gemini",
-                "vertex_ai",  # Vertex AI Gemini uses same format as Gemini
-                "anthropic",
-            )
-
             if output_schema:
-                if vendor in supported_structured_output_vendors:
-                    # Apply vendor-specific response_format for structured output
-                    from _mcp_mesh.engine.provider_handlers import make_schema_strict
-
-                    if vendor == "anthropic":
-                        # Claude: doesn't require all properties in 'required', uses strict=False
-                        schema = make_schema_strict(
-                            output_schema, add_all_required=False
+                # Include messages so handler can modify system prompt (e.g., HINT mode injection)
+                model_params_copy["messages"] = request.messages
+                handler.apply_structured_output(
+                    output_schema, output_type_name, model_params_copy
+                )
+                # Remove messages to avoid duplication in completion_args
+                model_params_copy.pop("messages", None)
+                logger.debug(
+                    f"🎯 Applied {vendor} structured output via handler: "
+                    f"{output_type_name}"
+                )
+
+            # Use vendor handler to format system prompt when tools are present
+            messages = request.messages
+            if request.tools:
+
+                # Find and format system message
+                formatted_messages = []
+                for msg in messages:
+                    if msg.get("role") == "system":
+                        # Format system prompt with vendor-specific instructions
+                        base_prompt = msg.get("content", "")
+                        formatted_content = handler.format_system_prompt(
+                            base_prompt=base_prompt,
+                            tool_schemas=request.tools,
+                            output_type=str,  # Provider returns raw string
                         )
-                        strict_mode = False
-                    else:
-                        # OpenAI/Azure/Gemini/Vertex: require all properties in 'required', uses strict=True
-                        schema = make_schema_strict(
-                            output_schema, add_all_required=True
+                        formatted_messages.append(
+                            {"role": "system", "content": formatted_content}
                         )
-                        strict_mode = True
-
-                    model_params_copy["response_format"] = {
-                        "type": "json_schema",
-                        "json_schema": {
-                            "name": output_type_name or "Response",
-                            "schema": schema,
-                            "strict": strict_mode,
-                        },
-                    }
-                    logger.debug(
-                        f"🎯 Applied {vendor} response_format for structured output: "
-                        f"{output_type_name} (strict={strict_mode})"
-                    )
-                else:
-                    # Vendor doesn't support structured output - warn user
-                    logger.warning(
-                        f"⚠️ Structured output schema '{output_type_name or 'Response'}' "
-                        f"was provided but vendor '{vendor}' does not support response_format. "
-                        f"The schema will be ignored and the LLM may return unstructured output."
-                    )
+                    else:
+                        formatted_messages.append(msg)
+                messages = formatted_messages
 
             # Build litellm.completion arguments
             completion_args: dict[str, Any] = {
                 "model": effective_model,
-                "messages": request.messages,
+                "messages": messages,
                 **litellm_kwargs,
             }