- generate-registry: cross-validate not_supported_features against features list
- catalog-types: widen manifestation union to include 'starter'
- claude-sdk-python: drop invalid 'declarative-schema' from generative_ui enum
- crewai-crews: remove duplicate animated_preview_url key in mcp-apps demo
- built-in-agent + pydantic-ai: REASONING_MODEL env-var fallback so deployers can swap if gpt-5.2/gpt-5 isn't available
Wave-3 fill for the Claude Agent SDK (TypeScript) showcase.
- hitl-in-chat / hitl-in-chat-booking: frontend-tool useHumanInTheLoop
flow with an inline TimePickerCard. Pass-through agent — Claude sees
the book_call tool definition forwarded via AG-UI and calls it; the
frontend renders the picker and returns the user's selection.
- a2ui-fixed-schema: dedicated /a2ui-fixed-schema endpoint on the
Express agent ships flight_schema.json and a display_flight tool that
emits an a2ui_operations container. New runtime route
copilotkit-a2ui-fixed-schema runs the A2UI middleware with
injectA2UITool: false because the backend owns the rendering tool.
- headless-complete: dedicated /headless-complete endpoint exposes
get_weather + get_stock_price backend tools, frontend ports the
fully-headless useAgent surface and per-tool renderers from
claude-sdk-python (highlight_note remains a frontend-only useComponent
tool). New runtime route copilotkit-headless-complete proxies to it.
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.
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).
github-actions[bot]