Skip to content

The Open Standard for Generative UI

docs: add Angular to integrations and replace the generic integration path (#1239)

Visharad Kashyap60363e8197a9
diff --git a/docs/app/(home)/integrations/[slug]/page.tsx b/docs/app/(home)/integrations/[slug]/page.tsx
index 6fd33cf0c..af46fa732 100644
--- a/docs/app/(home)/integrations/[slug]/page.tsx
+++ b/docs/app/(home)/integrations/[slug]/page.tsx
@@ -74,42 +74,6 @@ export default async function IntegrationDetailPage(props: { params: Promise<{ s
<p className={styles.detailLead}>{integration.howItWorks}</p>
</section>
- <section className={styles.flowSection}>
- <h2>The integration path</h2>
- <ol className={styles.flowList}>
- <li>
- <span className={styles.flowNumber}>1</span>
- <div>
- <h3>Describe the interface</h3>
- <p>
- Generate a component prompt from the same OpenUI library that will render the
- response.
- </p>
- </div>
- </li>
- <li>
- <span className={styles.flowNumber}>2</span>
- <div>
- <h3>Stream structured output</h3>
- <p>
- Let {integration.name} own its part of the stack while OpenUI Lang travels as
- incremental text or mapped agent events.
- </p>
- </div>
- </li>
- <li>
- <span className={styles.flowNumber}>3</span>
- <div>
- <h3>Render and interact</h3>
- <p>
- Parse the stream with the matching OpenUI runtime, render real components, and
- return validated actions to the application.
- </p>
- </div>
- </li>
- </ol>
- </section>
-
{integration.install ? (
<section className={styles.installSection}>
<div>
@@ -122,6 +86,21 @@ export default async function IntegrationDetailPage(props: { params: Promise<{ s
</div>
</section>
) : null}
+
+ <section className={styles.flowSection}>
+ <h2>Integration steps</h2>
+ <ol className={styles.flowList}>
+ {integration.steps.map((step, index) => (
+ <li key={step.title}>
+ <span className={styles.flowNumber}>{index + 1}</span>
+ <div>
+ <h3>{step.title}</h3>
+ <p>{step.description}</p>
+ </div>
+ </li>
+ ))}
+ </ol>
+ </section>
</article>
<aside className={styles.resourceSidebar}>
diff --git a/docs/app/(home)/integrations/data.ts b/docs/app/(home)/integrations/data.ts
index 3f6b51322..0946d81d2 100644
--- a/docs/app/(home)/integrations/data.ts
+++ b/docs/app/(home)/integrations/data.ts
@@ -6,6 +6,11 @@ export interface IntegrationLink {
kind: "Docs" | "Example" | "Guide" | "GitHub" | "npm" | "Website" | "Plugin";
}
+export interface IntegrationStep {
+ title: string;
+ description: string;
+}
+
export interface Integration {
slug: string;
name: string;
@@ -14,6 +19,7 @@ export interface Integration {
type: string;
summary: string;
howItWorks: string;
+ steps: IntegrationStep[];
install?: string;
links: IntegrationLink[];
}
@@ -85,13 +91,30 @@ const integrationCatalog: Integration[] = [
"Wrap shadcn/ui components in an OpenUI library and let the model compose them as streaming interfaces.",
howItWorks:
"Each shadcn component is registered with defineComponent and a Zod prop schema. createLibrary produces both the prompt vocabulary and the renderer mapping used by the example chat app.",
+ steps: [
+ {
+ title: "Wrap your shadcn/ui components",
+ description:
+ "Register each component with defineComponent and a Zod prop schema, then combine them with createLibrary. The example library covers 45+ components, including cards, tables, charts, forms, and dialogs.",
+ },
+ {
+ title: "Generate the library spec",
+ description:
+ "Run openui generate --spec on the library file. The chat route passes that spec to generateSystemPrompt({ cloud: true }), so the model can only call components the client can render.",
+ },
+ {
+ title: "Render the responses",
+ description:
+ "Pass the library to Renderer from @openuidev/react-lang wherever your app shows model output. For a ready-made chat app, the example passes it to AgentInterface as componentLibrary instead.",
+ },
+ ],
links: [
{
label: "Integration guide",
href: "/docs/openui-lang/examples/design-systems/shadcn",
kind: "Guide",
},
- exampleLink("shadcn-chat"),
+ exampleLink("design-systems/shadcn"),
{ label: "shadcn/ui", href: "https://ui.shadcn.com", kind: "Website" },
],
},
@@ -105,8 +128,25 @@ const integrationCatalog: Integration[] = [
"Expose Material UI components to a model without replacing your existing React design system.",
howItWorks:
"The example wraps Material UI components with OpenUI definitions, generates a constrained component prompt, and renders model output back into the same Material UI primitives.",
+ steps: [
+ {
+ title: "Map MUI components to OpenUI",
+ description:
+ "Wrap Material UI components with defineComponent and Zod schemas, and export them through createLibrary. Charts use @mui/x-charts.",
+ },
+ {
+ title: "Generate the library spec",
+ description:
+ "Run openui generate --spec on src/library.ts. The chat route sends that spec to OpenUI Cloud and runs app-owned tools with runChatToolLoop.",
+ },
+ {
+ title: "Render inside your MUI theme",
+ description:
+ "Render responses with Renderer, or with AgentInterface as the example does, inside your MUI ThemeProvider. Generated components then use the app's theme and light or dark mode.",
+ },
+ ],
links: [
- exampleLink("material-ui-chat"),
+ exampleLink("design-systems/material-ui"),
{
label: "Defining components",
href: "/docs/openui-lang/defining-components",
@@ -125,8 +165,25 @@ const integrationCatalog: Integration[] = [
"Connect a live Handsontable spreadsheet to OpenUI so agent tools can analyze and update its data.",
howItWorks:
"The maintained example shares table state between Handsontable and a custom OpenUI SpreadsheetTable component. Tool calls update the server-side data, and the rendered component synchronizes those results back into the live grid.",
+ steps: [
+ {
+ title: "Share the table state",
+ description:
+ "Keep the table in a server-side store that both the grid and the chat route use. Edits made in Handsontable sync back to the server through POST /api/table.",
+ },
+ {
+ title: "Give the model spreadsheet tools",
+ description:
+ "Expose tools such as get_table_data, update_cells, add_rows, and set_formula. After a write, the model responds with a SpreadsheetTable component.",
+ },
+ {
+ title: "Sync results into the grid",
+ description:
+ "The Renderer draws SpreadsheetTable from the custom library, and the useSpreadsheetSync hook pushes the new data into the live Handsontable instance.",
+ },
+ ],
links: [
- exampleLink("hands-on-table-chat"),
+ exampleLink("miscellaneous/handsontable"),
{ label: "Handsontable", href: "https://handsontable.com", kind: "Website" },
],
},
@@ -141,9 +198,26 @@ const integrationCatalog: Integration[] = [
howItWorks:
"@openuidev/react-email provides 44 OpenUI component definitions, an emailLibrary, and prompt rules. OpenUI Lang streams into a React Email preview, which @react-email/render can convert to email-compatible HTML.",
install: "npm install @openuidev/react-email @openuidev/react-lang",
+ steps: [
+ {
+ title: "Import the email library",
+ description:
+ "Use emailLibrary from @openuidev/react-email. It covers 44 email-safe components, including headers, feature grids, pricing cards, and checkout tables.",
+ },
+ {
+ title: "Generate the email prompt",
+ description:
+ "Build the system prompt from emailLibrary and emailPromptOptions, so the model composes emails only from those components.",
+ },
+ {
+ title: "Preview and export HTML",
+ description:
+ "Stream the response into Renderer from @openuidev/react-lang for a live preview, then convert the email to client-compatible HTML with @react-email/render.",
+ },
+ ],
links: [
...packageLinks("@openuidev/react-email", "react-email", "/docs/api-reference/react-email"),
- exampleLink("react-email"),
+ exampleLink("miscellaneous/react-email"),
{ label: "React Email", href: "https://react.email", kind: "Website" },
],
},
@@ -158,8 +232,25 @@ const integrationCatalog: Integration[] = [
summary:
"Connect LangChain and LangGraph to OpenUI through first-party server and stream adapters.",
howItWorks:
- "The @openuidev/langchain package transforms LangGraph protocol-v2 events into AG-UI on the server, then agUIAdapter() consumes the stream in AgentInterface. If your backend already returns native LangGraph named-event SSE, use the bundled langGraphAdapter() and langGraphMessageFormat instead.",
+ "The @openuidev/langchain package transforms LangGraph protocol-v2 events into AG-UI on the server, then agUIAdapter() consumes the stream on the client. If your backend already returns native LangGraph named-event SSE, use the bundled langGraphAdapter() and langGraphMessageFormat instead.",
install: "npm install @openuidev/langchain @langchain/langgraph",
+ steps: [
+ {
+ title: "Add the stream transformer",
+ description:
+ "Add openUIStreamTransformer from @openuidev/langchain/transformer to your graph's streamTransformers, and give the agent the generated OpenUI system prompt.",
+ },
+ {
+ title: "Expose an AG-UI route",
+ description:
+ "Return createLangChainStreamResponse(request, options) from a server route. It starts a protocol-v2 run and relays the output as AG-UI SSE while the API key and deployment URL stay on the server.",
+ },
+ {
+ title: "Connect your chat UI",
+ description:
+ "Point fetchLLM at the route with agUIAdapter(), then pass it to AgentInterface for a ready-made chat app or to ChatProvider from @openuidev/react-headless for your own UI. For native LangGraph named-event SSE, use langGraphAdapter() with langGraphMessageFormat instead.",
+ },
+ ],
links: [
...packageLinks("@openuidev/langchain", "langchain", "/docs/api-reference/langchain"),
{
@@ -172,7 +263,7 @@ const integrationCatalog: Integration[] = [
href: "/docs/agent/agent-runtimes/langgraph-platform",
kind: "Guide",
},
- exampleLink("langchain-chat"),
+ exampleLink("agent-frameworks/langgraph-platform"),
],
},
{
@@ -184,8 +275,25 @@ const integrationCatalog: Integration[] = [
summary:
"Connect Vercel AI SDK UIMessage streams to OpenUI with OpenUI's bundled first-party adapter and message format.",
howItWorks:
- "Return the UIMessage SSE produced by streamText().toUIMessageStreamResponse(), then use vercelAIAdapter() with vercelAIMessageFormat in AgentInterface. OpenUI validates AI SDK v6 or v7 chunks and maps streamed text, tool inputs, tool results, multi-step lifecycles, and errors into AG-UI events.",
+ "Return the UIMessage SSE produced by streamText().toUIMessageStreamResponse(), then use vercelAIAdapter() with vercelAIMessageFormat on the client. OpenUI validates AI SDK v6 or v7 chunks and maps streamed text, tool inputs, tool results, multi-step lifecycles, and errors into AG-UI events.",
install: "npm install @openuidev/react-ui ai",
+ steps: [
+ {
+ title: "Stream with streamText",
+ description:
+ "Call streamText with the generated OpenUI system prompt and your AI SDK tools, then return toUIMessageStreamResponse() from the route.",
+ },
+ {
+ title: "Configure the adapter",
+ description:
+ "Create the client connection with fetchLLM({ streamAdapter: vercelAIAdapter(), messageFormat: vercelAIMessageFormat }).",
+ },
+ {
+ title: "Connect your chat UI",
+ description:
+ "Pass that llm to AgentInterface for a ready-made chat app, or to ChatProvider from @openuidev/react-headless to build your own UI. Either way, streamed text, tool calls, and multi-step runs arrive as the same chat events.",
+ },
+ ],
links: [
{
label: "Vercel AI adapter",
@@ -198,7 +306,7 @@ const integrationCatalog: Integration[] = [
kind: "Guide",
},
...packageLinks("@openuidev/react-headless", "react-headless"),
- exampleLink("vercel-ai-chat"),
+ exampleLink("agent-frameworks/vercel-ai-sdk"),
{ label: "AI SDK", href: "https://ai-sdk.dev", kind: "Website" },
],
},
@@ -209,11 +317,28 @@ const integrationCatalog: Integration[] = [
category: "ai-frameworks",
type: "Agent SDK",
summary:
- "Bridge Google ADK for TypeScript run events into AgentInterface with tools and multi-turn sessions.",
+ "Bridge Google ADK for TypeScript run events into OpenUI with tools and multi-turn sessions.",
howItWorks:
- "A Google ADK Agent and FunctionTool run in a Next.js route. ADK runAsync events are converted into streaming chat-completion chunks that OpenUI's adapter parses and renders.",
+ "A Google ADK Agent and FunctionTool run in a Next.js route. The route maps ADK runAsync events to AG-UI SSE, which agUIAdapter() parses on the client.",
+ steps: [
+ {
+ title: "Define the agent",
+ description:
+ "Create an ADK Agent with FunctionTool tools and use the generated OpenUI system prompt as its instruction. The example calls OpenUI Cloud through adk-llm-bridge's Custom() model adapter.",
+ },
+ {
+ title: "Bridge events to AG-UI",
+ description:
+ "Run the agent with a Runner whose sessions are keyed by chat thread, and map text, functionCall, and functionResponse parts to AG-UI text and tool events.",
+ },
+ {
+ title: "Connect your chat UI",
+ description:
+ "Create an llm with fetchLLM and agUIAdapter(), then pass it to AgentInterface for a ready-made chat app or to ChatProvider from @openuidev/react-headless for your own UI.",
+ },
+ ],
links: [
- exampleLink("google-adk"),
+ exampleLink("agent-frameworks/google-adk"),
{ label: "Google ADK", href: "https://github.com/google/adk-js", kind: "GitHub" },
],
},
@@ -224,11 +349,28 @@ const integrationCatalog: Integration[] = [
category: "ai-frameworks",
type: "Agent framework",
summary:
- "Connect a Mastra agent to AgentInterface over AG-UI and render its streamed output as typed interfaces.",
+ "Connect a Mastra agent to OpenUI over AG-UI and render its streamed output as typed interfaces.",
howItWorks:
- "Mastra owns the agent and tools, the AG-UI transport serializes the run as SSE, and OpenUI's agUIAdapter drives AgentInterface and the component renderer on the client.",
+ "Mastra owns the agent and tools, the AG-UI transport serializes the run as SSE, and OpenUI's agUIAdapter drives the chat state and component renderer on the client.",
+ steps: [
+ {
+ title: "Build the Mastra agent",
+ description:
+ "Define the Agent with createTool tools and the generated OpenUI instructions. The example registers a custom Mastra gateway that routes model calls through OpenUI Cloud.",
+ },
+ {
+ title: "Stream AG-UI events",
+ description:
+ "Wrap the agent with MastraAgent from @ag-ui/mastra in a server route and stream its AG-UI events to the browser as SSE.",
+ },
+ {
+ title: "Connect your chat UI",
+ description:
+ "Create an llm with fetchLLM and agUIAdapter(), then pass it to AgentInterface for a ready-made chat app or to ChatProvider from @openuidev/react-headless for your own UI.",
+ },
+ ],
links: [
- exampleLink("mastra-chat"),
+ exampleLink("agent-frameworks/mastra"),
{
label: "Mastra integration guide",
href: "https://mastra.ai/guides/build-your-ui/openui",
@@ -248,6 +390,23 @@ const integrationCatalog: Integration[] = [
howItWorks:
"The @openuidev/assistant-ui toolkit registers display and human-input tools, generates matching model instructions, renders partial OpenUI Lang, and sends validated form actions back through assistant-ui's tool result flow.",
install: "npm install @openuidev/assistant-ui @assistant-ui/react",
+ steps: [
+ {
+ title: "Register the OpenUI toolkit",
+ description:
+ "Inside AssistantRuntimeProvider, add openuiIntegration.toolkit through AuiConfig and pass openuiIntegration.instructions to useAssistantInstructions.",
+ },
+ {
+ title: "Let the model call the OpenUI tools",
+ description:
+ "present_openui renders complete cards, tables, and charts. prompt_openui renders forms and choices, and completes only when the user submits a result.",
+ },
+ {
+ title: "Bring your own components",
+ description:
+ "Call createOpenUIIntegration with your own library so the tool schemas, model instructions, and renderers share one component vocabulary.",
+ },
+ ],
links: [
...packageLinks("@openuidev/assistant-ui", "assistant-ui"),
{
@@ -272,6 +431,23 @@ const integrationCatalog: Integration[] = [
"Consume standard AG-UI event streams in OpenUI chat surfaces with the built-in agUIAdapter.",
howItWorks:
"Point fetchLLM or a direct ChatLLM implementation at an AG-UI SSE endpoint and use agUIAdapter() as the stream adapter. OpenUI maps supported lifecycle, text, tool, and error events into its chat runtime.",
+ steps: [
+ {
+ title: "Prompt your agent for OpenUI Lang",
+ description:
+ "Give the agent a system prompt generated from the same component library the client renders, so its text output is valid OpenUI Lang.",
+ },
+ {
+ title: "Serve AG-UI events",
+ description:
+ "Expose the agent as an SSE endpoint that emits standard AG-UI run lifecycle, text message, tool call, and error events.",
+ },
+ {
+ title: "Connect the adapter",
+ description:
+ "Point fetchLLM, or your own ChatLLM implementation, at that endpoint with agUIAdapter() as the stream adapter. Pass it to AgentInterface for a ready-made chat app, or to ChatProvider from @openuidev/react-headless for your own UI.",
+ },
+ ],
links: [
{
label: "Adapters and formats",
@@ -292,6 +468,23 @@ const integrationCatalog: Integration[] = [
"Use OpenUI as a generative UI frontend for persistent Grok Build coding-agent sessions.",
howItWorks:
"The maintained local harness talks to Grok Build through its official Agent Client Protocol stdio mode, injects the generated OpenUI rules, and maps reasoning, text, tools, and interactions into AG-UI events for AgentInterface. As shipped, it is an unauthenticated single-user harness and needs authentication, sandboxing, and a stricter permission policy before networked deployment.",
+ steps: [
+ {
+ title: "Install and sign in to Grok Build",
+ description:
+ "Put the grok CLI on your PATH and run grok login. In non-interactive environments, set XAI_API_KEY instead.",
+ },
+ {
+ title: "Start the harness on a workspace",
+ description:
+ "Launch the example with the project directory Grok Build should work in. It runs one grok agent stdio process and opens a separate ACP session for each OpenUI thread, with the OpenUI prompt added as session rules.",
+ },
+ {
+ title: "Answer questions and approve plans in the browser",
+ description:
+ "Grok's clarifying questions and plan approvals appear as browser dialogs, and your answers go back over ACP so the same turn can continue.",
+ },
+ ],
links: [
exampleLink("harnesses/grok-build", "OpenUI harness"),
{ label: "Grok Build", href: "https://github.com/xai-org/grok-build", kind: "GitHub" },
@@ -307,13 +500,30 @@ const integrationCatalog: Integration[] = [
"Connect Vercel Eve's resumable agent sessions to OpenUI while preserving Eve's native runtime.",
howItWorks:
"The maintained harness delivers turns over Eve's native session protocol, resumes its event stream from a stored cursor, and translates Eve text, tool, and failure events into AG-UI for AgentInterface. The example uses an unauthenticated local Eve channel; a deployed version must configure channel authentication and appropriate tool permissions.",
+ steps: [
+ {
+ title: "Add the OpenUI instructions",
+ description:
+ "Add an Eve instruction that injects the generated OpenUI Lang prompt when each session starts, alongside the agent's own identity and tools.",
+ },
+ {
+ title: "Deliver turns over Eve's session protocol",
+ description:
+ "Send each turn through Eve's HTTP channel and store the session cursor per OpenUI thread, so the NDJSON event stream can resume where it stopped.",
+ },
+ {
+ title: "Map events with eveAdapter()",
+ description:
+ "Use eveAdapter() from @openuidev/react-headless as the llm's stream protocol. It converts Eve text, tool call, and failure events into AG-UI for AgentInterface or your own UI built on ChatProvider.",
+ },
+ ],
links: [
{
label: "Integration guide",
href: "/docs/agent/agent-runtimes/vercel-eve",
kind: "Guide",
},
- exampleLink("harnesses/vercel-eve", "OpenUI harness"),
+ exampleLink("agent-frameworks/vercel-eve", "OpenUI harness"),
{ label: "Vercel Eve", href: "https://github.com/vercel/eve", kind: "GitHub" },
],
},
@@ -327,13 +537,30 @@ const integrationCatalog: Integration[] = [
"Embed the Pi coding-agent SDK behind OpenUI and render its answers, reasoning, and tool activity.",
howItWorks:
"The maintained local harness embeds @earendil-works/pi-coding-agent in a Next.js route, injects the prompt generated from OpenUI's component library, and converts Pi text, reasoning, and tool events into an OpenAI-compatible stream consumed by openAIReadableStreamAdapter(). It exposes real filesystem and shell tools, so the shipped unauthenticated harness must not be exposed to a network as-is.",
+ steps: [
+ {
+ title: "Embed the Pi SDK",
+ description:
+ "Create one Pi AgentSession per chat thread with createAgentSession in a Node.js route. Point its model at OpenUI Cloud and append the generated OpenUI prompt.",
+ },
+ {
+ title: "Translate Pi events",
+ description:
+ "Write Pi text deltas to delta.content and its reasoning and tool executions to delta.tool_calls, one OpenAI chat.completion.chunk per NDJSON line.",
+ },
+ {
+ title: "Render with the NDJSON adapter",
+ description:
+ "Parse the stream with openAIReadableStreamAdapter(), then render the answers, reasoning, and tool activity with AgentInterface or your own UI built on ChatProvider.",
+ },
+ ],
links: [
{
label: "Integration guide",
href: "/docs/agent/agent-runtimes/pi",
kind: "Guide",
},
- exampleLink("harnesses/pi-agent-harness", "OpenUI harness"),
+ exampleLink("harnesses/pi", "OpenUI harness"),
{ label: "Pi", href: "https://pi.dev", kind: "Website" },
{ label: "Pi source", href: "https://github.com/earendil-works/pi", kind: "GitHub" },
],
@@ -349,6 +576,23 @@ const integrationCatalog: Integration[] = [
"Render charts, forms, tables, cards, and follow-ups directly inside Open WebUI conversations.",
howItWorks:
"The plugin gives the model a render_openui tool and returns a self-contained HTML response. A sandboxed iframe loads the OpenUI browser bundle and renders the generated program inline.",
+ steps: [
+ {
+ title: "Install the tool",
+ description:
+ "Import the plugin from the Open WebUI community site, or create a tool in Admin > Tools and paste in the plugin's tool.py.",
+ },
+ {
+ title: "Enable it for a model",
+ description:
+ "Turn the tool on for the models or chats that should render UI. The model calls render_openui when an answer needs a chart, form, table, or card.",
+ },
+ {
+ title: "Choose where the bundle loads from",
+ description:
+ "The cdn_base_url valve sets where the OpenUI browser bundle loads from. By default it is the latest @openuidev/browser-bundle on jsDelivr.",
+ },
+ ],
links: [
{
label: "Plugin source",
@@ -376,6 +620,23 @@ const integrationCatalog: Integration[] = [
howItWorks:
"@lynx-js/genui/openui incrementally parses OpenUI Lang, maps registered expressions to ReactLynx components, and renders them through Lynx's native pipeline while the host application owns its component definitions, tools, and actions.",
install: "npm install @lynx-js/genui @lynx-js/react @lynx-js/lynx-ui",
+ steps: [
+ {
+ title: "Create the library",
+ description:
+ "Build a component library with createOpenUiLibrary() from @lynx-js/genui/openui, and import the renderer stylesheet from @lynx-js/genui/openui/styles/renderer.css.",
+ },
+ {
+ title: "Generate the agent instructions",
+ description:
+ "On the server, build the system prompt with buildOpenUiSystemPrompt() from @lynx-js/genui/openui/prompt.",
+ },
+ {
+ title: "Render with OpenUiRenderer",
+ description:
+ "Pass the full text received so far, not just the latest delta, to OpenUiRenderer with the library. Handle host-side effects such as navigation in onAction.",
+ },
+ ],
links: [
{
label: "OpenUI integration guide",
@@ -406,12 +667,67 @@ const integrationCatalog: Integration[] = [
howItWorks:
"Vue component definitions and Zod schemas form a shared library for prompt generation and rendering. The Vue Renderer updates progressively as OpenUI Lang arrives.",
install: "npm install @openuidev/vue-lang",
+ steps: [
+ {
+ title: "Define Vue components",
+ description:
+ "Register each Vue component with defineComponent and a Zod prop schema, then combine them with createLibrary.",
+ },
+ {
+ title: "Generate the system prompt",
+ description:
+ "Build the prompt from the same library with library.prompt(), or with generateSystemPrompt on the server, so the model only calls components the renderer knows.",
+ },
+ {
+ title: "Render the stream",
+ description:
+ "Bind the streamed text to the Renderer component's response prop along with library and is-streaming. Handle button and form actions with on-action.",
+ },
+ ],
links: [
...packageLinks("@openuidev/vue-lang", "vue-lang"),
- exampleLink("vue-chat"),
+ exampleLink("app-frameworks/vue"),
{ label: "Vue", href: "https://vuejs.org", kind: "Website" },
],
},
+ {
+ slug: "angular",
+ name: "Angular",
+ logo: "/integration-logos/angular.svg",
+ category: "frontend-platforms",
+ type: "Native runtime",
+ summary:
+ "Define model-renderable Angular components and render streamed OpenUI Lang with @openuidev/angular-lang.",
+ howItWorks:
+ "Standalone Angular components and Zod schemas form one library for prompt generation and rendering. The openui-renderer component resolves streamed statements into those components, and injection helpers give them access to actions, form state, and query loading.",
+ install: "npm install @openuidev/angular-lang zod rxjs",
+ steps: [
+ {
+ title: "Define Angular components",
+ description:
+ "Write standalone components that accept props, renderNode, and statementId inputs. Register each one with defineComponent and a Zod schema, then combine them with createLibrary.",
+ },
+ {
+ title: "Generate the system prompt",
+ description:
+ "Call library.prompt() in the app, or share the Zod schemas with a Node backend and use @openuidev/lang-core so the server never imports Angular classes.",
+ },
+ {
+ title: "Render with openui-renderer",
+ description:
+ "Import Renderer and bind response, library, and isStreaming. Handle the (action), (stateUpdate), and (error) outputs, and pass a toolProvider to run Query and Mutation calls.",
+ },
+ ],
+ links: [
+ ...packageLinks(
+ "@openuidev/angular-lang",
+ "angular-lang",
+ "/docs/api-reference/angular-lang",
+ ),
+ exampleLink("app-frameworks/angular"),
+ { label: "Angular", href: "https://angular.dev", kind: "Website" },
+ ],
+ },
{
slug: "react-native",
name: "React Native",
@@ -422,13 +738,25 @@ const integrationCatalog: Integration[] = [
"Render model-generated interfaces in a native mobile chat application with a dedicated component library.",
howItWorks:
"The reference project pairs a React Native chat app with a backend that prompts for OpenUI Lang. Native component definitions map the same structured response model to mobile views and actions.",
- links: [
+ steps: [
{
- label: "Integration guide",
- href: "/docs/openui-lang/examples/app-frameworks/react-native",
- kind: "Guide",
+ title: "Describe the components on the backend",
+ description:
+ "Define the component vocabulary (Card, Text, and chart components) with defineComponent and createLibrary in a Node-compatible file, with renderers set to null. The CLI compiles it into the system prompt.",
},
- exampleLink("openui-react-native"),
+ {
+ title: "Stream plain text",
+ description:
+ "Return raw text/plain chunks from the chat route instead of SSE, so the mobile app can read the stream without a browser EventSource.",
+ },
+ {
+ title: "Render native components",
+ description:
+ "Use Renderer from @openuidev/react-lang in the Expo app with a library that maps the same component names to native views and charts.",
+ },
+ ],
+ links: [
+ exampleLink("app-frameworks/react-native"),
{ label: "React Native", href: "https://reactnative.dev", kind: "Website" },
],
},
@@ -443,9 +771,26 @@ const integrationCatalog: Integration[] = [
howItWorks:
"Svelte component definitions and Zod schemas become one component library. The package generates the model prompt and its Renderer resolves streamed statements into Svelte components.",
install: "npm install @openuidev/svelte-lang",
+ steps: [
+ {
+ title: "Define Svelte components",
+ description:
+ "Pair each .svelte component with defineComponent and a Zod prop schema, then combine them with createLibrary.",
+ },
+ {
+ title: "Generate the system prompt",
+ description:
+ "Build the prompt from the same library with library.prompt(), or with generateSystemPrompt on the server, so the model only calls components the renderer knows.",
+ },
+ {
+ title: "Render the stream",
+ description:
+ "Pass the streamed text, the library, and isStreaming to the Renderer component. It resolves each statement into a Svelte component as it arrives.",
+ },
+ ],
links: [
...packageLinks("@openuidev/svelte-lang", "svelte-lang"),
- exampleLink("svelte-chat"),
+ exampleLink("app-frameworks/svelte"),
{ label: "Svelte", href: "https://svelte.dev", kind: "Website" },
],
},
@@ -465,7 +810,15 @@ const popularityOrder: Record<IntegrationCategoryId, string[]> = {
"google-adk",
],
"design-systems": ["shadcn-ui", "material-ui", "handsontable", "react-email"],
- "frontend-platforms": ["vue", "svelte", "react-native", "lynx", "assistant-ui", "open-webui"],
+ "frontend-platforms": [
+ "vue",
+ "angular",
+ "svelte",
+ "react-native",
+ "lynx",
+ "assistant-ui",
+ "open-webui",
+ ],
};
export const integrationBySlug = new Map(integrations.map((item) => [item.slug, item]));
diff --git a/docs/public/integration-logos/angular.svg b/docs/public/integration-logos/angular.svg
new file mode 100644
index 000000000..02f619a0c
--- /dev/null
+++ b/docs/public/integration-logos/angular.svg
@@ -0,0 +1 @@
+<svg fill="#0F0F11" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Angular</title><path d="M16.712 17.711H7.288l-1.204 2.916L12 24l5.916-3.373-1.204-2.916ZM14.692 0l7.832 16.855.814-12.856L14.692 0ZM9.308 0 .662 3.999l.814 12.856L9.308 0Zm-.405 13.93h6.198L12 6.396 8.903 13.93Z"/></svg>