Normalize outbound MCP tool arguments

application/single_app/config.py

@@ -96,7 +96,7 @@
 EXECUTOR_TYPE = 'thread'
 EXECUTOR_MAX_WORKERS = 30
 SESSION_TYPE = 'filesystem'
-VERSION = "0.250.126"
+VERSION = "0.250.128"
 IS_DEVELOPMENT = is_development_env_enabled()
 
 SESSION_COOKIE_SAMESITE = os.getenv('SESSION_COOKIE_SAMESITE', 'Lax')

application/single_app/functions_mcp_operations.py

@@ -477,6 +477,33 @@
     return warnings[:20]
 
 
+def _mcp_tool_schema_defines_property(tool, property_name):
+    if not isinstance(tool, dict):
+        return False
+
+    input_schema = tool.get("input_schema") if isinstance(tool.get("input_schema"), dict) else {}
+    properties = input_schema.get("properties")
+    return isinstance(properties, dict) and property_name in properties
+
+
+def normalize_mcp_tool_call_arguments(tool, arguments):
+    """Return MCP tool arguments in the top-level shape expected by tools/call."""
+    if arguments is None:
+        return {}
+    if not isinstance(arguments, dict):
+        return arguments
+
+    wrapper_value = arguments.get("kwargs")
+    if (
+        set(arguments.keys()) == {"kwargs"}
+        and isinstance(wrapper_value, dict)
+        and not _mcp_tool_schema_defines_property(tool, "kwargs")
+    ):
+        return wrapper_value
+
+    return arguments
+
+
 def validate_mcp_tool_arguments(tool, arguments):
     """Return validation errors for MCP tool arguments against cached input schema."""
     if not isinstance(tool, dict):

application/single_app/semantic_kernel_plugins/mcp_plugin.py

@@ -13,6 +13,7 @@
     classify_mcp_exception,
     normalize_mcp_additional_fields,
     normalize_mcp_tool_metadata,
+    normalize_mcp_tool_call_arguments,
     validate_mcp_tool_arguments,
 )
 from semantic_kernel_plugins.base_plugin import BasePlugin
@@ -157,12 +158,16 @@
                 "error_type": "not_configured",
                 "configured_tools": sorted(configured_tool_names),
             }
+        configured_tool = next(
+            (tool for tool in self._tools if tool.get("original_name") == normalized_tool_name),
+            None,
+        )
+        normalized_arguments = normalize_mcp_tool_call_arguments(
+            configured_tool,
+            arguments if arguments is not None else {},
+        )
         if self._additional_fields.get("validate_tool_arguments"):
-            configured_tool = next(
-                (tool for tool in self._tools if tool.get("original_name") == normalized_tool_name),
-                None,
-            )
-            validation_errors = validate_mcp_tool_arguments(configured_tool, arguments or {})
+            validation_errors = validate_mcp_tool_arguments(configured_tool, normalized_arguments)
             if validation_errors:
                 return {
                     "success": False,
@@ -171,7 +176,7 @@
                     "validation_errors": validation_errors,
                 }
 
-        return await self.invoke_tool(normalized_tool_name, arguments or {})
+        return await self.invoke_tool(normalized_tool_name, normalized_arguments or {})
 
     async def invoke_tool(self, tool_name: str, arguments: Optional[dict] = None) -> dict:
         """Invoke an MCP tool through the factory's native MCP connector."""
@@ -180,7 +185,7 @@
                 f"[MCP_PLUGIN] Invoking MCP tool tool_name={tool_name} "
                 f"transport={self._additional_fields.get('transport')} "
                 f"endpoint_present={bool(str(self.manifest.get('endpoint') or '').strip())} "
-                f"argument_keys={sorted((arguments or {}).keys())}"
+                f"argument_keys={sorted(arguments.keys()) if isinstance(arguments, dict) else []}"
             )
             from semantic_kernel_plugins.mcp_plugin_factory import McpPluginFactory
 

application/single_app/semantic_kernel_plugins/mcp_plugin_factory.py

@@ -26,6 +26,7 @@
     get_mcp_custom_header_validation_errors,
     is_valid_mcp_header_name,
     normalize_mcp_additional_fields,
+    normalize_mcp_tool_call_arguments,
     normalize_mcp_tool_metadata,
     validate_mcp_endpoint_for_transport,
 )
@@ -249,10 +250,35 @@ async def call_tool_from_config(
         arguments: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
         """Connect to an MCP server, invoke one tool, and normalize the result."""
+        configured_tool = cls._find_configured_tool(config, tool_name)
+        normalized_arguments = (
+            normalize_mcp_tool_call_arguments(configured_tool, arguments)
+            if configured_tool
+            else arguments
+        )
         return await cls._run_with_retries(
             config,
             "tool_call",
-            lambda: cls._call_tool_once(config, tool_name, arguments),
+            lambda: cls._call_tool_once(config, tool_name, normalized_arguments),
+        )
+
+    @classmethod
+    def _find_configured_tool(cls, config: Dict[str, Any], tool_name: str) -> Optional[Dict[str, Any]]:
+        """Return cached MCP tool metadata for a factory invocation."""
+        normalized_tool_name = str(tool_name or "").strip()
+        if not normalized_tool_name:
+            return None
+
+        additional_fields = normalize_mcp_additional_fields((config or {}).get("additionalFields", {}))
+        configured_tools = normalize_mcp_tool_metadata(additional_fields.get("mcp_tools", []))
+        return next(
+            (
+                tool
+                for tool in configured_tools
+                if tool.get("original_name") == normalized_tool_name
+                or tool.get("function_name") == normalized_tool_name
+            ),
+            None,
         )
 
     @classmethod

docs/explanation/release_notes.md

@@ -2,6 +2,15 @@
 
 For feature-focused and fix-focused drill-downs by version, see [Features by Version](/explanation/features/) and [Fixes by Version](/explanation/fixes/).
 
+### **(v0.250.128)**
+
+#### Bug Fixes
+
+*   **Outbound MCP Tool Argument Normalization**
+    *   Fixed outbound MCP tool calls that could wrap parameters inside a `kwargs` object, preventing standards-compliant MCP servers from seeing required top-level fields such as `type`.
+    *   Added schema-aware normalization before MCP argument validation and invocation while preserving tools that explicitly define a real top-level `kwargs` property.
+    *   (Ref: #1163, MCP `tools/call` arguments, `functions_mcp_operations.py`, `mcp_plugin.py`, `mcp_plugin_factory.py`)
+
 ### **(v0.250.126)**
 
 #### Bug Fixes