Final changes, tests

Author: hallvictoria

azure/functions/__init__.py

@@ -10,7 +10,7 @@
                          DecoratorApi, DataType, AuthLevel,
                          Cardinality, AccessRights, HttpMethod,
                          AsgiFunctionApp, WsgiFunctionApp,
-                         ExternalHttpFunctionApp, BlobSource)
+                         ExternalHttpFunctionApp, BlobSource, McpPropertyType)
 from ._durable_functions import OrchestrationContext, EntityContext
 from .decorators.function_app import (FunctionRegister, TriggerApi,
                                       BindingApi, SettingsApi)
@@ -102,7 +102,8 @@
     'AccessRights',
     'HttpMethod',
     'BlobSource',
-    'MCPToolContext'
+    'MCPToolContext',
+    'McpPropertyType'
 )
 
 __version__ = '1.25.0b1'

azure/functions/decorators/__init__.py

@@ -4,7 +4,7 @@
 from .function_app import FunctionApp, Function, DecoratorApi, DataType, \
     AuthLevel, Blueprint, ExternalHttpFunctionApp, AsgiFunctionApp, \
     WsgiFunctionApp, FunctionRegister, TriggerApi, BindingApi, \
-    SettingsApi, BlobSource
+    SettingsApi, BlobSource, McpPropertyType
 from .http import HttpMethod
 
 __all__ = [
@@ -24,5 +24,6 @@
     'Cardinality',
     'AccessRights',
     'HttpMethod',
-    'BlobSource'
+    'BlobSource',
+    'McpPropertyType'
 ]

azure/functions/decorators/core.py

@@ -73,6 +73,22 @@ class BlobSource(StringifyEnum):
     """Standard polling mechanism to detect changes in the container."""
 
 
+class McpPropertyType(StringifyEnum):
+    """MCP property types."""
+    INTEGER = "integer"
+    """Integer type."""
+    FLOAT = "float"
+    """Float type."""
+    STRING = "string"
+    """String type."""
+    BOOLEAN = "boolean"
+    """Boolean type."""
+    OBJECT = "object"
+    """Object type."""
+    DATETIME = "string"
+    """Datetime type represented as string."""
+
+
 class Binding(ABC):
     """Abstract binding class which captures common attributes and
     functions. :meth:`get_dict_repr` can auto generate the function.json for

azure/functions/decorators/function_app.py

@@ -13,7 +13,8 @@
 
 from azure.functions.decorators.blob import BlobTrigger, BlobInput, BlobOutput
 from azure.functions.decorators.core import Binding, Trigger, DataType, \
-    AuthLevel, SCRIPT_FILE_NAME, Cardinality, AccessRights, Setting, BlobSource
+    AuthLevel, SCRIPT_FILE_NAME, Cardinality, AccessRights, Setting, BlobSource, \
+    McpPropertyType
 from azure.functions.decorators.cosmosdb import CosmosDBTrigger, \
     CosmosDBOutput, CosmosDBInput, CosmosDBTriggerV3, CosmosDBInputV3, \
     CosmosDBOutputV3
@@ -44,7 +45,7 @@
     AssistantQueryInput, AssistantPostInput, InputType, EmbeddingsInput, \
     semantic_search_system_prompt, \
     SemanticSearchInput, EmbeddingsStoreOutput
-from .mcp import MCPToolTrigger, _TYPE_MAPPING, check_property_type, check_is_array, check_is_required
+from .mcp import MCPToolTrigger, check_property_type, check_is_array, check_is_required
 from .retry_policy import RetryPolicy
 from .function_name import FunctionName
 from .warmup import WarmUpTrigger
@@ -55,8 +56,6 @@
     MySqlTrigger
 
 
-logger = logging.getLogger('azure.functions.WsgiMiddleware')
-
 class Function(object):
     """
     The function object represents a function in Function App. It
@@ -1593,7 +1592,6 @@ def decorator(fb: FunctionBuilder) -> FunctionBuilder:
 
             # 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__
@@ -1613,26 +1611,27 @@ def decorator(fb: FunctionBuilder) -> FunctionBuilder:
                 if param_type_hint is MCPToolContext:
                     continue
 
-                # 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
+                # Inferred defaults
                 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({
+                property_data = {
                     "propertyName": param_name,
                     "propertyType": property_type,
                     "description": "",
                     "isArray": is_array,
                     "isRequired": is_required
-                })
+                }
+
+                # Merge in any explicit overrides
+                if param_name in explicit_properties:
+                    overrides = explicit_properties[param_name]
+                    for key, value in overrides.items():
+                        if value is not None:
+                            property_data[key] = value
+
+                tool_properties.append(property_data)
 
             tool_properties_json = json.dumps(tool_properties)
 
@@ -1682,39 +1681,46 @@ 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):
+                          description: Optional[str] = None,
+                          property_type: Optional[McpPropertyType] = None,
+                          is_required: Optional[bool] = True,
+                          is_array: Optional[bool] = False):
         """
         Decorator for defining explicit MCP tool property metadata for a specific argument.
 
+        :param arg_name: The name of the argument.
+        :param description: The description of the argument.
+        :param property_type: The type of the argument.
+        :param is_required: If the argument is required or not.
+        :param is_array: If the argument is array or not.
+
+        :return: Decorator function.
+
         Example:
             @app.mcp_tool_property(
                 arg_name="snippetname",
                 description="The name of the snippet.",
-                property_type="string",
+                property_type=func.McpPropertyType.STRING,
                 is_required=True,
                 is_array=False
             )
         """
         def decorator(func):
-        # If this function is already wrapped by FunctionBuilder or similar, unwrap it
+            # 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",
+                "description": description,
+                "propertyType": property_type.value if property_type else None,  # Get enum value
                 "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

@@ -8,7 +8,7 @@
 from azure.functions.decorators.constants import (
     MCP_TOOL_TRIGGER
 )
-from azure.functions.decorators.core import Trigger, DataType
+from azure.functions.decorators.core import Trigger, DataType, McpPropertyType
 
 # Mapping Python types to MCP property types
 _TYPE_MAPPING = {
@@ -39,6 +39,7 @@ def __init__(self,
         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)
@@ -58,13 +59,16 @@ def check_is_array(param_type_hint: type) -> bool:
 
 def check_property_type(pytype: type, is_array: bool) -> str:
     """Map Python type hints to MCP property types."""
+    if isinstance(pytype, McpPropertyType):
+        return pytype.value
     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.