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.
Adds the optional not_supported_features array to the manifest JSON schema so integrations can declare features whose framework cannot architecturally support them. This unblocks llamaindex (and other emerging frameworks) from declaring such gaps without tripping AJV's additionalProperties:false.
The dashboard rendering logic that turns this field into 'unsupported' cells lives in a separate dashboard PR (879b18740) — this commit is the schema half so manifest validation passes today.
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.
Adds the following demos to the built-in-agent showcase:
- open-gen-ui-advanced: sandboxFunctions bridge between agent-authored
iframe UI and host-defined handlers
- tool-rendering-default-catchall: useDefaultRenderTool with no config
- tool-rendering-custom-catchall: useDefaultRenderTool with branded
wildcard renderer
- frontend-tools: useFrontendTool that mutates page background
- frontend-tools-async: async useFrontendTool with branded NotesCard
Also expands server-tools.ts with mock get_weather, search_flights,
get_stock_price, and roll_dice tools used by the catch-all demos.
Manifest updated with new feature ids, demo entries, and highlight
files.
Reasoning-related demos (agentic-chat-reasoning, reasoning-default-render,
tool-rendering-reasoning-chain) are NOT included: the tanstack/openai
adapter with gpt-4o does not natively emit REASONING_* events, so
reasoning would not surface in the UI.
Picks up the remaining demos from D13's port. Adds:
- mcp-apps: dedicated route with mcpApps.servers config (Excalidraw), no-tools Mastra agent
- tool-rendering-reasoning-chain: per-tool renderers + custom reasoningMessage slot
- gen-ui-tool-based: manifest entry for the existing useFrontendTool haiku page
- hitl-in-chat-booking: manifest alias pointing at the existing /demos/hitl-in-chat route
- hitl: manifest entry for the existing step-selection page (useLangGraphInterrupt branch is a no-op on Mastra; useHumanInTheLoop branch works)
BLOCKED on Mastra adapter capabilities:
- gen-ui-interrupt: useInterrupt requires AG-UI INTERRUPT events the Mastra adapter does not emit
- interrupt-headless: same root cause
Adds five missing showcase demos to the Claude Agent SDK (TypeScript)
integration:
- tool-rendering-default-catchall: zero-config wildcard tool renderer.
- tool-rendering-custom-catchall: branded wildcard renderer.
- agentic-chat-reasoning: custom reasoningMessage slot.
- reasoning-default-render: built-in reasoning slot.
- tool-rendering-reasoning-chain: reasoning + per-tool renderers + catch-all.
Backend changes in agent_server.ts wire Anthropic extended thinking on a
new /reasoning endpoint and forward thinking_delta events as AG-UI
REASONING_MESSAGE_* events. A dedicated Next.js runtime route
copilotkit-reasoning/route.ts proxies the three reasoning agent ids.
Catch-all tool demos register the LangGraph reference's mock tools
(get_weather, search_flights, get_stock_price, roll_dice) via
useFrontendTool with stub handlers, so the pass-through agent can call
them without backend agent changes.
PARITY_NOTES updated to reflect what shipped and what remains BLOCKED
(headless-complete, beautiful-chat, a2ui-fixed-schema, and the four
LangGraph-interrupt-only demos).
Ports the second batch of langgraph-python showcase cells to AG2.
Each demo gets a dedicated AG2 sub-app mounted at a named path on the
agent server, plus (where required) its own /api/copilotkit-* runtime
route so the runtime middleware config doesn't leak into other cells.
- declarative-gen-ui — A2UI Dynamic Schema. Backend (a2ui_dynamic.py)
owns the generate_a2ui tool, calls a secondary LLM bound to
render_a2ui, returns an a2ui_operations container. Runtime route
with a2ui.injectA2UITool: false.
- a2ui-fixed-schema — A2UI Fixed Schema. Backend (a2ui_fixed.py) ships
flight_schema.json and emits a2ui_operations directly from
display_flight. Runtime route with a2ui.injectA2UITool: false.
- mcp-apps — Backend (mcp_apps_agent.py) is a no-tools ConversableAgent;
runtime route configures mcpApps.servers pointing at the public
Excalidraw MCP server.
- open-gen-ui, open-gen-ui-advanced — Backends are no-tools
ConversableAgents; shared runtime route enables openGenerativeUI.
- agentic-chat-reasoning, tool-rendering-reasoning-chain — Frontend
ports of the reasoning cells. Custom reasoningMessage slot wired as
in the canonical reference. tool-rendering-reasoning-chain has its
own backend with weather/flights/stock/dice tools. AG2 caveat
documented: ConversableAgent does not natively emit AG-UI
REASONING_MESSAGE_* events the way LangGraph deepagents does, so the
reasoning slot may render empty until/if AG2 adds reasoning emission.
Updates manifest.yaml with all 7 new demo entries plus matching feature
list, and updates PARITY_NOTES.md to record Batch 4.
- hitl-in-chat-booking: frontend useHumanInTheLoop with inline time-picker
- mcp-apps: separate route with mcpApps middleware → Excalidraw MCP server
- open-gen-ui: separate route with openGenerativeUI middleware + design skill
Alem Tuzlak