How to Stream LLM Responses with FastAgent?

[jake-codes]

I'm attempting to build an MCP client with FastAgent but I don't see a way to stream back responses from the LLM.
Is that not possible?

What I have so far is below and I feel that I'm close. But the stream_agent() call (for the /agent/sse endpoint) is what I'm having trouble with.

import asyncio
from fastapi import FastAPI, Request
from fastapi.responses import StreamingResponse
from mcp_agent.core.fastagent import FastAgent
import httpx

# Create the FastAPI app
app = FastAPI()

# Create the FastAgent instance using config, without CLI arg parsing (since FastAPI handles args)
fast = FastAgent(
    "mcp-api-agent",
    config_path="fastagent.config.yaml",
    parse_cli_args=False
)

# Register a fallback default agent (not strictly used here but required by decorator syntax)
@fast.agent(instruction="You are a helpful API assistant")
async def fallback_agent():
    pass

# Shared agent application reference
agent_app = None

@app.on_event("startup")
async def startup_event():
    global agent_app
    async with fast.run() as agent: # !!!!!! This is the key line too run fastagent as an agent !!!!!!!
        agent_app = agent
        while True:
            await asyncio.sleep(3600)  # Keep context manager alive

# POST /agent
# Used for synchronous interactions (e.g., /chat endpoint on the backend)
# Waits for the full result from the LLM and tools, then returns it all at once
@app.post("/agent")
async def handle_agent(request: Request):
    data = await request.json()
    user_input = data.get("message", "")
    if not agent_app:
        return {"error": "Agent not initialized"}
    result = await agent_app.send(user_input)
    return {"response": result}

# GET /agent/sse
# Used for streaming interactions (e.g., /stream endpoint on the backend)
# Forwards the streaming output from a downstream streaming MCP server (if available)
@app.get("/agent/sse")
async def stream_agent(query: str):
    async def my_fastagent_stream(query):
        if not agent_app:
            yield "[ERROR: Agent not initialized]"
            return
        # Try to use a streaming method if available
        stream_method = None
        if hasattr(agent_app, "stream") and callable(getattr(agent_app, "stream")):
            stream_method = getattr(agent_app, "stream")
        elif hasattr(agent_app, "stream_send") and callable(getattr(agent_app, "stream_send")):
            stream_method = getattr(agent_app, "stream_send")
        if stream_method:
            async for token in stream_method(query):
                yield token
        else:
            # Fallback: use send() and yield the full response at once
            response = await agent_app.send(query)
            yield response
        yield "[DONE]"

    async def event_generator():
        async for token in my_fastagent_stream(query):
            yield f"data: {token}\n\n"

    return StreamingResponse(event_generator(), media_type="text/event-stream")