- 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
Ports beautiful-chat, byoc-hashbrown, byoc-json-render, multimodal, open-gen-ui, open-gen-ui-advanced, and voice from the langgraph-python reference into the mastra integration.
Each frontend page is reused as-is. Backends use existing weatherAgent for cells where the UI shape is enforced on the frontend (byoc-*, open-gen-ui-*, beautiful-chat). Multimodal gets a dedicated vision-capable Mastra agent (gpt-4o) registered in the Mastra config. Voice wires the V2 runtime directly with TranscriptionServiceOpenAI so OPENAI_API_KEY-missing returns a clean 401.
Manifest features and demos lists updated. Frontend/backend agent name aliases aligned with each page's <CopilotKit agent=...> prop.
Adds beautiful-chat, cli-start (manifest), prebuilt-sidebar, prebuilt-popup,
chat-slots, chat-customization-css, headless-simple, and headless-complete
demos to the built-in-agent integration. All cells route through the single
in-process /api/copilotkit endpoint and target the 'default' agent.
The headless-complete tool renderers are adapted to the built-in-agent's
existing 'weather' and 'haiku' server tools, with HighlightNote retained as
a frontend-only useComponent example. Beautiful-chat is a simplified
two-pane polished starter rather than the full 4084 reference clone, since
the built-in-agent runner is intentionally minimal.
Adds 5 missing showcase features to crewai-crews manifest:
- cli-start: informational entry with starter clone command
- gen-ui-tool-based: uses pre-existing demo page (haiku via useFrontendTool)
- tool-rendering-default-catchall: built-in DefaultToolCallRenderer wildcard
- tool-rendering-custom-catchall: branded wildcard via useDefaultRenderTool
- hitl-in-chat-booking: alias to hitl-in-chat for booking flow
All demo page stubs already exist on disk and the relevant agent names are
already registered in src/app/api/copilotkit/route.ts; this commit only
surfaces them through manifest features + demo entries.
BLOCKED (omitted, no LangGraph interrupt or MCP runtime in CrewAI):
- gen-ui-interrupt
- interrupt-headless
- mcp-apps
Adds three feature-matrix entries to the Agno integration manifest:
- `cli-start` — informational copy-paste starter command card (no route).
- `gen-ui-tool-based` — frontend-only haiku-renderer demo that already ships
in `src/app/demos/gen-ui-tool-based/`; the manifest entry plus the
existing alias in `src/app/api/copilotkit/route.ts` (mainAgentNames)
surface it in the showcase.
- `hitl-in-chat-booking` — second cell for the booking flavor of the
time-picker HITL surface; reuses `src/app/demos/hitl-in-chat/` files and
the main agent's `book_call` external-execution tool.
PARITY_NOTES.md updated with a fourth-pass entry summarising the additions.
Five sibling features (`beautiful-chat`, `gen-ui-interrupt`,
`interrupt-headless`, `declarative-gen-ui`, `a2ui-fixed-schema`) remain
deferred for the reasons already documented in PARITY_NOTES.md — Agno's
AGUI adapter has no interrupt primitive, and the dedicated combined
runtimes (openGenerativeUI + a2ui injection + mcpApps) and the
CopilotKit-middleware-driven catalog injection that the langgraph-python
reference relies on have not been wired into Agno yet.
Adds the in-chat HITL demo (frontend-only useHumanInTheLoop with a
book_call tool and time-picker card) and the manifest entries that were
missing for cli-start, gen-ui-tool-based, hitl-in-chat, and
hitl-in-chat-booking.
Documents in PARITY_NOTES.md why mcp-apps is blocked on Langroid: the
runtime-level mcpApps middleware injects tools that the langroid custom
AG-UI adapter does not consume, since it builds a static tool list
against ALL_TOOLS.
Adds a dedicated CopilotRuntime route configured with mcpApps.servers pointing at the public Excalidraw MCP server, plus a no-tools ADK agent. The MCP middleware injects the remote tools and emits activity events that CopilotKit's built-in MCPAppsActivityRenderer renders inline as a sandboxed iframe.
Frontend-tool HITL via useHumanInTheLoop with an in-chat time-picker. Adds a dedicated ADK agent that prompts the model to call the frontend-defined book_call tool; the picker card is rendered inline by useHumanInTheLoop and resolves with the chosen slot or a cancellation.
Wires a dedicated chart-viz agent at /gen_ui_tool_based and updates the
demo page to mirror langgraph-python's tool-based generative UI pattern
(useComponent + render_bar_chart / render_pie_chart). Other reasoning
and interrupt-dependent demos remain framework-blocked; PARITY_NOTES
extended to cover hitl-in-chat-booking under the existing interrupt
skip.
Alem Tuzlak