Python: name changes executed (#607)

* name changes executed

* updated adr to accepted

* renamed openai base config

* renamed openai config to mixin

* added renames in user docs

* reverted mcperror

* fix tests

* remove sse from tests

python/packages/workflow/tests/test_magentic.py

@@ -11,11 +11,11 @@ from agent_framework import (
     ChatMessage,
     ChatResponse,
     ChatResponseUpdate,
-    ChatRole,
+    Role,
     TextContent,
 )
-from agent_framework._agents import AgentBase
-from agent_framework._clients import ChatClient as AFChatClient
+from agent_framework._agents import BaseAgent
+from agent_framework._clients import ChatClientProtocol as AFChatClient
 
 from agent_framework_workflow import (
     Executor,
@@ -42,7 +42,7 @@ def test_magentic_start_message_from_string():
     msg = MagenticStartMessage.from_string("Do the thing")
     assert isinstance(msg, MagenticStartMessage)
     assert isinstance(msg.task, ChatMessage)
-    assert msg.task.role == ChatRole.USER
+    assert msg.task.role == Role.USER
     assert msg.task.text == "Do the thing"
 
 
@@ -67,11 +67,11 @@ def test_plan_review_request_defaults_and_reply_variants():
 
 def test_magentic_context_reset_behavior():
     ctx = MagenticContext(
-        task=ChatMessage(role=ChatRole.USER, text="task"),
+        task=ChatMessage(role=Role.USER, text="task"),
         participant_descriptions={"Alice": "Researcher"},
     )
     # seed context state
-    ctx.chat_history.append(ChatMessage(role=ChatRole.ASSISTANT, text="draft"))
+    ctx.chat_history.append(ChatMessage(role=Role.ASSISTANT, text="draft"))
     ctx.stall_count = 2
     prev_reset = ctx.reset_count
 
@@ -97,18 +97,18 @@ class FakeManager(MagenticManagerBase):
     instruction_text: str = "Proceed with step 1"
 
     async def plan(self, magentic_context: MagenticContext) -> ChatMessage:
-        facts = ChatMessage(role=ChatRole.ASSISTANT, text="GIVEN OR VERIFIED FACTS\n- A\n")
-        plan = ChatMessage(role=ChatRole.ASSISTANT, text="- Do X\n- Do Y\n")
+        facts = ChatMessage(role=Role.ASSISTANT, text="GIVEN OR VERIFIED FACTS\n- A\n")
+        plan = ChatMessage(role=Role.ASSISTANT, text="- Do X\n- Do Y\n")
         self.task_ledger = _SimpleLedger(facts=facts, plan=plan)
         combined = f"Task: {magentic_context.task.text}\n\nFacts:\n{facts.text}\n\nPlan:\n{plan.text}"
-        return ChatMessage(role=ChatRole.ASSISTANT, text=combined, author_name="magentic_manager")
+        return ChatMessage(role=Role.ASSISTANT, text=combined, author_name="magentic_manager")
 
     async def replan(self, magentic_context: MagenticContext) -> ChatMessage:
-        facts = ChatMessage(role=ChatRole.ASSISTANT, text="GIVEN OR VERIFIED FACTS\n- A2\n")
-        plan = ChatMessage(role=ChatRole.ASSISTANT, text="- Do Z\n")
+        facts = ChatMessage(role=Role.ASSISTANT, text="GIVEN OR VERIFIED FACTS\n- A2\n")
+        plan = ChatMessage(role=Role.ASSISTANT, text="- Do Z\n")
         self.task_ledger = _SimpleLedger(facts=facts, plan=plan)
         combined = f"Task: {magentic_context.task.text}\n\nFacts:\n{facts.text}\n\nPlan:\n{plan.text}"
-        return ChatMessage(role=ChatRole.ASSISTANT, text=combined, author_name="magentic_manager")
+        return ChatMessage(role=Role.ASSISTANT, text=combined, author_name="magentic_manager")
 
     async def create_progress_ledger(self, magentic_context: MagenticContext) -> MagenticProgressLedger:
         is_satisfied = self.satisfied_after_signoff and len(magentic_context.chat_history) > 0
@@ -121,18 +121,18 @@ class FakeManager(MagenticManagerBase):
         )
 
     async def prepare_final_answer(self, magentic_context: MagenticContext) -> ChatMessage:
-        return ChatMessage(role=ChatRole.ASSISTANT, text="FINAL", author_name="magentic_manager")
+        return ChatMessage(role=Role.ASSISTANT, text="FINAL", author_name="magentic_manager")
 
 
 async def test_standard_manager_plan_and_replan_combined_ledger():
     manager = FakeManager(max_round_count=10, max_stall_count=3, max_reset_count=2)
     ctx = MagenticContext(
-        task=ChatMessage(role=ChatRole.USER, text="demo task"),
+        task=ChatMessage(role=Role.USER, text="demo task"),
         participant_descriptions={"agentA": "Agent A"},
     )
 
     first = await manager.plan(ctx.model_copy(deep=True))
-    assert first.role == ChatRole.ASSISTANT and "Facts:" in first.text and "Plan:" in first.text
+    assert first.role == Role.ASSISTANT and "Facts:" in first.text and "Plan:" in first.text
     assert manager.task_ledger is not None
 
     replanned = await manager.replan(ctx.model_copy(deep=True))
@@ -142,7 +142,7 @@ async def test_standard_manager_plan_and_replan_combined_ledger():
 async def test_standard_manager_progress_ledger_and_fallback():
     manager = FakeManager(max_round_count=10)
     ctx = MagenticContext(
-        task=ChatMessage(role=ChatRole.USER, text="demo"),
+        task=ChatMessage(role=Role.USER, text="demo"),
         participant_descriptions={"agentA": "Agent A"},
     )
 
@@ -166,7 +166,7 @@ async def test_magentic_workflow_plan_review_approval_to_completion():
     )
 
     req_event: RequestInfoEvent | None = None
