feedback

Author: hallvictoria

azure/functions/decorators/function_app.py

@@ -6,6 +6,8 @@
 import inspect
 import json
 import logging
+import textwrap
+
 from abc import ABC
 from datetime import time
 from typing import Any, Callable, Dict, List, Optional, Union, \
@@ -45,7 +47,7 @@
     AssistantQueryInput, AssistantPostInput, InputType, EmbeddingsInput, \
     semantic_search_system_prompt, \
     SemanticSearchInput, EmbeddingsStoreOutput
-from .mcp import MCPToolTrigger, check_property_type, check_is_array, check_is_required
+from .mcp import MCPToolTrigger, build_property_metadata
 from .retry_policy import RetryPolicy
 from .function_name import FunctionName
 from .warmup import WarmUpTrigger
@@ -1595,43 +1597,17 @@ def decorator(fb: FunctionBuilder) -> FunctionBuilder:
 
             # Parse tool name and description from function signature
             tool_name = target_func.__name__
-            description = (target_func.__doc__ or "").strip().split("\n")[0]
+            raw_doc = target_func.__doc__ or ""
+            description = textwrap.dedent(raw_doc).strip()
 
             # Identify arguments that are already bound (bindings)
             bound_param_names = {b.name for b in getattr(fb._function, "_bindings", [])}
             skip_param_names = bound_param_names
 
             # Build tool properties
-            tool_properties = []
-            for param_name, param in sig.parameters.items():
-                if param_name in skip_param_names:
-                    continue
-                param_type_hint = param.annotation if param.annotation != inspect.Parameter.empty else str  # noqa
-
-                if param_type_hint is MCPToolContext:
-                    continue
-
-                # 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)
-
-                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 = build_property_metadata(sig=sig,
+                                                      skip_param_names=skip_param_names,
+                                                      explicit_properties=explicit_properties)
 
             tool_properties_json = json.dumps(tool_properties)
 
@@ -1684,15 +1660,15 @@ def mcp_tool_property(self, arg_name: str,
                           description: Optional[str] = None,
                           property_type: Optional[McpPropertyType] = None,
                           is_required: Optional[bool] = True,
-                          is_array: Optional[bool] = False):
+                          as_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.
+        :param as_array: If the argument should be passed as an array or not.
 
         :return: Decorator function.
 
@@ -1702,7 +1678,7 @@ def mcp_tool_property(self, arg_name: str,
                 description="The name of the snippet.",
                 property_type=func.McpPropertyType.STRING,
                 is_required=True,
-                is_array=False
+                as_array=False
             )
         """
         def decorator(func):
@@ -1715,7 +1691,7 @@ def decorator(func):
                 "description": description,
                 "propertyType": property_type.value if property_type else None,  # Get enum value
                 "isRequired": is_required,
-                "isArray": is_array,
+                "isArray": as_array,
             }
             setattr(target_func, "__mcp_tool_properties__", existing)
             return func

azure/functions/decorators/mcp.py

@@ -5,6 +5,7 @@
 from typing import List, Optional, Union, get_origin, get_args
 from datetime import datetime
 
+from ..mcp import MCPToolContext
 from azure.functions.decorators.constants import (
     MCP_TOOL_TRIGGER
 )
@@ -50,19 +51,19 @@ def unwrap_optional(pytype: type):
     return pytype
 
 
-def check_is_array(param_type_hint: type) -> bool:
+def check_as_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:
+def check_property_type(pytype: type, as_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:
+    if as_array:
         args = get_args(base_type)
         inner_type = unwrap_optional(args[0]) if args else str
         return _TYPE_MAPPING.get(inner_type, "string")
@@ -90,3 +91,39 @@ def check_is_required(param: type, param_type_hint: type) -> bool:
 
     # 3) It's required
     return True
+
+
+def build_property_metadata(sig,
+                            skip_param_names: List[str],
+                            explicit_properties: dict) -> List[dict]:
+    tool_properties = []
+    for param_name, param in sig.parameters.items():
+        if param_name in skip_param_names:
+            continue
+        param_type_hint = param.annotation if param.annotation != inspect.Parameter.empty else str  # noqa
+
+        if param_type_hint is MCPToolContext:
+            continue
+
+        # Inferred defaults
+        is_required = check_is_required(param, param_type_hint)
+        as_array = check_as_array(param_type_hint)
+        property_type = check_property_type(param_type_hint, as_array)
+
+        property_data = {
+            "propertyName": param_name,
+            "propertyType": property_type,
+            "description": "",
+            "isArray": as_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)
+    return tool_properties

tests/decorators/test_mcp.py

@@ -79,6 +79,44 @@ def add_numbers(a: int, b: int) -> int:
                          '"isArray": false, '
                          '"isRequired": true}]')
 
+    def test_long_pydocs(self):
+        @self.app.mcp_tool()
+        def add_numbers(a: int, b: int) -> int:
+            """
+            Add two numbers.
+
+            Args:
+                a (int): The first number to add.
+                b (int): The second number to add.
+
+            Returns:
+                int: The sum of the two numbers.
+            """
+            return a + b
+
+        trigger = add_numbers._function._bindings[0]
+        self.assertEqual(trigger.description, '''Add two numbers.
+
+Args:
+    a (int): The first number to add.
+    b (int): The second number to add.
+
+Returns:
+    int: The sum of the two numbers.''')
+        self.assertEqual(trigger.name, "context")
+        self.assertEqual(trigger.tool_name, "add_numbers")
+        self.assertEqual(trigger.tool_properties,
+                         '[{"propertyName": "a", '
+                         '"propertyType": "integer", '
+                         '"description": "", '
+                         '"isArray": false, '
+                         '"isRequired": true}, '
+                         '{"propertyName": "b", '
+                         '"propertyType": "integer", '
+                         '"description": "", '
+                         '"isArray": false, '
+                         '"isRequired": true}]')
+
     def test_simple_signature_defaults(self):
         @self.app.mcp_tool()
         def add_numbers(a, b):
@@ -187,7 +225,7 @@ def add_numbers(a: int = 0) -> int:
                          '"isArray": false, '
                          '"isRequired": false}]')
 
-    def test_is_array(self):
+    def test_as_array(self):
         @self.app.mcp_tool()
         def add_numbers(a: typing.List[int]) -> typing.List[int]:
             """Add two numbers."""
@@ -204,7 +242,7 @@ def add_numbers(a: typing.List[int]) -> typing.List[int]:
                          '"isArray": true, '
                          '"isRequired": true}]')
 
-    def test_is_array_pep(self):
+    def test_as_array_pep(self):
         @self.app.mcp_tool()
         def add_numbers(a: list[int]) -> list[int]:
             """Add two numbers."""
@@ -244,7 +282,7 @@ def test_mcp_property_input_all_props(self):
                                     description="The first number",
                                     property_type=func.McpPropertyType.INTEGER,
                                     is_required=False,
-                                    is_array=True)
+                                    as_array=True)
         def add_numbers(a, b: int) -> int:
             """Add two numbers."""
             return a + b