Durable Task + AG-UI + CopilotKit

[Alex (kpobb1989)]

Could you provide a code sample showing how to integrate:

1. Durable Task (for long-running operations that can span days)
2. AG-UI (as the communication channel between the Azure Function and the frontend)
3. CopilotKit (on the Angular frontend)

It also seems like app.MapAGUI("/", agent) from Microsoft.Agents.AI.Hosting.AGUI.AspNetCore is designed for a standard .NET API host - not for Azure Durable Functions. How should this be wired up correctly in a Durable Functions context?

[John CSA (jluocsa)]

The behavior you are observing is by design. app.MapAGUI(...) ships in Microsoft.Agents.AI.Hosting.AGUI.AspNetCore and binds to ASP.NET Core endpoint routing, which is not available in the Azure Functions Worker host. There is no MapAGUI overload for Azure Functions today, so for this scenario the integration is assembled from existing primitives.

The good news is the architecture is already demonstrated in the repository — it is the 08_ReliableStreaming sample. The wire format in that sample is plain SSE; for CopilotKit you substitute the AG-UI event format. Below is the recommended architecture and the specific extension points.

Recommended architecture

CopilotKit (Angular) ──SSE──► HTTP-trigger Func ──signal──► Durable Entity Agent
                                    │                              │
                                    │                              ▼
                                    │                       IAgentResponseHandler
                                    │                              │
                                    │                              ▼
                                    └──── reads ───── Durable log (Redis / Event Hubs)

Three components in the Functions app:

1. HTTP-trigger function that starts the run and streams

A standard HTTP trigger (not MapAGUI) creates a session, fires the durable agent in fire-and-forget mode, and immediately begins streaming. From FunctionTriggers.CreateAsync:

AIAgent agentProxy = durableClient.AsDurableAgentProxy(context, "TravelPlanner");
AgentSession session = await agentProxy.CreateSessionAsync(ct);
string conversationId = session.GetService<AgentSessionId>().ToString();

// Fire-and-forget: the orchestration runs independently of the HTTP request lifetime.
await agentProxy.RunAsync(
    prompt,
    session,
    new DurableAgentRunOptions { IsFireAndForget = true },
    ct);

return await StreamToClientAsync(conversationId, cursor: null, httpContext: request.HttpContext, ct);

IsFireAndForget = true is the key configuration. It decouples the orchestration's lifetime from the HTTP request, which is what enables the multi-day execution semantics you require.

2. IAgentResponseHandler that persists each update to a durable log

Implement IAgentResponseHandler and register it in DI. The handler receives every AgentResponseUpdate produced by the orchestration and persists it, keyed by conversationId, to a durable store the streaming endpoint can read. The sample uses Redis Streams; supported alternatives are Event Hubs, Cosmos DB change feed, or Azure SignalR Service with backplane persistence.

builder.ConfigureDurableAgents(options =>
{
    options.AddAIAgent(travelPlannerAgent);
});
builder.Services.AddSingleton<IAgentResponseHandler, AGUIEventResponseHandler>();

3. Second HTTP-trigger function for cursor-based resumption

A GET /agent/stream/{conversationId}?cursor={cursor} endpoint allows the Angular client to reconnect from any point in the stream. This is essential for orchestrations longer than the Azure Functions HTTP timeout (≈230s on Consumption, 10 minutes on Premium and Dedicated). The Angular client reconnects with the last cursor it received; the framework replays from that position.

Translating to the AG-UI event format

The reference sample emits plain SSE chunks (event: message, data: "..."). CopilotKit's runtime expects the AG-UI event protocol — RUN_STARTED, TEXT_MESSAGE_START, TEXT_MESSAGE_CONTENT, TEXT_MESSAGE_END, RUN_FINISHED, and the tool-call event family. The translation happens in two places:

Layer	Responsibility
IAgentResponseHandler	Project each AgentResponseUpdate into one or more AG-UI events. Map update.Text → TEXT_MESSAGE_CONTENT, update.Contents.OfType<FunctionCallContent>() → TOOL_CALL_*, role boundaries → TEXT_MESSAGE_START / _END, and completion → RUN_FINISHED. Serialize as JSON and append to the durable log.
HTTP stream loop	Set Content-Type: text/event-stream, write each AG-UI JSON event as an SSE data: …\n\n frame, and emit the cursor as the SSE id: field so client reconnects resume correctly.

CopilotKit's Angular runtime treats the endpoint as an opaque AG-UI-over-SSE source — the Durable Functions host is invisible to it.

Alternative: ASP.NET Core front door with Durable Task behind it

If Azure Functions is not a hard requirement, an alternative topology is to host the AG-UI endpoint on ASP.NET Core and use Microsoft.Agents.AI.DurableTask only for the orchestration tier. IDurableAgentClient and AsDurableAgentProxy are not Functions-specific. In that configuration:

app.MapAGUI("/", durableAgentProxy);

remains the front door, and the Durable Task client invokes long-running work in the background. This is the simplest path when you need Durable Task's orchestration guarantees but do not have an organizational requirement to host on Functions specifically.

Summary

Requirement	Recommended pattern
Multi-day orchestrations + AG-UI on Azure Functions	Manual SSE HTTP-trigger pattern from 08_ReliableStreaming, with the on-the-wire format replaced by AG-UI events. No MapAGUI.
Durable Task + MapAGUI as-is	Host on ASP.NET Core, wrap the agent with DurableAIAgentProxy.
Short-lived chat only	MapAGUI on ASP.NET Core; no Durable Task required.

For your stated requirements (Angular + CopilotKit + multi-day operations on Functions), Option 1 is the correct path. An end-to-end sample combining Durable Functions, AG-UI, and CopilotKit does not exist in the repository today, but every building block is present and 08_ReliableStreaming is a substantial portion of the implementation.

[Alex (kpobb1989)]

John CSA (@jluocsa) Thank you for the very detailed explanation. Durable Function is not a strict requirement. DurableAgentProxy is a very interesting solution. Is it going to work for a use case when more than one agent is involved (e.g., PlannerAgent and ExecutorAgent)?

I also noticed there is a way to set up AllowBackgroundResponses. Is it the same as DurableAgentProxy?

AgentRunOptions options = new()
{
AllowBackgroundResponses = true
};

[Alex (kpobb1989)]

John CSA (@jluocsa) The  AsDurableAgentProxy  solution is not working because of the error “streaming is not supported for durable agents,” which I get when trying to pass the proxy agent into the  MapAGUI  method. I tried to implement my own DurableStreamingBridge on top of the proxy agent, but faced a problem getting the  conversationId  and tools are not being passed to the AI model either.