-    async for ev in wf.run_streaming("do work"):
+    async for ev in wf.run_stream("do work"):
         if isinstance(ev, RequestInfoEvent) and ev.request_type is MagenticPlanReviewRequest:
             req_event = ev
     assert req_event is not None
@@ -205,7 +205,7 @@ async def test_magentic_plan_review_approve_with_comments_replans_and_proceeds()
 
     # Wait for the initial plan review request
     req_event: RequestInfoEvent | None = None
-    async for ev in wf.run_streaming("do work"):
+    async for ev in wf.run_stream("do work"):
         if isinstance(ev, RequestInfoEvent) and ev.request_type is MagenticPlanReviewRequest:
             req_event = ev
     assert req_event is not None
@@ -242,7 +242,7 @@ async def test_magentic_orchestrator_round_limit_produces_partial_result():
     from agent_framework_workflow import WorkflowEvent  # type: ignore
 
     events: list[WorkflowEvent] = []
-    async for ev in wf.run_streaming("round limit test"):
+    async for ev in wf.run_stream("round limit test"):
         events.append(ev)
         if len(events) > 50:
             break
@@ -251,7 +251,7 @@ async def test_magentic_orchestrator_round_limit_produces_partial_result():
     assert completed is not None
     data = getattr(completed, "data", None)
     assert isinstance(data, ChatMessage)
-    assert data.role == ChatRole.ASSISTANT
+    assert data.role == Role.ASSISTANT
 
 
 class _DummyExec(Executor):
@@ -268,7 +268,7 @@ from agent_framework_workflow import StandardMagenticManager  # noqa: E402
 
 class _StubChatClient(AFChatClient):
     async def get_response(self, messages, **kwargs):  # type: ignore[override]
-        return ChatResponse(messages=[ChatMessage(role=ChatRole.ASSISTANT, text="ok")])
+        return ChatResponse(messages=[ChatMessage(role=Role.ASSISTANT, text="ok")])
 
     def get_streaming_response(self, messages, **kwargs) -> AsyncIterable[ChatResponseUpdate]:  # type: ignore[override]
         async def _gen():
@@ -284,14 +284,14 @@ async def test_standard_manager_plan_and_replan_via_complete_monkeypatch():
     async def fake_complete_plan(messages: list[ChatMessage], **kwargs: Any) -> ChatMessage:
         # Return a different response depending on call order length
         if any("FACTS" in (m.text or "") for m in messages):
-            return ChatMessage(role=ChatRole.ASSISTANT, text="- step A\n- step B")
-        return ChatMessage(role=ChatRole.ASSISTANT, text="GIVEN OR VERIFIED FACTS\n- fact1")
+            return ChatMessage(role=Role.ASSISTANT, text="- step A\n- step B")
+        return ChatMessage(role=Role.ASSISTANT, text="GIVEN OR VERIFIED FACTS\n- fact1")
 
     # First, patch to produce facts then plan
     mgr._complete = fake_complete_plan  # type: ignore[attr-defined]
 
     ctx = MagenticContext(
-        task=ChatMessage(role=ChatRole.USER, text="T"),
+        task=ChatMessage(role=Role.USER, text="T"),
         participant_descriptions={"A": "desc"},
     )
     combined = await mgr.plan(ctx.model_copy(deep=True))
