Python: Fix Http Schema (#2112)

* Rename to threadid

* Respond in plain text

* Make snake-case

* Add http prefix

* rename to wait-for-response

* Add query param check

* address comments

python/packages/azurefunctions/tests/test_models.py

@@ -1,34 +1,19 @@
 # Copyright (c) Microsoft. All rights reserved.
 
-"""Unit tests for data models (AgentSessionId, RunRequest, AgentResponse, ChatRole)."""
+"""Unit tests for data models (AgentSessionId, RunRequest, AgentResponse)."""
 
 import azure.durable_functions as df
 import pytest
+from agent_framework import Role
 from pydantic import BaseModel
 
-from agent_framework_azurefunctions._models import AgentResponse, AgentSessionId, ChatRole, RunRequest
+from agent_framework_azurefunctions._models import AgentResponse, AgentSessionId, RunRequest
 
 
 class ModuleStructuredResponse(BaseModel):
     value: int
 
 
-class TestChatRole:
-    """Test suite for ChatRole enum."""
-
-    def test_chat_role_values(self) -> None:
-        """Test that ChatRole has correct values."""
-        assert ChatRole.USER == "user"
-        assert ChatRole.SYSTEM == "system"
-        assert ChatRole.ASSISTANT == "assistant"
-
-    def test_chat_role_is_string(self) -> None:
-        """Test that ChatRole values are strings."""
-        assert isinstance(ChatRole.USER.value, str)
-        assert isinstance(ChatRole.SYSTEM.value, str)
-        assert isinstance(ChatRole.ASSISTANT.value, str)
-
-
 class TestAgentSessionId:
     """Test suite for AgentSessionId."""
 
@@ -164,49 +149,55 @@ class TestRunRequest:
 
     def test_init_with_defaults(self) -> None:
         """Test RunRequest initialization with defaults."""
-        request = RunRequest(message="Hello", conversation_id="conv-default")
+        request = RunRequest(message="Hello", thread_id="thread-default")
 
         assert request.message == "Hello"
-        assert request.role == ChatRole.USER
+        assert request.role == Role.USER
         assert request.response_format is None
         assert request.enable_tool_calls is True
-        assert request.conversation_id == "conv-default"
+        assert request.thread_id == "thread-default"
 
     def test_init_with_all_fields(self) -> None:
         """Test RunRequest initialization with all fields."""
         schema = ModuleStructuredResponse
         request = RunRequest(
             message="Hello",
-            conversation_id="conv-123",
-            role=ChatRole.SYSTEM,
+            thread_id="thread-123",
+            role=Role.SYSTEM,
             response_format=schema,
             enable_tool_calls=False,
         )
 
         assert request.message == "Hello"
-        assert request.role == ChatRole.SYSTEM
+        assert request.role == Role.SYSTEM
         assert request.response_format is schema
         assert request.enable_tool_calls is False
-        assert request.conversation_id == "conv-123"
+        assert request.thread_id == "thread-123"
+
+    def test_init_coerces_string_role(self) -> None:
+        """Ensure string role values are coerced into Role instances."""
+        request = RunRequest(message="Hello", thread_id="thread-str-role", role="system")  # type: ignore[arg-type]
+
+        assert request.role == Role.SYSTEM
 
     def test_to_dict_with_defaults(self) -> None:
         """Test to_dict with default values."""
-        request = RunRequest(message="Test message", conversation_id="conv-to-dict")
+        request = RunRequest(message="Test message", thread_id="thread-to-dict")
         data = request.to_dict()
 
         assert data["message"] == "Test message"
         assert data["enable_tool_calls"] is True
         assert data["role"] == "user"
         assert "response_format" not in data or data["response_format"] is None
-        assert data["conversation_id"] == "conv-to-dict"
+        assert data["thread_id"] == "thread-to-dict"
 
     def test_to_dict_with_all_fields(self) -> None:
         """Test to_dict with all fields."""
         schema = ModuleStructuredResponse
         request = RunRequest(
             message="Hello",
-            conversation_id="conv-456",
-            role=ChatRole.ASSISTANT,
+            thread_id="thread-456",
+            role=Role.ASSISTANT,
             response_format=schema,
             enable_tool_calls=False,
         )
@@ -218,17 +209,17 @@ class TestRunRequest:
         assert data["response_format"]["module"] == schema.__module__
         assert data["response_format"]["qualname"] == schema.__qualname__
         assert data["enable_tool_calls"] is False
-        assert data["conversation_id"] == "conv-456"
+        assert data["thread_id"] == "thread-456"
 
     def test_from_dict_with_defaults(self) -> None:
         """Test from_dict with minimal data."""
-        data = {"message": "Hello", "conversation_id": "conv-from-dict"}
+        data = {"message": "Hello", "thread_id": "thread-from-dict"}
         request = RunRequest.from_dict(data)
 
         assert request.message == "Hello"
-        assert request.role == ChatRole.USER
+        assert request.role == Role.USER
         assert request.enable_tool_calls is True
-        assert request.conversation_id == "conv-from-dict"
+        assert request.thread_id == "thread-from-dict"
 
     def test_from_dict_with_all_fields(self) -> None:
         """Test from_dict with all fields."""
@@ -241,38 +232,39 @@ class TestRunRequest:
                 "qualname": ModuleStructuredResponse.__qualname__,
             },
             "enable_tool_calls": False,
