ag-ui-protocol/ag-ui

Follows #2800. Closes the loop: the Python client declares tools, the agent calls them, the client executes them locally and returns results. Scope Let a caller register local tool implementations with the client. Send those tool definitions on RunAgentInput. On a matching tool call, execute the local implementation and submit the result back to the agent. Extend the #2800 demo to show a complete round trip. Acceptance criteria A registered tool is advertised to the agent and invoked by it. The result returns and the agent's run continues to completion. An exception inside a local tool is reported back as a tool error, not swallowed and not crashing the run. The demo README walks through the full cycle. End-to-end test against a fixture server. Pointers sdks/typescript/packages/client/ for the TS frontend-tool flow. integrations/server-starter-all-features/. Out of scope Shared state and interrupts — a natural follow-up, not scoped here.

Follows #2799. Extends the Python client from text-only to the tool-call event surface, and proves it with a runnable demo. Scope Decode TOOL_CALL_START / TOOL_CALL_ARGS / TOOL_CALL_END / TOOL_CALL_RESULT. Accumulate argument deltas per tool_call_id and expose completed calls as typed objects. Handle interleaved tool calls without mixing argument buffers. Ship a small demo that connects to an existing AG-UI server and prints tool calls as they stream. Acceptance criteria Sequential and interleaved tool calls both decode correctly. Accumulated arguments parse as valid JSON on TOOL_CALL_END. Malformed argument JSON produces a clear error naming the offending tool_call_id — it does not take down the stream. The demo runs against one of the integrations/server-starter* servers with documented steps. Pointers sdks/typescript/packages/client/ for the equivalent TS handling. integrations/server-starter-all-features/ as the demo's counterpart server. Out of scope Frontend tool exec

Context The TypeScript SDK ships @ag-ui/client (sdks/typescript/packages/client/). The Python SDK has no client counterpart — sdks/python/ag_ui/ provides core types and an EventEncoder for servers only. Python callers therefore cannot consume an AG-UI agent without hand-rolling SSE parsing. This issue adds the narrowest useful client: connect, send a user message, receive streamed text. Scope Add a client module under sdks/python/ag_ui/. Open an SSE connection to an AG-UI endpoint and decode the stream into typed core events. Reassemble TEXT_MESSAGE_START / TEXT_MESSAGE_CONTENT / TEXT_MESSAGE_END into complete messages, while also exposing the raw event stream for callers who want deltas. Surface RUN_ERROR as a raised exception rather than a silently truncated stream. Acceptance criteria A client can send a user message to a local AG-UI server and receive the streamed reply. Unknown or future event types are skipped without crashing the client. A stream that ends without RUN_FI

Context Final slice. Follows 2797. Covers the advanced AG-UI capabilities, gated on what 2793 concluded Flue can actually express. Scope Shared state: emit STATE_SNAPSHOT and STATE_DELTA as agent state changes, and accept inbound state on RunAgentInput. Interrupts: support human-in-the-loop pause/resume if Flue exposes a suspension point. Reasoning: surface intermediate reasoning as the corresponding AG-UI events where Flue emits it. Anything 2793 determined Flue cannot support should be closed out here with a short written note rather than left silently unimplemented. Acceptance criteria State round-trips: a client-supplied state reaches the agent, and mutations come back as deltas. Deltas apply cleanly against the preceding snapshot. Each of the three capabilities is either implemented with a test, or documented in the integration README as unsupported with the reason. Pointers integrations/langgraph/ is the richest in-repo example of state sync and interrupts. integrations/s

Context Follows 2796. AG-UI lets the frontend declare tools that the agent may call, with execution happening client-side. The adapter has to advertise those tools to Flue and route the results back. Scope Read the tools array off RunAgentInput and register them with the Flue agent for the duration of that run. When the agent calls a frontend tool, emit the tool-call events and yield control rather than attempting local execution. Accept the tool result on the next request and resume the agent with it. Acceptance criteria Frontend-declared tools appear to the agent alongside any server-side tools. A frontend tool call suspends correctly and resumes with the returned result. Tools are scoped per request — one run's tools never leak into a concurrent run. A test covers the full declare → call → resume → respond cycle. Pointers integrations/server-starter-all-features/ demonstrates the frontend-tool flow. Per-request isolation matters here: see CopilotKit/CopilotKit#5659