@@ -303,8 +303,8 @@ async def test_standard_manager_plan_and_replan_via_complete_monkeypatch():
     # Now replan with new outputs
     async def fake_complete_replan(messages: list[ChatMessage], **kwargs: Any) -> ChatMessage:
         if any("Please briefly explain" in (m.text or "") for m in messages):
-            return ChatMessage(role=ChatRole.ASSISTANT, text="- new step")
-        return ChatMessage(role=ChatRole.ASSISTANT, text="GIVEN OR VERIFIED FACTS\n- updated")
+            return ChatMessage(role=Role.ASSISTANT, text="- new step")
+        return ChatMessage(role=Role.ASSISTANT, text="GIVEN OR VERIFIED FACTS\n- updated")
 
     mgr._complete = fake_complete_replan  # type: ignore[attr-defined]
     combined2 = await mgr.replan(ctx.model_copy(deep=True))
@@ -314,7 +314,7 @@ async def test_standard_manager_plan_and_replan_via_complete_monkeypatch():
 async def test_standard_manager_progress_ledger_success_and_error():
     mgr = StandardMagenticManager(chat_client=_StubChatClient())
     ctx = MagenticContext(
-        task=ChatMessage(role=ChatRole.USER, text="task"),
+        task=ChatMessage(role=Role.USER, text="task"),
         participant_descriptions={"alice": "desc"},
     )
 
@@ -327,7 +327,7 @@ async def test_standard_manager_progress_ledger_success_and_error():
             '"next_speaker": {"reason": "r", "answer": "alice"}, '
             '"instruction_or_question": {"reason": "r", "answer": "do"}}'
         )
-        return ChatMessage(role=ChatRole.ASSISTANT, text=json_text)
+        return ChatMessage(role=Role.ASSISTANT, text=json_text)
 
     mgr._complete = fake_complete_ok  # type: ignore[attr-defined]
     ledger = await mgr.create_progress_ledger(ctx.model_copy(deep=True))
@@ -335,7 +335,7 @@ async def test_standard_manager_progress_ledger_success_and_error():
 
     # Error path: invalid JSON now raises to avoid emitting planner-oriented instructions to agents
     async def fake_complete_bad(messages: list[ChatMessage], **kwargs: Any) -> ChatMessage:
-        return ChatMessage(role=ChatRole.ASSISTANT, text="not-json")
+        return ChatMessage(role=Role.ASSISTANT, text="not-json")
 
     mgr._complete = fake_complete_bad  # type: ignore[attr-defined]
     with pytest.raises(RuntimeError):
@@ -348,10 +348,10 @@ class InvokeOnceManager(MagenticManagerBase):
         self._invoked = False
 
     async def plan(self, magentic_context: MagenticContext) -> ChatMessage:
-        return ChatMessage(role=ChatRole.ASSISTANT, text="ledger")
+        return ChatMessage(role=Role.ASSISTANT, text="ledger")
 
     async def replan(self, magentic_context: MagenticContext) -> ChatMessage:
-        return ChatMessage(role=ChatRole.ASSISTANT, text="re-ledger")
+        return ChatMessage(role=Role.ASSISTANT, text="re-ledger")
 
     async def create_progress_ledger(self, magentic_context: MagenticContext) -> MagenticProgressLedger:
         if not self._invoked:
@@ -374,43 +374,41 @@ class InvokeOnceManager(MagenticManagerBase):
         )
 
     async def prepare_final_answer(self, magentic_context: MagenticContext) -> ChatMessage:
-        return ChatMessage(role=ChatRole.ASSISTANT, text="final")
+        return ChatMessage(role=Role.ASSISTANT, text="final")
 
 
-class StubThreadAgent(AgentBase):
-    async def run_streaming(self, messages=None, *, thread=None, **kwargs):  # type: ignore[override]
+class StubThreadAgent(BaseAgent):
+    async def run_stream(self, messages=None, *, thread=None, **kwargs):  # type: ignore[override]
         yield AgentRunResponseUpdate(
             contents=[TextContent(text="thread-ok")],
             author_name="agentA",
-            role=ChatRole.ASSISTANT,
+            role=Role.ASSISTANT,
         )
 
     async def run(self, messages=None, *, thread=None, **kwargs):  # type: ignore[override]