-            "conversation_id": "conv-789",
+            "thread_id": "thread-789",
         }
         request = RunRequest.from_dict(data)
 
         assert request.message == "Test"
-        assert request.role == ChatRole.SYSTEM
+        assert request.role == Role.SYSTEM
         assert request.response_format is ModuleStructuredResponse
         assert request.enable_tool_calls is False
-        assert request.conversation_id == "conv-789"
+        assert request.thread_id == "thread-789"
 
-    def test_from_dict_invalid_role_defaults_to_user(self) -> None:
-        """Test from_dict with invalid role defaults to USER."""
-        data = {"message": "Test", "role": "invalid_role", "conversation_id": "conv-invalid-role"}
+    def test_from_dict_with_unknown_role_preserves_value(self) -> None:
+        """Test from_dict keeps custom roles intact."""
+        data = {"message": "Test", "role": "reviewer", "thread_id": "thread-with-custom-role"}
         request = RunRequest.from_dict(data)
 
-        assert request.role == ChatRole.USER
+        assert request.role.value == "reviewer"
+        assert request.role != Role.USER
 
     def test_from_dict_empty_message(self) -> None:
         """Test from_dict with empty message."""
-        data = {"conversation_id": "conv-empty"}
+        data = {"thread_id": "thread-empty"}
         request = RunRequest.from_dict(data)
 
         assert request.message == ""
-        assert request.role == ChatRole.USER
-        assert request.conversation_id == "conv-empty"
+        assert request.role == Role.USER
+        assert request.thread_id == "thread-empty"
 
     def test_round_trip_dict_conversion(self) -> None:
         """Test round-trip to_dict and from_dict."""
         original = RunRequest(
             message="Test message",
-            conversation_id="conv-123",
-            role=ChatRole.SYSTEM,
+            thread_id="thread-123",
+            role=Role.SYSTEM,
             response_format=ModuleStructuredResponse,
             enable_tool_calls=False,
         )
@@ -284,13 +276,13 @@ class TestRunRequest:
         assert restored.role == original.role
         assert restored.response_format is ModuleStructuredResponse
         assert restored.enable_tool_calls == original.enable_tool_calls
-        assert restored.conversation_id == original.conversation_id
+        assert restored.thread_id == original.thread_id
 
     def test_round_trip_with_pydantic_response_format(self) -> None:
         """Ensure Pydantic response formats serialize and deserialize properly."""
         original = RunRequest(
             message="Structured",
-            conversation_id="conv-pydantic",
+            thread_id="thread-pydantic",
             response_format=ModuleStructuredResponse,
         )
 
@@ -305,14 +297,14 @@ class TestRunRequest:
 
     def test_init_with_correlation_id(self) -> None:
         """Test RunRequest initialization with correlation_id."""
-        request = RunRequest(message="Test message", conversation_id="conv-corr-init", correlation_id="corr-123")
+        request = RunRequest(message="Test message", thread_id="thread-corr-init", correlation_id="corr-123")
 
         assert request.message == "Test message"
         assert request.correlation_id == "corr-123"
 
     def test_to_dict_with_correlation_id(self) -> None:
         """Test to_dict includes correlation_id."""
-        request = RunRequest(message="Test", conversation_id="conv-corr-to-dict", correlation_id="corr-456")
+        request = RunRequest(message="Test", thread_id="thread-corr-to-dict", correlation_id="corr-456")
         data = request.to_dict()
 
         assert data["message"] == "Test"
@@ -320,19 +312,19 @@ class TestRunRequest:
 
     def test_from_dict_with_correlation_id(self) -> None:
         """Test from_dict with correlation_id."""
-        data = {"message": "Test", "correlation_id": "corr-789", "conversation_id": "conv-corr-from-dict"}
+        data = {"message": "Test", "correlation_id": "corr-789", "thread_id": "thread-corr-from-dict"}
         request = RunRequest.from_dict(data)
 
         assert request.message == "Test"
         assert request.correlation_id == "corr-789"
