Add support for isRequired, isArray, McpToolProperty input

Author: hallvictoria

azure/functions/decorators/function_app.py

@@ -44,7 +44,7 @@
     AssistantQueryInput, AssistantPostInput, InputType, EmbeddingsInput, \
     semantic_search_system_prompt, \
     SemanticSearchInput, EmbeddingsStoreOutput
-from .mcp import MCPToolTrigger, _TYPE_MAPPING
+from .mcp import MCPToolTrigger, _TYPE_MAPPING, check_property_type, check_is_array, check_is_required
 from .retry_policy import RetryPolicy
 from .function_name import FunctionName
 from .warmup import WarmUpTrigger
@@ -55,6 +55,8 @@
     MySqlTrigger
 
 
+logger = logging.getLogger('azure.functions.WsgiMiddleware')
+
 class Function(object):
     """
     The function object represents a function in Function App. It
@@ -1588,6 +1590,11 @@ def mcp_tool(self):
         def decorator(fb: FunctionBuilder) -> FunctionBuilder:
             target_func = fb._function.get_user_function()
             sig = inspect.signature(target_func)
+
+            # Pull any explicitly declared MCP tool properties
+            explicit_properties = getattr(target_func, "__mcp_tool_properties__", {})
+            logger.info(f"Explicit MCP tool properties: {explicit_properties}")
+
             # Parse tool name and description from function signature
             tool_name = target_func.__name__
             description = (target_func.__doc__ or "").strip().split("\n")[0]
@@ -1602,15 +1609,29 @@ def decorator(fb: FunctionBuilder) -> FunctionBuilder:
                 if param_name in skip_param_names:
                     continue
                 param_type_hint = param.annotation if param.annotation != inspect.Parameter.empty else str  # noqa
-                # Parse type and description from type hint
-                actual_type = param_type_hint
-                if actual_type is MCPToolContext:
+
+                if param_type_hint is MCPToolContext:
                     continue
-                property_type = _TYPE_MAPPING.get(actual_type, "string")
+
+                # Check if explicit metadata exists for this param
+                if param_name in explicit_properties:
+                    logger.info(f"Using explicit MCP tool property for param: {param_name}")  # noqa
+                    prop = explicit_properties[param_name].copy()
+                    prop["propertyName"] = param_name
+                    tool_properties.append(prop)
+                    continue
+
+                 # Otherwise infer it
+                is_required = check_is_required(param, param_type_hint)
+                is_array = check_is_array(param_type_hint)
+                property_type = check_property_type(param_type_hint, is_array)
+
                 tool_properties.append({
                     "propertyName": param_name,
                     "propertyType": property_type,
                     "description": "",
+                    "isArray": is_array,
+                    "isRequired": is_required
                 })
 
             tool_properties_json = json.dumps(tool_properties)
@@ -1660,6 +1681,40 @@ async def wrapper(context: str, *args, **kwargs):
 
         return decorator
 
+    def mcp_tool_property(self, arg_name: str,
+                      description: Optional[str] = "",
+                      property_type: Optional[str] = None,
+                      is_required: Optional[bool] = True,
+                      is_array: Optional[bool] = False):
+        """
+        Decorator for defining explicit MCP tool property metadata for a specific argument.
+
+        Example:
+            @app.mcp_tool_property(
+                arg_name="snippetname",
+                description="The name of the snippet.",
+                property_type="string",
+                is_required=True,
+                is_array=False
+            )
+        """
+        def decorator(func):
+        # If this function is already wrapped by FunctionBuilder or similar, unwrap it
+            target_func = getattr(func, "_function", func)
+            target_func = getattr(target_func, "_func", target_func)
+
+            existing = getattr(target_func, "__mcp_tool_properties__", {})
+            existing[arg_name] = {
+                "description": description or "",
+                "propertyType": property_type or "string",
+                "isRequired": is_required,
+                "isArray": is_array,
+            }
+            setattr(target_func, "__mcp_tool_properties__", existing)
+            return func
+        return decorator
+
+
     def dapr_service_invocation_trigger(self,
                                         arg_name: str,
                                         method_name: str,

azure/functions/decorators/mcp.py

@@ -1,6 +1,8 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
-from typing import Optional
+import inspect
+
+from typing import List, Optional, Union, get_origin, get_args
 from datetime import datetime
 
 from azure.functions.decorators.constants import (
@@ -36,3 +38,51 @@ def __init__(self,
         self.description = description
         self.tool_properties = tool_properties
         super().__init__(name=name, data_type=data_type)
+
+def unwrap_optional(pytype: type):
+    """If Optional[T], return T; else return pytype unchanged."""
+    origin = get_origin(pytype)
+    args = get_args(pytype)
+    if origin is Union and any(a is type(None) for a in args):
+        non_none_args = [a for a in args if a is not type(None)]
+        return non_none_args[0] if non_none_args else str
+    return pytype
+
+
+def check_is_array(param_type_hint: type) -> bool:
+    """Return True if type is (possibly optional) list[...]"""
+    unwrapped = unwrap_optional(param_type_hint)
+    origin = get_origin(unwrapped)
+    return origin in (list, List)
+
+
+def check_property_type(pytype: type, is_array: bool) -> str:
+    """Map Python type hints to MCP property types."""
+    base_type = unwrap_optional(pytype)
+    if is_array:
+        args = get_args(base_type)
+        inner_type = unwrap_optional(args[0]) if args else str
+        return _TYPE_MAPPING.get(inner_type, "string")
+    return _TYPE_MAPPING.get(base_type, "string")
+
+def check_is_required(param: type, param_type_hint: type) -> bool:
+    """
+    Return True when param is required, False when optional.
+
+    Rules:
+    - If param has an explicit default -> not required
+    - If annotation is Optional[T] (Union[..., None]) -> not required
+    - Otherwise -> required
+    """
+    # 1) default value present => not required
+    if param.default is not inspect.Parameter.empty:
+        return False
+
+    # 2) Optional[T] => not required
+    origin = get_origin(param_type_hint)
+    args = get_args(param_type_hint)
+    if origin is Union and any(a is type(None) for a in args):
+        return False
+
+    # 3) It's required
+    return True