Workflow Orchestrator Pause and resume.

[sathibabu-enmovil]

I am implementing an orchestrator workflow for my project, where multiple agents collaborate to complete tasks. In certain scenarios, some agents need to wait for external data—such as vendor input—before they can proceed further. In these cases, I need the ability to pause the workflow execution until the required data is available, and then resume the process seamlessly.

Could you please advise on best practices for implementing this pause-and-resume functionality, both in an asyncio-based workflow and when using Temporal workflows?
`import asyncio
import os
import logging
import json
import yaml

from mcp_agent.agents.agent import Agent
from mcp_agent.executor.workflow import Workflow, WorkflowResult, Signal
from mcp_agent.workflows.llm.augmented_llm import RequestParams
from augmented_llm_azure import AzureAugmentedLLM
from mcp_agent.workflows.orchestrator.orchestrator import Orchestrator
from mcp_agent.server.app_server import create_mcp_server_for_app
from mcp_agent.config import Settings
from mcp_agent.app import MCPApp
import warnings
from human_input import register_human_input_tools, console_human_input_callback
from agent_prompt import (PLANNER_PROMPT, REVIEW_AGENT_PROMPT,
RFQ_CREATOR_PROMPT, RFQ_ANALYZER_ANNOUNCER_PROMPT,
RFQ_NOTIFIER_PROMPT, BID_COLLECTOR_PROMPT, SYNTHESIZER_PROMPT)

warnings.filterwarnings("ignore")
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(name)

with open("mcp_agent.config.yaml") as f:
d = yaml.safe_load(f)

settings = Settings(**d)
mcp_app = MCPApp(name="basic_agent_server", description="Basic agent server example")

@mcp_app.workflow
class OrchestratorWorkflow(Workflow[str]):
"""
A simple workflow that demonstrates the basic structure of a Temporal workflow.
"""

@mcp_app.workflow_run
async def run(self, input: str = '') -> WorkflowResult[str]:

    planner = Agent(
        name="RFQPlanner",
        instruction=PLANNER_PROMPT,
    )

    rfq_creator = Agent(
        name="RFQCreatorAgent",
        instruction=RFQ_CREATOR_PROMPT,
        server_names=["rfq"],
        # human_input_callback=my_human_callback,
    )
    rfq_notifier = Agent(
        name="RFQNotifierAgent",
        instruction=RFQ_NOTIFIER_PROMPT,
        server_names=["rfq"],
    )
    bid_collector = Agent(
        name="BidCollectorAgent",
        instruction=BID_COLLECTOR_PROMPT,
        server_names=["rfq"],
        # human_input_callback=my_human_callback,
    )

    rfq_analyzer_announcer = Agent(
        name="RFQAnnouncerAgent",
        instruction=RFQ_ANALYZER_ANNOUNCER_PROMPT,
        server_names=["rfq"],
    )
    review_agent = Agent(
        name="ReviewAgent",
        instruction=REVIEW_AGENT_PROMPT,
        server_names=[],

    )

    synth_agent = Agent(
        name="Synthesizer",
        instruction=SYNTHESIZER_PROMPT,
        server_names=[],

    )


    orchestrator = Orchestrator(
        llm_factory=AzureAugmentedLLM,
        planner=AzureAugmentedLLM(planner),
        synthesizer=AzureAugmentedLLM(synth_agent),
        available_agents=[
            rfq_creator, rfq_notifier, bid_collector,
            rfq_analyzer_announcer, review_agent, ],
        plan_type="full",
        # context=app.context,
    )

    result = await orchestrator.generate_str(
        message=input,
        request_params=RequestParams(model='model_name', maxTokens=4096, max_iterations=100),
    )

    return WorkflowResult(value=result)

async def main():
async with mcp_app.run() as agent_app:
logger.info(f"Creating MCP server for {agent_app.name}")
logger.info("Registered workflows:")
for workflow_id in agent_app.workflows:
logger.info(f" - {workflow_id}")
mcp_server = create_mcp_server_for_app(agent_app)
register_human_input_tools(mcp_server) # <-- Register your extra tool(s) here!
mcp_server.settings.host = "0.0.0.0"
mcp_server.settings.port = 8042
await mcp_server.run_sse_async()
# await mcp_server.run_streamable_http_async()
# await mcp_server.run_stdio_async()

if name == "main":
asyncio.run(main())`