-        return AgentRunResponse(messages=[ChatMessage(role=ChatRole.ASSISTANT, text="thread-ok", author_name="agentA")])
+        return AgentRunResponse(messages=[ChatMessage(role=Role.ASSISTANT, text="thread-ok", author_name="agentA")])
 
 
 class StubAssistantsClient:
     pass  # class name used for branch detection
 
 
-class StubAssistantsAgent(AgentBase):
+class StubAssistantsAgent(BaseAgent):
     chat_client: object | None = None  # allow assignment via Pydantic field
 
     def __init__(self) -> None:
         super().__init__()
         self.chat_client = StubAssistantsClient()  # type name contains 'AssistantsClient'
 
-    async def run_streaming(self, messages=None, *, thread=None, **kwargs):  # type: ignore[override]
+    async def run_stream(self, messages=None, *, thread=None, **kwargs):  # type: ignore[override]
         yield AgentRunResponseUpdate(
             contents=[TextContent(text="assistants-ok")],
             author_name="agentA",
-            role=ChatRole.ASSISTANT,
+            role=Role.ASSISTANT,
         )
 
     async def run(self, messages=None, *, thread=None, **kwargs):  # type: ignore[override]
-        return AgentRunResponse(
-            messages=[ChatMessage(role=ChatRole.ASSISTANT, text="assistants-ok", author_name="agentA")]
-        )
+        return AgentRunResponse(messages=[ChatMessage(role=Role.ASSISTANT, text="assistants-ok", author_name="agentA")])
 
 
 async def _collect_agent_responses_setup(participant_obj: object):
@@ -432,7 +430,7 @@ async def _collect_agent_responses_setup(participant_obj: object):
 
     # Run a bounded stream to allow one invoke and then completion
     events: list[WorkflowEvent] = []
-    async for ev in wf.run_streaming("task"):  # plan review disabled
+    async for ev in wf.run_stream("task"):  # plan review disabled
         events.append(ev)
         if len(events) > 50:
             break

python/packages/workflow/tests/test_tracing.py

@@ -343,7 +343,7 @@ async def test_end_to_end_workflow_tracing(tracing_enabled: Any, span_exporter:
 
     # Run workflow (this should create run spans)
     events = []
-    async for event in workflow.run_streaming("test input"):
+    async for event in workflow.run_stream("test input"):
         events.append(event)
 
     # Verify workflow executed correctly
@@ -444,7 +444,7 @@ async def test_workflow_error_handling_in_tracing(tracing_enabled: Any, span_exp
 
     # Run workflow and expect error
     with pytest.raises(ValueError, match="Test error"):
-        async for _ in workflow.run_streaming("test input"):
+        async for _ in workflow.run_stream("test input"):
             pass
 
     spans = span_exporter.get_finished_spans()

python/packages/workflow/tests/test_workflow.py

@@ -95,7 +95,7 @@ async def test_workflow_run_streaming():
     )
 
     result: int | None = None
-    async for event in workflow.run_streaming(NumberMessage(data=0)):
+    async for event in workflow.run_stream(NumberMessage(data=0)):
         assert isinstance(event, WorkflowEvent)
         if isinstance(event, WorkflowCompletedEvent):
             result = event.data
@@ -118,7 +118,7 @@ async def test_workflow_run_stream_not_completed():
     )
 
     with pytest.raises(RuntimeError):
-        async for _ in workflow.run_streaming(NumberMessage(data=0)):
+        async for _ in workflow.run_stream(NumberMessage(data=0)):
             pass
 
 
@@ -176,7 +176,7 @@ async def test_workflow_send_responses_streaming():
     )
 
     request_info_event: RequestInfoEvent | None = None
-    async for event in workflow.run_streaming(NumberMessage(data=0)):
+    async for event in workflow.run_stream(NumberMessage(data=0)):
         if isinstance(event, RequestInfoEvent):
             request_info_event = event
 
