How to use HITL in MAF taking input from user using actual ui and not using the python 'input()' method?

[Psquare-0]

Hi Team,
I am trying to implement MAF HITL with my React Js as frontend but not able to understand how it will work with the actual ui. The MAF examples shows the HITL implementation with the python 'input()' method. So i tried to directly return the Agent question from that line to ask user for input like below (I am using a2a-sdk for A2A communication):

I followed this example https://github.com/microsoft/agent-framework/blob/main/python/samples/03-workflows/human-in-the-loop/guessing_game_with_human_input.py

async def process_event_stream(stream: AsyncIterable[WorkflowEvent]) -> dict[str, str] | None:
    """Process events from the workflow stream to capture human feedback requests."""
    # Track the last author to format streaming output.
    last_response_id: str | None = None
    requests: list[tuple[str, HumanFeedbackRequest]] = []
    async for event in stream:
        if event.type == "request_info" and isinstance(event.data, HumanFeedbackRequest):
            requests.append((event.request_id, event.data))
        elif event.type == "output":
            if isinstance(event.data, AgentResponseUpdate):
                update = event.data
                response_id = update.response_id
                if response_id != last_response_id:
                    if last_response_id is not None:
                        print()  # Newline between different responses
                    print(f"{update.author_name}: {update.text}", end="", flush=True)
                    last_response_id = response_id
                else:
                    print(update.text, end="", flush=True)
            else:
                print(f"\n{event.executor_id}: {event.data}")

    # Handle any pending human feedback requests.
    if requests:
        responses: dict[str, str] = {}
        for request_id, request in requests:
            print(f"\nHITL: {request.prompt}")
            # Instructional print already appears above. The input line below is the user entry point.
            # If desired, you can add more guidance here, but keep it concise.
            # answer = input("Enter higher/lower/correct/exit: ").lower()  ## **COMMENTED THIS**
            return new_agent_text_message("Enter higher/lower/correct/exit: ") ## **ADDED THIS** 
            
        return responses

    return None

This successfully returns the Agent question but when the user replies (FYI i am using the FileCheckpointerStorage) to the Agent question i get this error:

AgentInvalidResponseException( agent_framework.exceptions.AgentInvalidResponseException: Unexpected content type while awaiting request info responses. Request Error (ID: fa0calcc-9c0f-467a-b58e-f8feec852159): Code=-32603, Message='Unexpected content type while awaiting request info responses.'

NOTE : I followed the above example in my actual code which is in my office laptop and i can not access it, hence referring to this example.

Please help.

[ECD5A]

input() is only the sample's UI adapter. The workflow contract is the important part: after a request_info event, that workflow run is suspended and must be resumed with a response map keyed by the exact event.request_id.

Returning new_agent_text_message(...) at that point sends an A2A message where Agent Framework is waiting for the declared str response to HumanFeedbackRequest. That is why it reports an unexpected content type.

I would split the integration into two HTTP/A2A turns:

async def collect_pending(stream):
    pending = []
    async for event in stream:
        if (
            event.type == "request_info"
            and isinstance(event.data, HumanFeedbackRequest)
        ):
            pending.append({
                "request_id": event.request_id,
                "prompt": event.data.prompt,
            })
        # Forward output events to the UI as usual.
    return pending

# Initial request
pending = await collect_pending(
    workflow.run("start", stream=True)
)
# Return/publish an A2A `input-required` state containing request_id + prompt.

# A later request containing the React user's answer
pending = await collect_pending(
    workflow.run(
        stream=True,
        responses={payload.request_id: payload.answer},
    )
)

The React client should treat request_id as opaque and send it back unchanged with the user's answer. Your A2A adapter should publish the prompt as an input-required task state, not inject that prompt back into the paused workflow as its response.

For multiple users/tasks, keep these items associated with the A2A task/context:

• the workflow instance or the checkpoint needed to restore it;
• every pending Agent Framework request_id;
• the expected response type and UI prompt.

Your file-backed checkpointer can persist workflow state, but it does not turn a later A2A text message into the responses={request_id: value} mapping for you. Your adapter still has to perform that correlation. Also avoid sharing one mutable workflow instance across unrelated A2A conversations.

With that separation, @response_handler receives the plain string declared by response_type=str, and the actual UI can be React, a queue consumer, or another service; the workflow does not need to know which one.