lint + tests

Author: hallvictoria

azure/functions/decorators/function_app.py

@@ -1685,45 +1685,49 @@ async def wrapper(context: str, *args, **kwargs):
                         "content": json.dumps(result_dict),
                         "structuredContent": json.dumps(result.structured_content) if result.structured_content else None
                     })
-                
+
                 # Handle List[ContentBlock] - multiple content blocks
-                if isinstance(result, list) and all(isinstance(item, ContentBlock) for item in result):
+                if isinstance(result, list) and all(
+                        isinstance(item, ContentBlock) for item in result):
                     content_blocks = [block.to_dict() for block in result]
                     return json.dumps({
                         "type": "multi_content_result",
                         "content": json.dumps(content_blocks)
                     })
-                
+
                 # Handle single ContentBlock
                 if isinstance(result, ContentBlock):
                     block_dict = result.to_dict()
                     return json.dumps({
                         "type": result.type,
                         "content": json.dumps(block_dict)
                     })
-                
+
                 # Handle structured content generation when use_result_schema is True
                 if use_result_schema:
                     # Check if we should create structured content
                     if should_create_structured_content(result):
                         # Serialize result as JSON for structured content
                         # Handle dataclasses properly
                         if dataclasses.is_dataclass(result):
-                            result_json = json.dumps(dataclasses.asdict(result))
+                            result_json = json.dumps(
+                                dataclasses.asdict(result))
                         elif hasattr(result, '__dict__'):
                             # For regular classes with __dict__
                             result_json = json.dumps(result.__dict__)
                         else:
                             # Fallback to str conversion
-                            result_json = json.dumps(result) if not isinstance(result, str) else result
-                        
+                            result_json = json.dumps(
+                                result) if not isinstance(
+                                result, str) else result
+
                         # Return McpToolResult format with both text and structured content
                         return json.dumps({
                             "type": "text",
                             "content": json.dumps({"type": "text", "text": result_json}),
                             "structuredContent": result_json
                         })
-                
+
                 return str(result)
 
             wrapper.__signature__ = wrapper_sig

azure/functions/decorators/mcp.py

@@ -177,44 +177,44 @@ def has_mcp_content_marker(obj: typing.Any) -> bool:
 def should_create_structured_content(obj: typing.Any) -> bool:
     """
     Determines whether structured content should be created for the given object.
-    
+
     Returns True if:
     - The object's class is decorated with a marker that sets __mcp_content__ = True
     - The object is not a primitive type (str, int, float, bool, None)
     - The object is not a dict or list (unless explicitly marked)
-    
+
     This mimics the .NET implementation's McpContentAttribute checking.
     """
     if obj is None:
         return False
-    
+
     # Primitive types don't generate structured content unless explicitly marked
     if isinstance(obj, (str, int, float, bool)):
         return False
-    
+
     # Check for the marker attribute
     return has_mcp_content_marker(obj)
 
 
 def mcp_content(cls):
     """
-    Decorator to mark a class as an MCP result type that should be serialized 
+    Decorator to mark a class as an MCP result type that should be serialized
     as structured content.
-    
+
     When a function returns an object of a type decorated with this decorator,
     the result will be serialized as both text content (for backwards compatibility)
     and structured content (for clients that support it).
-    
+
     This is the Python equivalent of C#'s [McpContent] attribute.
-    
+
     Example:
         @mcp_content
         class ImageMetadata:
             def __init__(self, image_id: str, format: str, tags: list):
                 self.image_id = image_id
                 self.format = format
                 self.tags = tags
-        
+
         @app.mcp_tool(use_result_schema=True)
         def get_image_info():
             return ImageMetadata("logo", "png", ["functions"])

azure/functions/mcp.py

@@ -77,7 +77,7 @@ class CallToolResult:
     """
     Result type for MCP tool calls that allows manual construction
     of content blocks and structured content.
-    
+
     Example:
         return CallToolResult(
             content=[