@@ -326,7 +326,7 @@ async def test_workflow_checkpointing_not_enabled_for_external_restore(simple_ex
 
     # Attempt to restore from checkpoint without providing external storage should fail
     try:
-        [event async for event in workflow.run_streaming_from_checkpoint("fake-checkpoint-id")]
+        [event async for event in workflow.run_stream_from_checkpoint("fake-checkpoint-id")]
         raise AssertionError("Expected ValueError to be raised")
     except ValueError as e:
         assert "Cannot restore from checkpoint" in str(e)
@@ -344,7 +344,7 @@ async def test_workflow_run_stream_from_checkpoint_no_checkpointing_enabled(simp
 
     # Attempt to run from checkpoint should fail
     try:
-        async for _ in workflow.run_streaming_from_checkpoint("fake_checkpoint_id"):
+        async for _ in workflow.run_stream_from_checkpoint("fake_checkpoint_id"):
             pass
         raise AssertionError("Expected ValueError to be raised")
     except ValueError as e:
@@ -368,7 +368,7 @@ async def test_workflow_run_stream_from_checkpoint_invalid_checkpoint(simple_exe
 
         # Attempt to run from non-existent checkpoint should fail
         try:
-            async for _ in workflow.run_streaming_from_checkpoint("nonexistent_checkpoint_id"):
+            async for _ in workflow.run_stream_from_checkpoint("nonexistent_checkpoint_id"):
                 pass
             raise AssertionError("Expected RuntimeError to be raised")
         except RuntimeError as e:
@@ -401,7 +401,7 @@ async def test_workflow_run_stream_from_checkpoint_with_external_storage(simple_
         # Resume from checkpoint using external storage parameter
         try:
             events: list[WorkflowEvent] = []
-            async for event in workflow_without_checkpointing.run_streaming_from_checkpoint(
+            async for event in workflow_without_checkpointing.run_stream_from_checkpoint(
                 checkpoint_id, checkpoint_storage=storage
             ):
                 events.append(event)
@@ -446,7 +446,7 @@ async def test_workflow_run_from_checkpoint_non_streaming(simple_executor: Execu
 
 
 async def test_workflow_run_stream_from_checkpoint_with_responses(simple_executor: Executor):
-    """Test that run_streaming_from_checkpoint accepts responses parameter."""
+    """Test that run_stream_from_checkpoint accepts responses parameter."""
     with tempfile.TemporaryDirectory() as temp_dir:
         storage = FileCheckpointStorage(temp_dir)
 
@@ -477,7 +477,7 @@ async def test_workflow_run_stream_from_checkpoint_with_responses(simple_executo
 
         try:
             events: list[WorkflowEvent] = []
-            async for event in workflow.run_streaming_from_checkpoint(checkpoint_id, responses=responses):
+            async for event in workflow.run_stream_from_checkpoint(checkpoint_id, responses=responses):
                 events.append(event)
                 if len(events) >= 2:  # Limit to avoid infinite loops
                     break

python/packages/workflow/tests/test_workflow_agent.py

@@ -8,8 +8,8 @@ from agent_framework import (
     AgentRunResponse,
     AgentRunResponseUpdate,
     ChatMessage,
-    ChatRole,
     FunctionResultContent,
+    Role,
     TextContent,
     UsageContent,
     UsageDetails,
@@ -43,11 +43,11 @@ class SimpleExecutor(Executor):
         response_text = f"{self.response_text}: {input_text}"
 
         # Create response message for both streaming and non-streaming cases
-        response_message = ChatMessage(role=ChatRole.ASSISTANT, contents=[TextContent(text=response_text)])
+        response_message = ChatMessage(role=Role.ASSISTANT, contents=[TextContent(text=response_text)])
 
         # Emit update event.
         streaming_update = AgentRunResponseUpdate(
-            contents=[TextContent(text=response_text)], role=ChatRole.ASSISTANT, message_id=str(uuid.uuid4())
+            contents=[TextContent(text=response_text)], role=Role.ASSISTANT, message_id=str(uuid.uuid4())
         )
         await ctx.add_event(AgentRunUpdateEvent(executor_id=self.id, data=streaming_update))
 
@@ -68,7 +68,7 @@ class RequestingExecutor(Executor):
         # Handle the response and emit completion response
         update = AgentRunResponseUpdate(
             contents=[TextContent(text="Request completed successfully")],
-            role=ChatRole.ASSISTANT,
+            role=Role.ASSISTANT,
             message_id=str(uuid.uuid4()),
         )
         await ctx.add_event(AgentRunUpdateEvent(executor_id=self.id, data=update))
@@ -132,7 +132,7 @@ class TestWorkflowAgent:
 
         # Execute workflow streaming to capture streaming events
         updates = []
-        async for update in agent.run_streaming("Test input"):
+        async for update in agent.run_stream("Test input"):
             updates.append(update)
 
         # Should have received at least one streaming update
@@ -165,7 +165,7 @@ class TestWorkflowAgent:
 
         # Execute workflow streaming to get request info event
         updates = []
-        async for update in agent.run_streaming("Start request"):
+        async for update in agent.run_stream("Start request"):
             updates.append(update)
         # Should have received a function call for the request info
         assert len(updates) > 0
@@ -192,7 +192,7 @@ class TestWorkflowAgent:
 
         # Now provide a function result response to test continuation
         response_message = ChatMessage(
-            role=ChatRole.USER,
+            role=Role.USER,
             contents=[FunctionResultContent(call_id=function_call.call_id, result="User provided answer")],
         )
 
@@ -252,7 +252,7 @@ class TestWorkflowAgentMergeUpdates:
             # Response B, Message 2 (latest in resp B)
             AgentRunResponseUpdate(
                 contents=[TextContent(text="RespB-Msg2")],
-                role=ChatRole.ASSISTANT,
+                role=Role.ASSISTANT,
                 response_id="resp-b",
                 message_id="msg-2",
                 created_at="2024-01-01T12:02:00Z",
@@ -260,7 +260,7 @@ class TestWorkflowAgentMergeUpdates:
             # Response A, Message 1 (earliest overall)
             AgentRunResponseUpdate(
                 contents=[TextContent(text="RespA-Msg1")],
-                role=ChatRole.ASSISTANT,
+                role=Role.ASSISTANT,
                 response_id="resp-a",
                 message_id="msg-1",
                 created_at="2024-01-01T12:00:00Z",
@@ -268,7 +268,7 @@ class TestWorkflowAgentMergeUpdates:
             # Response B, Message 1 (earlier in resp B)
             AgentRunResponseUpdate(
                 contents=[TextContent(text="RespB-Msg1")],
-                role=ChatRole.ASSISTANT,
+                role=Role.ASSISTANT,
                 response_id="resp-b",
                 message_id="msg-1",
                 created_at="2024-01-01T12:01:00Z",
@@ -276,7 +276,7 @@ class TestWorkflowAgentMergeUpdates:
             # Response A, Message 2 (later in resp A)
             AgentRunResponseUpdate(
                 contents=[TextContent(text="RespA-Msg2")],
-                role=ChatRole.ASSISTANT,
+                role=Role.ASSISTANT,
                 response_id="resp-a",
                 message_id="msg-2",
                 created_at="2024-01-01T12:00:30Z",
@@ -284,7 +284,7 @@ class TestWorkflowAgentMergeUpdates:
             # Global dangling update (no response_id) - should go at end
             AgentRunResponseUpdate(
                 contents=[TextContent(text="Global-Dangling")],
-                role=ChatRole.ASSISTANT,
+                role=Role.ASSISTANT,
                 response_id=None,
                 message_id="msg-global",
                 created_at="2024-01-01T11:59:00Z",  # Earliest timestamp but should be last
@@ -360,7 +360,7 @@ class TestWorkflowAgentMergeUpdates:
                         details=UsageDetails(input_token_count=10, output_token_count=5, total_token_count=15)
                     ),
                 ],
-                role=ChatRole.ASSISTANT,
+                role=Role.ASSISTANT,
                 response_id="resp-1",
                 message_id="msg-1",
                 created_at="2024-01-01T12:00:00Z",
@@ -373,7 +373,7 @@ class TestWorkflowAgentMergeUpdates:
                         details=UsageDetails(input_token_count=20, output_token_count=8, total_token_count=28)
                     ),
                 ],
-                role=ChatRole.ASSISTANT,
+                role=Role.ASSISTANT,
                 response_id="resp-2",
                 message_id="msg-2",
                 created_at="2024-01-01T12:01:00Z",  # Later timestamp
@@ -384,7 +384,7 @@ class TestWorkflowAgentMergeUpdates:
                     TextContent(text="Third"),
                     UsageContent(details=UsageDetails(input_token_count=5, output_token_count=3, total_token_count=8)),
                 ],
-                role=ChatRole.ASSISTANT,
+                role=Role.ASSISTANT,
                 response_id="resp-1",  # Same response_id as first
                 message_id="msg-3",
                 created_at="2024-01-01T11:59:00Z",  # Earlier timestamp