Adds a dedicated A2UI dynamic-schema cell for the Agno integration:
new `a2ui_dynamic_agent.py` owns its own `generate_a2ui` tool that
reads the runtime-injected client catalog from
`run_context.session_state["copilotkit"]["context"]` and feeds it
to a secondary OpenAI client bound to `render_a2ui`. Result is an
`a2ui_operations` container the runtime A2UI middleware forwards
to the registered frontend catalog renderer.
Unlike the main agent's existing `generate_a2ui` (hardcoded
internal catalog), this dedicated agent stays in sync with whatever
catalog the frontend registers via `<CopilotKit a2ui={{ catalog }}>`.
Frontend ports `page.tsx` + Zod definitions / renderers / catalog
from the langgraph-python reference. Dedicated runtime route at
`/api/copilotkit-declarative-gen-ui` runs with
`injectA2UITool: false` so the agent owns the tool itself.
Adds a dedicated A2UI fixed-schema cell for the Agno integration:
backend `a2ui_fixed_agent.py` ships `flight_schema.json` +
`booked_schema.json` and a single `display_flight` tool that emits
an `a2ui_operations` container directly (no secondary LLM).
Frontend ports `page.tsx` + Zod definitions / renderers / catalog
from the langgraph-python reference. Dedicated runtime route at
`/api/copilotkit-a2ui-fixed-schema` runs the A2UI middleware with
`injectA2UITool: false` so the agent owns its rendering tool.
Port the A2UI dynamic-schema demo to the built-in-agent showcase. The
in-process tanstack agent owns a generate_a2ui tool that fires a
secondary LLM call (forced JSON output) to design the surface tree from
the registered client catalog. The dedicated runtime route runs the
A2UI middleware with injectA2UITool: false so the runtime does not
duplicate the tool slot; the middleware still serialises the catalog
into input.context and detects the a2ui_operations container in tool
results.
Manifest: register both new demos under features and demos.
Port the A2UI fixed-schema flight-card demo to built-in-agent. The
in-process tanstack agent owns a display_flight tool that emits an
a2ui_operations container directly; the dedicated runtime route runs the
A2UI middleware with injectA2UITool: false so the runtime does not
duplicate the slot.
Ports the langgraph-python hitl-in-chat demo to PydanticAI using the frontend-tool pattern: a Zod-typed book_call tool defined via useHumanInTheLoop renders a TimePickerCard inline in chat. Backend agent is a chat-only PydanticAI Agent with no tools — the AG-UI bridge surfaces the frontend-registered tool to the model on each run. Adds hitl-in-chat-booking as a manifest alias pointing at the same route.
Adds not_supported_features to the manifest for gen-ui-interrupt,
interrupt-headless, and hitl (the LangGraph graph-interrupt variant —
distinct from the supported hitl-in-chat / hitl-in-app / hitl-in-chat-booking).
All three depend on a graph-interrupt primitive that LangGraph
provides via interrupt() nodes. The built-in-agent integration uses
TanStack AI's chat-completions adapter, which has no equivalent
node-level pause/resume — so the underlying primitive simply isn't
available.
Adds placeholder pages and READMEs for gen-ui-interrupt and
interrupt-headless explaining the limitation and pointing at
langgraph-python for a working reference. Adds a disambiguation
README in the existing hitl/ directory (which hosts the supported
hitl-in-chat demo) to clarify the distinction with the unsupported
hitl feature ID.
Adds page.tsx + README stubs for gen-ui-interrupt and interrupt-headless.
Both rely on LangGraph's graph-level interrupt() / Command(resume=...)
primitive, which the Claude Agent SDK's Anthropic Messages stream does
not expose. Stubs explain the gap and link users to the hitl /
hitl-in-app cells, which model approval gating with regular tool calls.
Implements agentic-chat-reasoning, reasoning-default-render, and
tool-rendering-reasoning-chain for the built-in-agent integration.
The default tanstack factory uses gpt-4o (non-reasoning), so
REASONING_* events never flow. This commit adds a dedicated
reasoning-factory wrapping the v2 runtime with a reasoning-capable
OpenAI model (gpt-5.2) and reasoning_effort: low. The runtime's
tanstack converter already translates upstream
REASONING_START/REASONING_MESSAGE_CONTENT/REASONING_END events into
AG-UI reasoning events, so once the model emits reasoning the chain
surfaces in the chat with no extra plumbing.
A single shared route /api/copilotkit-reasoning registers all three
agents by ID, keeping bundle and cold-start cost out of unrelated
demos.
A polished brand-themed chat surface over the shared Claude agent.
Mirrors the simplified spring-ai port: gradient background, brand
fonts, seeded suggestion pills, plus a small decorative side panel
(static SVG sparkline + intent breakdown). No A2UI / declarative
generative UI infrastructure required — pure frontend dressing on top
of the existing /api/copilotkit endpoint.
The full canonical version (langgraph-python ExampleCanvas + A2UI
catalog) is documented as out-of-scope in the per-demo README.
Adds the MCP Apps demo to the claude-sdk-python integration. The
dedicated /mcp-apps FastAPI endpoint forwards AG-UI input_data.tools
(injected by the runtime's MCP Apps middleware) straight to the
Anthropic Messages API and streams tool_use blocks back as AG-UI
TOOL_CALL_* events. The runtime middleware then fetches each MCP UI
resource and emits the activity event the built-in
MCPAppsActivityRenderer paints in the chat.
Also extends the manifest schema with not_supported_features (a
pre-approved field for surfacing stub pages on features that cannot
be ported to a given backend).
Both demos are built on useLangGraphInterrupt, which hooks into the
LangGraph interrupt lifecycle. AWS Strands does not expose an equivalent
first-class interrupt primitive, and we don't yet have a Strands-side
adapter. Rather than skipping them silently, surface them under the
manifest's new not_supported_features list and ship per-demo stub pages
that explain the rationale and link to ergonomic replacements
(hitl-in-chat for gen-ui-interrupt; headless-complete + hitl-in-chat
for interrupt-headless).
- manifest.yaml: add not_supported_features list with both ids.
- src/app/demos/gen-ui-interrupt/page.tsx + README.md: stub.
- src/app/demos/interrupt-headless/page.tsx + README.md: stub.
- PARITY_NOTES.md: cross-reference the stubs from the Skipped section.
Simplified port of the langgraph-python flagship beautiful-chat. The
canonical reference combines THREE features (A2UI Dynamic + Open
Generative UI + MCP Apps); the AG2 port ships the first two together
in a single dedicated runtime so users can see them coexist. MCP is
left to the existing /demos/mcp-apps cell, and the canonical's app-mode
toggle / todos canvas is intentionally out of scope.
Components:
- src/agents/beautiful_chat.py — ConversableAgent that owns generate_a2ui
explicitly (mirrors a2ui_dynamic.py); system prompt steers the LLM toward
generate_a2ui for catalog-bound visuals and generateSandboxedUi for
free-form / educational visualisations.
- src/agent_server.py — mounted at /beautiful-chat.
- src/app/api/copilotkit-beautiful-chat/route.ts — dedicated runtime with
a2ui.injectA2UITool: false (agent owns the tool) and
openGenerativeUI.agents: ['beautiful-chat']. Both flags scoped to this
cell so they don't leak into the shared /api/copilotkit endpoint.
- src/app/demos/beautiful-chat/page.tsx — single CopilotKit provider with
both a2ui catalog and openGenerativeUI design skill; reuses the catalog
from /demos/declarative-gen-ui to avoid duplication.
- src/app/demos/beautiful-chat/README.md — per-demo doc.
Manifest: added beautiful-chat to features list and demos section.
The langgraph-python beautiful-chat ships a much larger surface
(ExampleCanvas, GenerativeUIExamples, declarative A2UI catalog,
dedicated runtime combining openGenerativeUI + a2ui + mcpApps). That
ecosystem depends on dozens of starter-level sub-components.
This Strands port mirrors the spring-ai sibling pattern: a polished
landing-style chat shell with brand theming and seeded suggestions,
sitting on top of the shared Strands agent. It is the 'show me a
great-looking starter chat' cell.
Cosmetic styling is entirely on the frontend; the backend agent and
the shared /api/copilotkit runtime are unchanged. Register the new
'beautiful-chat' agent name in the shared route so the cell resolves.
- src/app/demos/beautiful-chat/page.tsx + README.md: brand-themed
CopilotChat shell with useConfigureSuggestions for seeded prompts.
- src/app/api/copilotkit/route.ts: register 'beautiful-chat' agent name.
- manifest.yaml: surface beautiful-chat under features + demos.
- PARITY_NOTES.md: move beautiful-chat from Skipped to Shipped (simplified).
- Add hitl-in-chat-booking as a manifest alias to /demos/hitl-in-chat (frontend-tool pattern via useHumanInTheLoop — no backend interrupt required)
- Mark gen-ui-interrupt and interrupt-headless as not_supported_features: LlamaIndex FunctionAgent has no graph-interrupt API equivalent to LangGraph's interrupt()/Command(resume=...) primitive
- Stub page.tsx + README for each unsupported feature explaining the architectural gap and pointing to /demos/hitl-in-chat as the equivalent UX
Both routes now render an in-page explanation panel with links to the
supported AG2 alternatives (hitl-in-chat for the in-chat surface;
hitl-in-app and frontend-tools-async for the out-of-chat surface). Each
stub ships a README.md documenting the missing primitive (LangGraph
interrupt() resumable round-trip) and why AG2 ConversableAgent cannot
reproduce it.
Wave-2 follow-up — ag2:
- hitl-in-chat-booking is functionally identical to hitl-in-chat on AG2 (both
use useHumanInTheLoop with TimePickerCard); aliased to the same /demos/hitl-in-chat
route, mirroring the langgraph-python manifest. Earlier 'skipped — missing
primitive' note was incorrect (it conflated the booking variant with the
useInterrupt-driven flow).
- Added not_supported_features: [gen-ui-interrupt, interrupt-headless] to the
manifest. Both depend on LangGraph interrupt() resumable round-trips that
AG2 ConversableAgent cannot reproduce.
- PARITY_NOTES updated to reflect the corrected classification.
Marks gen-ui-interrupt and interrupt-headless as not_supported_features
in manifest.yaml. PydanticAI's AG-UI bridge has no graph-interrupt
primitive (runs are linear; agent.run / agent.iter cannot pause to
await a frontend response and resume the same in-flight call), so both
LangGraph-style interrupt cells fundamentally cannot be ported.
Adds minimal placeholder pages with "Not supported by pydantic-ai"
panels that link to the per-demo READMEs explaining the rationale and
pointing to the working langgraph-python references.
Adds the four new shipped features (agentic-chat-reasoning,
reasoning-default-render, tool-rendering-reasoning-chain, mcp-apps)
plus their demo entries to the features list.
The langgraph-python sibling demonstrates MCP-server-driven UI via
the runtime's mcpApps middleware. The Strands integration can use
exactly the same pattern — the middleware advertises MCP tools to the
agent at request time and emits activity events that CopilotKit's
built-in MCPAppsActivityRenderer paints inline as a sandboxed iframe.
This unblocks the previously-deferred mcp-apps cell (D8 had marked it
BLOCKED). The Strands shared agent itself needs no bespoke MCP tools.
- src/app/api/copilotkit-mcp-apps/route.ts: dedicated runtime with
mcpApps.servers pointing at the public Excalidraw MCP server
(serverId pinned for stable thread restoration).
- src/app/demos/mcp-apps/page.tsx + README.md: cell wired to the new
runtime endpoint with seeded suggestions.
- manifest.yaml: surface mcp-apps under features + demos.
- PARITY_NOTES.md: move mcp-apps from Skipped to Ported (simplified).
Mounts the new reasoning, tool_rendering_reasoning_chain, and mcp_apps
agents under dedicated sub-paths in agent_server.py and registers their
agent ids in the main copilotkit runtime so the frontend cells route to
the right backend mounts.
The two reasoning demo ids (agentic-chat-reasoning,
reasoning-default-render) share the same /reasoning backend mount —
the only difference between the cells is the frontend slot wiring.
Adds the MCP Apps showcase cell. The pydantic-ai agent itself is a
no-tools agent; the dedicated /api/copilotkit-mcp-apps route configures
the CopilotKit runtime with mcpApps.servers pointing at the public
Excalidraw MCP server. The runtime auto-applies the MCP Apps middleware
which injects the remote MCP server's tools into each request, and
pydantic-ai's AG-UI bridge surfaces them to the model. The built-in
MCPAppsActivityRenderer paints the resulting activity events as
sandboxed iframes inline.
Mirrors the same pattern proven by claude-sdk-typescript and
langgraph-python.
Adds the three reasoning showcase cells (agentic-chat-reasoning,
reasoning-default-render, tool-rendering-reasoning-chain) for the
pydantic-ai integration. Each is backed by OpenAIResponsesModel pinned
to gpt-5 with openai_reasoning_summary="auto" — that model emits
reasoning items on the Responses API which pydantic-ai's AG-UI bridge
translates to REASONING/THINKING events the v2 chat already renders.
Includes per-demo READMEs explaining the reasoning-model rationale and
mirrors the langgraph-python frontend cell components 1:1 (custom amber
ReasoningBlock slot, default reasoning card, weather/flight/catchall
renderers + ReasoningBlock for the chain demo).
Beautiful Chat (simplified) — polished landing-style chat shell over the
shared agentic_chat agent with gradient theming, suggestion pills, and an
example dashboard surface (BarChart + PieChart re-used from byoc-json-
render). Mirrors the spring-ai simplified port; full A2UI demonstration
catalog is out of scope while Agno lacks an A2UI middleware adapter.
gen-ui-interrupt + interrupt-headless — stubbed as not_supported_features
in manifest.yaml. Agno has no graph-level interrupt primitive, so each
stub page documents the gap and links to the closest Agno-supported
pattern (hitl-in-chat for in-chat blocking, hitl-in-app for out-of-chat
blocking via async useFrontendTool).
Implement MCP Apps demo via the same dedicated-runtime pattern as
google-adk, llamaindex, ms-agent-python, and others: a no-tools CrewAI
crew mounted at /mcp-apps on the FastAPI agent server, plus a dedicated
Next.js runtime route (/api/copilotkit-mcp-apps) that wires
mcpApps.servers to the public Excalidraw MCP server. The runtime
middleware injects MCP tools at request time, so the crew itself
defines no Pydantic BaseTool list -- bringing the previously-claimed
'no MCP middleware integration' blocker in line with the established
cross-integration pattern.
Mark gen-ui-interrupt and interrupt-headless as not_supported_features:
ag-ui-crewai's ChatWithCrewFlow has no pause/resume primitive
equivalent to LangGraph's interrupt(), and there is no port path
without upstream support. Stub READMEs and placeholder pages added so
the showcase shell renders an honest 'not supported' surface for those
two demos.
Adds not_supported_features to manifest.yaml for gen-ui-interrupt,
interrupt-headless, shared-state-streaming, and byoc-json-render. Each
demo dir now ships a placeholder page.tsx and a README explaining the
Spring AI architectural gap (no graph-interrupt primitive, no
mid-stream state-delta API, BeanOutputConverter resolves only on final
response) and points at the LangGraph Python integration where each
feature works.
Mastra workflow suspend/resume isn't bridged through getLocalAgent into
AG-UI, and the Mastra adapter never emits AG-UI INTERRUPT custom events,
so useInterrupt and useHeadlessInterrupt cannot resolve. Mark both
features in the manifest's not_supported_features and ship stub pages
plus per-demo READMEs pointing to the langgraph-python reference.
ag-ui-adk has no interrupt() primitive and does not emit on_interrupt
custom events, so useInterrupt and useHeadlessInterrupt have nothing to
subscribe to. Add not_supported_features to the manifest and provide
README + stub page.tsx for each, pointing to the langgraph-python
reference implementation.
Adds hitl-in-app, readonly-state-agent-context, auth, agent-config,
voice, multimodal, byoc-hashbrown, and byoc-json-render demos to the
built-in-agent showcase. Each demo lives under src/app/demos/<feature>
with a dedicated runtime route under src/app/api/copilotkit-<feature>
where required.
Patterns:
- hitl-in-app and readonly-state-agent-context are frontend-only and
reuse the default /api/copilotkit runtime.
- auth uses createCopilotRuntimeHandler with the V2 onRequest hook to
reject requests missing the Bearer token.
- agent-config reads input.forwardedProps inside the BuiltInAgent
factory and prepends a tone/expertise/length-tuned system prompt.
- voice mounts at [[...slug]]/route.ts and registers
TranscriptionServiceOpenAI from @copilotkit/voice; falls back to a
401 with 'api key missing' when OPENAI_API_KEY is unset.
- multimodal reuses the base gpt-4o factory (vision-capable) and the
TanStack converter (convertInputToTanStackAI) for native image and
document part forwarding — no langgraph-specific binary rewrite.
- byoc-hashbrown and byoc-json-render add per-demo factories that pin
modelOptions.response_format to json_object so the streaming UI
parsers receive a single valid JSON object with no preamble.
Alem Tuzlak