fix: add proper serialization/validation for auth and auth_tools fields

- Add field_serializer and field_validator for auth_tools in TextCallTemplate
- Add field_serializer and field_validator for both auth and auth_tools in HttpCallTemplate
- Use AuthSerializer.validate_dict() for proper dict-to-Auth conversion
- Add comprehensive test coverage for auth_tools serialization
- Ensures dict configurations preserve all critical authentication fields
- All 155 tests pass with proper field validation

Author: perrozzi

plugins/communication_protocols/http/src/utcp_http/http_call_template.py

@@ -1,10 +1,10 @@
 from utcp.data.call_template import CallTemplate, CallTemplateSerializer
-from utcp.data.auth import Auth
+from utcp.data.auth import Auth, AuthSerializer
 from utcp.interfaces.serializer import Serializer
 from utcp.exceptions import UtcpSerializerValidationError
 import traceback
-from typing import Optional, Dict, List, Literal
-from pydantic import Field
+from typing import Optional, Dict, List, Literal, Any
+from pydantic import Field, field_serializer, field_validator
 
 class HttpCallTemplate(CallTemplate):
     """REQUIRED
@@ -108,6 +108,44 @@ class HttpCallTemplate(CallTemplate):
     body_field: Optional[str] = Field(default="body", description="The name of the single input field to be sent as the request body.")
     header_fields: Optional[List[str]] = Field(default=None, description="List of input fields to be sent as request headers.")
 
+    @field_serializer('auth')
+    def serialize_auth(self, auth: Optional[Auth]) -> Optional[dict]:
+        """Serialize auth to dictionary."""
+        if auth is None:
+            return None
+        return AuthSerializer().to_dict(auth)
+
+    @field_validator('auth', mode='before')
+    @classmethod
+    def validate_auth(cls, v: Any) -> Optional[Auth]:
+        """Validate and deserialize auth from dictionary."""
+        if v is None:
+            return None
+        if isinstance(v, Auth):
+            return v
+        if isinstance(v, dict):
+            return AuthSerializer().validate_dict(v)
+        raise ValueError(f"auth must be None, Auth instance, or dict, got {type(v)}")
+
+    @field_serializer('auth_tools')
+    def serialize_auth_tools(self, auth_tools: Optional[Auth]) -> Optional[dict]:
+        """Serialize auth_tools to dictionary."""
+        if auth_tools is None:
+            return None
+        return AuthSerializer().to_dict(auth_tools)
+
+    @field_validator('auth_tools', mode='before')
+    @classmethod
+    def validate_auth_tools(cls, v: Any) -> Optional[Auth]:
+        """Validate and deserialize auth_tools from dictionary."""
+        if v is None:
+            return None
+        if isinstance(v, Auth):
+            return v
+        if isinstance(v, dict):
+            return AuthSerializer().validate_dict(v)
+        raise ValueError(f"auth_tools must be None, Auth instance, or dict, got {type(v)}")
+
 
 class HttpCallTemplateSerializer(Serializer[HttpCallTemplate]):
     """REQUIRED

plugins/communication_protocols/text/src/utcp_text/text_call_template.py

@@ -1,8 +1,8 @@
-from typing import Literal, Optional
-from pydantic import Field
+from typing import Literal, Optional, Any
+from pydantic import Field, field_serializer, field_validator
 
 from utcp.data.call_template import CallTemplate
-from utcp.data.auth import Auth
+from utcp.data.auth import Auth, AuthSerializer
 from utcp.interfaces.serializer import Serializer
 from utcp.exceptions import UtcpSerializerValidationError
 import traceback
@@ -26,6 +26,25 @@ class TextCallTemplate(CallTemplate):
     auth: None = None
     auth_tools: Optional[Auth] = Field(None, description="Authentication to apply to generated tools from OpenAPI specs.")
 
+    @field_serializer('auth_tools')
+    def serialize_auth_tools(self, auth_tools: Optional[Auth]) -> Optional[dict]:
+        """Serialize auth_tools to dictionary."""
+        if auth_tools is None:
+            return None
+        return AuthSerializer().to_dict(auth_tools)
+
+    @field_validator('auth_tools', mode='before')
+    @classmethod
+    def validate_auth_tools(cls, v: Any) -> Optional[Auth]:
+        """Validate and deserialize auth_tools from dictionary."""
+        if v is None:
+            return None
+        if isinstance(v, Auth):
+            return v
+        if isinstance(v, dict):
+            return AuthSerializer().validate_dict(v)
+        raise ValueError(f"auth_tools must be None, Auth instance, or dict, got {type(v)}")
+
 
 class TextCallTemplateSerializer(Serializer[TextCallTemplate]):
     """REQUIRED

plugins/communication_protocols/text/tests/test_text_communication_protocol.py

@@ -372,3 +372,30 @@ async def test_text_call_template_with_auth_tools():
 
     assert template.auth_tools == auth_tools
     assert template.auth is None  # auth should still be None for file access
+
+
+@pytest.mark.asyncio
+async def test_text_call_template_auth_tools_serialization():
+    """Test that auth_tools field properly serializes and validates from dict."""
+    # Test creation from dict
+    template_dict = {
+        "name": "test-template",
+        "call_template_type": "text",
+        "file_path": "test.json",
+        "auth_tools": {
+            "auth_type": "api_key",
+            "api_key": "test-key",
+            "var_name": "Authorization",
+            "location": "header"
+        }
+    }
+    
+    template = TextCallTemplate(**template_dict)
+    assert template.auth_tools is not None
+    assert template.auth_tools.api_key == "test-key"
+    assert template.auth_tools.var_name == "Authorization"
+    
+    # Test serialization to dict
+    serialized = template.model_dump()
+    assert serialized["auth_tools"]["auth_type"] == "api_key"
+    assert serialized["auth_tools"]["api_key"] == "test-key"