-        assert request.conversation_id == "conv-corr-from-dict"
+        assert request.thread_id == "thread-corr-from-dict"
 
     def test_round_trip_with_correlation_id(self) -> None:
         """Test round-trip to_dict and from_dict with correlation_id."""
         original = RunRequest(
             message="Test message",
-            conversation_id="conv-123",
-            role=ChatRole.SYSTEM,
+            thread_id="thread-123",
+            role=Role.SYSTEM,
             correlation_id="corr-123",
         )
 
@@ -342,7 +334,7 @@ class TestRunRequest:
         assert restored.message == original.message
         assert restored.role == original.role
         assert restored.correlation_id == original.correlation_id
-        assert restored.conversation_id == original.conversation_id
+        assert restored.thread_id == original.thread_id
 
 
 class TestAgentResponse:
@@ -351,12 +343,12 @@ class TestAgentResponse:
     def test_init_with_required_fields(self) -> None:
         """Test AgentResponse initialization with required fields."""
         response = AgentResponse(
-            response="Test response", message="Test message", conversation_id="conv-123", status="success"
+            response="Test response", message="Test message", thread_id="thread-123", status="success"
         )
 
         assert response.response == "Test response"
         assert response.message == "Test message"
-        assert response.conversation_id == "conv-123"
+        assert response.thread_id == "thread-123"
         assert response.status == "success"
         assert response.message_count == 0
         assert response.error is None
@@ -369,7 +361,7 @@ class TestAgentResponse:
         response = AgentResponse(
             response=None,
             message="What is the answer?",
-            conversation_id="conv-456",
+            thread_id="thread-456",
             status="success",
             message_count=5,
             error=None,
@@ -384,13 +376,13 @@ class TestAgentResponse:
     def test_to_dict_with_text_response(self) -> None:
         """Test to_dict with text response."""
         response = AgentResponse(
-            response="Text response", message="Message", conversation_id="conv-1", status="success", message_count=3
+            response="Text response", message="Message", thread_id="thread-1", status="success", message_count=3
         )
         data = response.to_dict()
 
         assert data["response"] == "Text response"
         assert data["message"] == "Message"
-        assert data["conversation_id"] == "conv-1"
+        assert data["thread_id"] == "thread-1"
         assert data["status"] == "success"
         assert data["message_count"] == 3
         assert "structured_response" not in data
@@ -403,7 +395,7 @@ class TestAgentResponse:
         response = AgentResponse(
             response=None,
             message="Question",
-            conversation_id="conv-2",
+            thread_id="thread-2",
             status="success",
             structured_response=structured,
         )
@@ -417,7 +409,7 @@ class TestAgentResponse:
         response = AgentResponse(
             response=None,
             message="Failed message",
-            conversation_id="conv-3",
+            thread_id="thread-3",
             status="error",
             error="Something went wrong",
             error_type="ValueError",
@@ -434,7 +426,7 @@ class TestAgentResponse:
         response = AgentResponse(
             response="Text response",
             message="Message",
-            conversation_id="conv-4",
+            thread_id="thread-4",
             status="success",
             structured_response=structured,
         )
@@ -452,26 +444,26 @@ class TestModelIntegration:
     def test_run_request_with_session_id(self) -> None:
         """Test using RunRequest with AgentSessionId."""
         session_id = AgentSessionId.with_random_key("AgentEntity")
-        request = RunRequest(message="Test message", conversation_id=str(session_id))
+        request = RunRequest(message="Test message", thread_id=str(session_id))
 
-        assert request.conversation_id is not None
-        assert request.conversation_id == str(session_id)
-        assert request.conversation_id.startswith("@AgentEntity@")
+        assert request.thread_id is not None
+        assert request.thread_id == str(session_id)
+        assert request.thread_id.startswith("@AgentEntity@")
 
     def test_response_from_run_request(self) -> None:
         """Test creating AgentResponse from RunRequest."""
-        request = RunRequest(message="What is 2+2?", conversation_id="conv-123", role=ChatRole.USER)
+        request = RunRequest(message="What is 2+2?", thread_id="thread-123", role=Role.USER)
 
         response = AgentResponse(
             response="4",
             message=request.message,
-            conversation_id=request.conversation_id,
+            thread_id=request.thread_id,
             status="success",
             message_count=1,
         )
 
         assert response.message == request.message
-        assert response.conversation_id == request.conversation_id
+        assert response.thread_id == request.thread_id
 
 
 if __name__ == "__main__":