Python: (samples): adopt AzureOpenAIResponsesClient, reorganize orchestration examples, and fix workflow/orchestration bugs (#3873)

* adopt AzureOpenAIResponsesClient, reorganize orchestration examples, and fix workflow/orchestration bugs

* Updates

* add comment

python/samples/getting_started/workflows/human-in-the-loop/agents_with_HITL.py

@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 import asyncio
+import os
 from collections.abc import AsyncIterable
 from dataclasses import dataclass, field
 
@@ -17,7 +18,7 @@ from agent_framework import (
     handler,
     response_handler,
 )
-from agent_framework.azure import AzureOpenAIChatClient
+from agent_framework.azure import AzureOpenAIResponsesClient
 from azure.identity import AzureCliCredential
 from typing_extensions import Never
 
@@ -37,7 +38,8 @@ Demonstrates:
 - Handling human feedback and routing it to the appropriate agents.
 
 Prerequisites:
-- Azure OpenAI configured for AzureOpenAIChatClient with required environment variables.
+- AZURE_AI_PROJECT_ENDPOINT must be your Azure AI Foundry Agent Service (V2) project endpoint.
+- Azure OpenAI configured for AzureOpenAIResponsesClient with required environment variables.
 - Authentication via azure-identity. Run `az login` before executing.
 """
 
@@ -161,13 +163,21 @@ async def process_event_stream(stream: AsyncIterable[WorkflowEvent]) -> dict[str
 async def main() -> None:
     """Run the workflow and bridge human feedback between two agents."""
     # Create the agents
-    writer_agent = AzureOpenAIChatClient(credential=AzureCliCredential()).as_agent(
+    writer_agent = AzureOpenAIResponsesClient(
+        project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
+        deployment_name=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=AzureCliCredential(),
+    ).as_agent(
         name="writer_agent",
         instructions=("You are a marketing writer."),
         tool_choice="required",
     )
 
-    final_editor_agent = AzureOpenAIChatClient(credential=AzureCliCredential()).as_agent(
+    final_editor_agent = AzureOpenAIResponsesClient(
+        project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
+        deployment_name=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=AzureCliCredential(),
+    ).as_agent(
         name="final_editor_agent",
         instructions=(
             "You are an editor who polishes marketing copy after human approval. "

python/samples/getting_started/workflows/human-in-the-loop/agents_with_approval_requests.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import json
+import os
 from dataclasses import dataclass
 from typing import Annotated
 
@@ -15,7 +16,8 @@ from agent_framework import (
     handler,
     tool,
 )
-from agent_framework.openai import OpenAIChatClient
+from agent_framework.azure import AzureOpenAIResponsesClient
+from azure.identity import AzureCliCredential
 from typing_extensions import Never
 
 """
@@ -45,6 +47,7 @@ Demonstrate:
 - Handling approval requests during workflow execution.
 
 Prerequisites:
+- AZURE_AI_PROJECT_ENDPOINT must be your Azure AI Foundry Agent Service (V2) project endpoint.
 - Azure AI Agent Service configured, along with the required environment variables.
 - Authentication via azure-identity. Use AzureCliCredential and run az login before executing the sample.
 - Basic familiarity with WorkflowBuilder, edges, events, request_info events (type='request_info'), and streaming runs.
@@ -193,13 +196,20 @@ class EmailPreprocessor(Executor):
     @handler
     async def preprocess(self, email: Email, ctx: WorkflowContext[str]) -> None:
         """Preprocess the incoming email."""
-        message = str(email)
+        email_payload = (
+            f"Incoming email:\n"
+            f"From: {email.sender}\n"
+            f"Subject: {email.subject}\n"
+            f"Body: {email.body}"
+        )
+        message = email_payload
         if email.sender in self.special_email_addresses:
             note = (
-                "Pay special attention to this sender. This email is very important. "
-                "Gather relevant information from all previous emails within my team before responding."
+                "Priority sender context: this message is business-critical. "
+                "If additional context is needed, use available tools to retrieve only the minimum relevant "
+                "prior team communication related to this request."
             )
-            message = f"{note}\n\n{message}"
+            message = f"{note}\n\n{email_payload}"
 
         await ctx.send_message(message)
 
@@ -215,7 +225,11 @@ async def conclude_workflow(
 
 async def main() -> None:
     # Create agent
-    email_writer_agent = OpenAIChatClient().as_agent(
+    email_writer_agent = AzureOpenAIResponsesClient(
+        project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
+        deployment_name=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=AzureCliCredential(),
+    ).as_agent(
         name="EmailWriter",
         instructions=("You are an excellent email assistant. You respond to incoming emails."),
         # tools with `approval_mode="always_require"` will trigger approval requests

python/samples/getting_started/workflows/human-in-the-loop/agents_with_declaration_only_tools.py

@@ -16,16 +16,18 @@ Flow:
   4. The workflow resumes — the agent sees the tool result and finishes.
 
 Prerequisites:
+  - AZURE_AI_PROJECT_ENDPOINT must be your Azure AI Foundry Agent Service (V2) project endpoint.
   - Azure OpenAI endpoint configured via environment variables.
   - `az login` for AzureCliCredential.
 """
 
 import asyncio
 import json
+import os
 from typing import Any
 
 from agent_framework import Content, FunctionTool, WorkflowBuilder
-from agent_framework.azure import AzureOpenAIChatClient
+from agent_framework.azure import AzureOpenAIResponsesClient
 from azure.identity import AzureCliCredential
 
 # A declaration-only tool: the schema is sent to the LLM, but the framework
@@ -45,7 +47,11 @@ get_user_location = FunctionTool(
 
 
 async def main() -> None:
-    agent = AzureOpenAIChatClient(credential=AzureCliCredential()).as_agent(
+    agent = AzureOpenAIResponsesClient(
+        project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
+        deployment_name=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=AzureCliCredential(),
+    ).as_agent(
         name="WeatherBot",
         instructions=(
             "You are a helpful weather assistant. "

python/samples/getting_started/workflows/human-in-the-loop/concurrent_request_info.py

@@ -1,197 +0,0 @@
-# Copyright (c) Microsoft. All rights reserved.
-
-"""
-Sample: Request Info with ConcurrentBuilder
-
-This sample demonstrates using the `.with_request_info()` method to pause a
-ConcurrentBuilder workflow for specific agents, allowing human review and
-modification of individual agent outputs before aggregation.
-
-Purpose:
-Show how to use the request info API that pauses for selected concurrent agents,
-allowing review and steering of their results.
-
-Demonstrate:
-- Configuring request info with `.with_request_info()` for specific agents
-- Reviewing output from individual agents during concurrent execution
-- Injecting human guidance for specific agents before aggregation
-
-Prerequisites:
-- Azure OpenAI configured for AzureOpenAIChatClient with required environment variables
-- Authentication via azure-identity (run az login before executing)
-"""
-
-import asyncio
-from collections.abc import AsyncIterable
-from typing import Any
-
-from agent_framework import (
-    AgentExecutorResponse,
-    Message,
-    WorkflowEvent,
-)
-from agent_framework.azure import AzureOpenAIChatClient
-from agent_framework.orchestrations import AgentRequestInfoResponse, ConcurrentBuilder
-from azure.identity import AzureCliCredential
-
-# Store chat client at module level for aggregator access
-_chat_client: AzureOpenAIChatClient | None = None
-
-
-async def aggregate_with_synthesis(results: list[AgentExecutorResponse]) -> Any:
-    """Custom aggregator that synthesizes concurrent agent outputs using an LLM.
-
-    This aggregator extracts the outputs from each parallel agent and uses the
-    chat client to create a unified summary, incorporating any human feedback
-    that was injected into the conversation.
-
-    Args:
-        results: List of responses from all concurrent agents
-
-    Returns:
-        The synthesized summary text
-    """
-    if not _chat_client:
-        return "Error: Chat client not initialized"
-
-    # Extract each agent's final output
-    expert_sections: list[str] = []
-    human_guidance = ""
-
-    for r in results:
-        try:
-            messages = getattr(r.agent_response, "messages", [])
-            final_text = messages[-1].text if messages and hasattr(messages[-1], "text") else "(no content)"
-            expert_sections.append(f"{getattr(r, 'executor_id', 'analyst')}:\n{final_text}")
-
-            # Check for human feedback in the conversation (will be last user message if present)
-            if r.full_conversation:
-                for msg in reversed(r.full_conversation):
-                    if msg.role == "user" and msg.text and "perspectives" not in msg.text.lower():
-                        human_guidance = msg.text
-                        break
-        except Exception:
-            expert_sections.append(f"{getattr(r, 'executor_id', 'analyst')}: (error extracting output)")
-
-    # Build prompt with human guidance if provided
-    guidance_text = f"\n\nHuman guidance: {human_guidance}" if human_guidance else ""
-
-    system_msg = Message(
-        "system",
-        text=(
-            "You are a synthesis expert. Consolidate the following analyst perspectives "
-            "into one cohesive, balanced summary (3-4 sentences). If human guidance is provided, "
-            "prioritize aspects as directed."
-        ),
-    )
-    user_msg = Message("user", text="\n\n".join(expert_sections) + guidance_text)
-
-    response = await _chat_client.get_response([system_msg, user_msg])
-    return response.messages[-1].text if response.messages else ""
-
-
-async def process_event_stream(stream: AsyncIterable[WorkflowEvent]) -> dict[str, AgentRequestInfoResponse] | None:
-    """Process events from the workflow stream to capture human feedback requests."""
-
-    requests: dict[str, AgentExecutorResponse] = {}
-    async for event in stream:
-        if event.type == "request_info" and isinstance(event.data, AgentExecutorResponse):
-            requests[event.request_id] = event.data
-
-        if event.type == "output":
-            # The output of the workflow comes from the aggregator and it's a single string
-            print("\n" + "=" * 60)
-            print("ANALYSIS COMPLETE")
-            print("=" * 60)
-            print("Final synthesized analysis:")
-            print(event.data)
-
-    # Process any requests for human feedback
-    responses: dict[str, AgentRequestInfoResponse] = {}
-    if requests:
-        for request_id, request in requests.items():
-            print("\n" + "-" * 40)
-            print("INPUT REQUESTED")
-            print(
-                f"Agent {request.executor_id} just responded with: '{request.agent_response.text}'. "
-                "Please provide your feedback."
-            )
-            print("-" * 40)
-            if request.full_conversation:
-                print("Conversation context:")
-                recent = (
-                    request.full_conversation[-2:] if len(request.full_conversation) > 2 else request.full_conversation
-                )
-                for msg in recent:
-                    name = msg.author_name or msg.role
-                    text = (msg.text or "")[:150]
-                    print(f"  [{name}]: {text}...")
-                print("-" * 40)
-
-            # Get human input to steer this agent's contribution
-            user_input = input("Your guidance for the analysts (or 'skip' to approve): ")  # noqa: ASYNC250
-            if user_input.lower() == "skip":
-                user_input = AgentRequestInfoResponse.approve()
-            else:
-                user_input = AgentRequestInfoResponse.from_strings([user_input])
-
-            responses[request_id] = user_input
-
-    return responses if responses else None
-
-
-async def main() -> None:
-    global _chat_client
-    _chat_client = AzureOpenAIChatClient(credential=AzureCliCredential())
-
-    # Create agents that analyze from different perspectives
-    technical_analyst = _chat_client.as_agent(
-        name="technical_analyst",
-        instructions=(
-            "You are a technical analyst. When given a topic, provide a technical "
-            "perspective focusing on implementation details, performance, and architecture. "
-            "Keep your analysis to 2-3 sentences."
-        ),
-    )
-
-    business_analyst = _chat_client.as_agent(
-        name="business_analyst",
-        instructions=(
-            "You are a business analyst. When given a topic, provide a business "
-            "perspective focusing on ROI, market impact, and strategic value. "
-            "Keep your analysis to 2-3 sentences."
-        ),
-    )
-
-    user_experience_analyst = _chat_client.as_agent(
-        name="ux_analyst",
-        instructions=(
-            "You are a UX analyst. When given a topic, provide a user experience "
-            "perspective focusing on usability, accessibility, and user satisfaction. "
-            "Keep your analysis to 2-3 sentences."
-        ),
-    )
-
-    # Build workflow with request info enabled and custom aggregator
-    workflow = (
-        ConcurrentBuilder(participants=[technical_analyst, business_analyst, user_experience_analyst])
-        .with_aggregator(aggregate_with_synthesis)
-        # Only enable request info for the technical analyst agent
-        .with_request_info(agents=["technical_analyst"])
-        .build()
-    )
-
-    # Initiate the first run of the workflow.
-    # Runs are not isolated; state is preserved across multiple calls to run.
-    stream = workflow.run("Analyze the impact of large language models on software development.", stream=True)
-
-    pending_responses = await process_event_stream(stream)
-    while pending_responses is not None:
-        # Run the workflow until there is no more human feedback to provide,
-        # in which case this workflow completes.
-        stream = workflow.run(stream=True, responses=pending_responses)
-        pending_responses = await process_event_stream(stream)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

python/samples/getting_started/workflows/human-in-the-loop/group_chat_request_info.py

@@ -1,168 +0,0 @@
-# Copyright (c) Microsoft. All rights reserved.
-
-"""
-Sample: Request Info with GroupChatBuilder
-
-This sample demonstrates using the `.with_request_info()` method to pause a
-GroupChatBuilder workflow BEFORE specific participants speak. By using the
-`agents=` filter parameter, you can target only certain participants rather
-than pausing before every turn.
-
-Purpose:
-Show how to use the request info API with selective filtering to pause before
-specific participants speak, allowing human input to steer their response.
-
-Demonstrate:
-- Configuring request info with `.with_request_info(agents=[...])`
-- Using agent filtering to reduce interruptions
-- Steering agent behavior with pre-agent human input
-
-Prerequisites:
-- Azure OpenAI configured for AzureOpenAIChatClient with required environment variables
-- Authentication via azure-identity (run az login before executing)
-"""
-
-import asyncio
-from collections.abc import AsyncIterable
-from typing import cast
-
-from agent_framework import (
-    AgentExecutorResponse,
-    Message,
-    WorkflowEvent,
-)
-from agent_framework.azure import AzureOpenAIChatClient
-from agent_framework.orchestrations import AgentRequestInfoResponse, GroupChatBuilder
-from azure.identity import AzureCliCredential
-
-
-async def process_event_stream(stream: AsyncIterable[WorkflowEvent]) -> dict[str, AgentRequestInfoResponse] | None:
-    """Process events from the workflow stream to capture human feedback requests."""
-
-    requests: dict[str, AgentExecutorResponse] = {}
-    async for event in stream:
-        if event.type == "request_info" and isinstance(event.data, AgentExecutorResponse):
-            requests[event.request_id] = event.data
-
-        if event.type == "output":
-            # The output of the workflow comes from the orchestrator and it's a list of messages
-            print("\n" + "=" * 60)
-            print("DISCUSSION COMPLETE")
-            print("=" * 60)
-            print("Final discussion summary:")
-            # To make the type checker happy, we cast event.data to the expected type
-            outputs = cast(list[Message], event.data)
-            for msg in outputs:
-                speaker = msg.author_name or msg.role
-                print(f"[{speaker}]: {msg.text}")
-
-    responses: dict[str, AgentRequestInfoResponse] = {}
-    if requests:
-        for request_id, request in requests.items():
-            # Display pre-agent context for human input
-            print("\n" + "-" * 40)
-            print("INPUT REQUESTED")
-            print(
-                f"Agent {request.executor_id} just responded with: '{request.agent_response.text}'. "
-                "Please provide your feedback."
-            )
-            print("-" * 40)
-            if request.full_conversation:
-                print("Conversation context:")
-                recent = (
-                    request.full_conversation[-2:] if len(request.full_conversation) > 2 else request.full_conversation
-                )
-                for msg in recent:
-                    name = msg.author_name or msg.role
-                    text = (msg.text or "")[:150]
-                    print(f"  [{name}]: {text}...")
-                print("-" * 40)
-
-            # Get human input to steer the agent
-            user_input = input(f"Feedback for {request.executor_id} (or 'skip' to approve): ")  # noqa: ASYNC250
-            if user_input.lower() == "skip":
-                user_input = AgentRequestInfoResponse.approve()
-            else:
-                user_input = AgentRequestInfoResponse.from_strings([user_input])
-
-            responses[request_id] = user_input
-
-    return responses if responses else None
-
-
-async def main() -> None:
-    client = AzureOpenAIChatClient(credential=AzureCliCredential())
-
-    # Create agents for a group discussion
-    optimist = client.as_agent(
-        name="optimist",
-        instructions=(
-            "You are an optimistic team member. You see opportunities and potential "
-            "in ideas. Engage constructively with the discussion, building on others' "
-            "points while maintaining a positive outlook. Keep responses to 2-3 sentences."
-        ),
-    )
-
-    pragmatist = client.as_agent(
-        name="pragmatist",
-        instructions=(
-            "You are a pragmatic team member. You focus on practical implementation "
-            "and realistic timelines. Sometimes you disagree with overly optimistic views. "
-            "Keep responses to 2-3 sentences."
-        ),
-    )
-
-    creative = client.as_agent(
-        name="creative",
-        instructions=(
-            "You are a creative team member. You propose innovative solutions and "
-            "think outside the box. You may suggest alternatives to conventional approaches. "
-            "Keep responses to 2-3 sentences."
-        ),
-    )
-
-    # Orchestrator coordinates the discussion
-    orchestrator = client.as_agent(
-        name="orchestrator",
-        instructions=(
-            "You are a discussion manager coordinating a team conversation between participants. "
-            "Your job is to select who speaks next.\n\n"
-            "RULES:\n"
-            "1. Rotate through ALL participants - do not favor any single participant\n"
-            "2. Each participant should speak at least once before any participant speaks twice\n"
-            "3. Continue for at least 5 rounds before ending the discussion\n"
-            "4. Do NOT select the same participant twice in a row"
-        ),
-    )
-
-    # Build workflow with request info enabled
-    # Using agents= filter to only pause before pragmatist speaks (not every turn)
-    # max_rounds=6: Limit to 6 rounds
-    workflow = (
-        GroupChatBuilder(
-            participants=[optimist, pragmatist, creative],
-            max_rounds=6,
-            orchestrator_agent=orchestrator,
-        )
-        .with_request_info(agents=[pragmatist])  # Only pause before pragmatist speaks
-        .build()
-    )
-
-    # Initiate the first run of the workflow.
-    # Runs are not isolated; state is preserved across multiple calls to run.
-    stream = workflow.run(
-        "Discuss how our team should approach adopting AI tools for productivity. "
-        "Consider benefits, risks, and implementation strategies.",
-        stream=True,
-    )
-
-    pending_responses = await process_event_stream(stream)
-    while pending_responses is not None:
-        # Run the workflow until there is no more human feedback to provide,
-        # in which case this workflow completes.
-        stream = workflow.run(stream=True, responses=pending_responses)
-        pending_responses = await process_event_stream(stream)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

python/samples/getting_started/workflows/human-in-the-loop/guessing_game_with_human_input.py

@@ -1,6 +1,7 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 import asyncio
+import os
 from collections.abc import AsyncIterable
 from dataclasses import dataclass
 
@@ -16,7 +17,7 @@ from agent_framework import (
     handler,
     response_handler,
 )
-from agent_framework.azure import AzureOpenAIChatClient
+from agent_framework.azure import AzureOpenAIResponsesClient
 from azure.identity import AzureCliCredential
 from pydantic import BaseModel
 
@@ -37,7 +38,8 @@ Demonstrate:
 - Driving the loop in application code with run and responses parameter.
 
 Prerequisites:
-- Azure OpenAI configured for AzureOpenAIChatClient with required environment variables.
+- AZURE_AI_PROJECT_ENDPOINT must be your Azure AI Foundry Agent Service (V2) project endpoint.
+- Azure OpenAI configured for AzureOpenAIResponsesClient with required environment variables.
 - Authentication via azure-identity. Use AzureCliCredential and run az login before executing the sample.
 - Basic familiarity with WorkflowBuilder, executors, edges, events, and streaming runs.
 """
@@ -183,7 +185,11 @@ async def process_event_stream(stream: AsyncIterable[WorkflowEvent]) -> dict[str
 async def main() -> None:
     """Run the human-in-the-loop guessing game workflow."""
     # Create agent and executor
-    guessing_agent = AzureOpenAIChatClient(credential=AzureCliCredential()).as_agent(
+    guessing_agent = AzureOpenAIResponsesClient(
+        project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
+        deployment_name=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
+        credential=AzureCliCredential(),
+    ).as_agent(
         name="GuessingAgent",
         instructions=(
             "You guess a number between 1 and 10. "

python/samples/getting_started/workflows/human-in-the-loop/sequential_request_info.py

@@ -1,136 +0,0 @@
-# Copyright (c) Microsoft. All rights reserved.
-
-"""
-Sample: Request Info with SequentialBuilder
-
-This sample demonstrates using the `.with_request_info()` method to pause a
-SequentialBuilder workflow AFTER each agent runs, allowing external input
-(e.g., human feedback) for review and optional iteration.
-
-Purpose:
-Show how to use the request info API that pauses after every agent response,
-using the standard request_info pattern for consistency.
-
-Demonstrate:
-- Configuring request info with `.with_request_info()`
-- Handling request_info events with AgentInputRequest data
-- Injecting responses back into the workflow via run(responses=..., stream=True)
-
-Prerequisites:
-- Azure OpenAI configured for AzureOpenAIChatClient with required environment variables
-- Authentication via azure-identity (run az login before executing)
-"""
-
-import asyncio
-from collections.abc import AsyncIterable
-from typing import cast
-
-from agent_framework import (
-    AgentExecutorResponse,
-    Message,
-    WorkflowEvent,
-)
-from agent_framework.azure import AzureOpenAIChatClient
-from agent_framework.orchestrations import AgentRequestInfoResponse, SequentialBuilder
-from azure.identity import AzureCliCredential
-
-
-async def process_event_stream(stream: AsyncIterable[WorkflowEvent]) -> dict[str, AgentRequestInfoResponse] | None:
-    """Process events from the workflow stream to capture human feedback requests."""
-
-    requests: dict[str, AgentExecutorResponse] = {}
-    async for event in stream:
-        if event.type == "request_info" and isinstance(event.data, AgentExecutorResponse):
-            requests[event.request_id] = event.data
-
-        elif event.type == "output":
-            # The output of the sequential workflow is a list of ChatMessages
-            print("\n" + "=" * 60)
-            print("WORKFLOW COMPLETE")
-            print("=" * 60)
-            print("Final output:")
-            outputs = cast(list[Message], event.data)
-            for message in outputs:
-                print(f"[{message.author_name or message.role}]: {message.text}")
-
-    responses: dict[str, AgentRequestInfoResponse] = {}
-    if requests:
-        for request_id, request in requests.items():
-            # Display agent response and conversation context for review
-            print("\n" + "-" * 40)
-            print("REQUEST INFO: INPUT REQUESTED")
-            print(
-                f"Agent {request.executor_id} just responded with: '{request.agent_response.text}'. "
-                "Please provide your feedback."
-            )
-            print("-" * 40)
-            if request.full_conversation:
-                print("Conversation context:")
-                recent = (
-                    request.full_conversation[-2:] if len(request.full_conversation) > 2 else request.full_conversation
-                )
-                for msg in recent:
-                    name = msg.author_name or msg.role
-                    text = (msg.text or "")[:150]
-                    print(f"  [{name}]: {text}...")
-                print("-" * 40)
-
-            # Get feedback on the agent's response (approve or request iteration)
-            user_input = input("Your guidance (or 'skip' to approve): ")  # noqa: ASYNC250
-            if user_input.lower() == "skip":
-                user_input = AgentRequestInfoResponse.approve()
-            else:
-                user_input = AgentRequestInfoResponse.from_strings([user_input])
-
-            responses[request_id] = user_input
-
-    return responses if responses else None
-
-
-async def main() -> None:
-    client = AzureOpenAIChatClient(credential=AzureCliCredential())
-
-    # Create agents for a sequential document review workflow
-    drafter = client.as_agent(
-        name="drafter",
-        instructions=("You are a document drafter. When given a topic, create a brief draft (2-3 sentences)."),
-    )
-
-    editor = client.as_agent(
-        name="editor",
-        instructions=(
-            "You are an editor. Review the draft and make improvements. "
-            "Incorporate any human feedback that was provided."
-        ),
-    )
-
-    finalizer = client.as_agent(
-        name="finalizer",
-        instructions=(
-            "You are a finalizer. Take the edited content and create a polished final version. "
-            "Incorporate any additional feedback provided."
-        ),
-    )
-
-    # Build workflow with request info enabled (pauses after each agent responds)
-    workflow = (
-        SequentialBuilder(participants=[drafter, editor, finalizer])
-        # Only enable request info for the editor agent
-        .with_request_info(agents=["editor"])
-        .build()
-    )
-
-    # Initiate the first run of the workflow.
-    # Runs are not isolated; state is preserved across multiple calls to run.
-    stream = workflow.run("Write a brief introduction to artificial intelligence.", stream=True)
-
-    pending_responses = await process_event_stream(stream)
-    while pending_responses is not None:
-        # Run the workflow until there is no more human feedback to provide,
-        # in which case this workflow completes.
-        stream = workflow.run(stream=True, responses=pending_responses)
-        pending_responses = await process_event_stream(stream)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())