@assistant-ui/react-generative-ui 0.0.2

package/dist/generativeUIToJSX.d.ts

@@ -0,0 +1,16 @@
+//#region src/generativeUIToJSX.d.ts
+/**
+ * Serializes a generative-UI node to a JSX-like string for display — the
+ * "view source" of a model-produced tree. The wire form
+ * `{ $type: "Weather", id: "x" }` becomes `<Weather id="x" />`, and nested
+ * `children` render between tags: `<Card title="Hi"><Text>hello</Text></Card>`.
+ *
+ * It is a faithful textual rendering, not a parser: text children are emitted
+ * verbatim (not HTML/JSX-escaped), so the result is meant to be shown, not
+ * re-parsed. Returns `""` for nodes that aren't renderable (no `$type` yet,
+ * `null`, booleans).
+ */
+declare function generativeUIToJSX(node: unknown): string;
+//#endregion
+export { generativeUIToJSX };
+//# sourceMappingURL=generativeUIToJSX.d.ts.map

package/dist/generativeUIToJSX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generativeUIToJSX.d.ts","names":[],"sources":["../src/generativeUIToJSX.ts"],"mappings":";;AAaA;;;;AAA+C;;;;;;iBAA/B,iBAAA,CAAkB,IAAa"}

package/dist/generativeUIToJSX.js

@@ -0,0 +1,46 @@
+import { TYPE_KEY } from "./constants.js";
+//#region src/generativeUIToJSX.ts
+/**
+* Serializes a generative-UI node to a JSX-like string for display — the
+* "view source" of a model-produced tree. The wire form
+* `{ $type: "Weather", id: "x" }` becomes `<Weather id="x" />`, and nested
+* `children` render between tags: `<Card title="Hi"><Text>hello</Text></Card>`.
+*
+* It is a faithful textual rendering, not a parser: text children are emitted
+* verbatim (not HTML/JSX-escaped), so the result is meant to be shown, not
+* re-parsed. Returns `""` for nodes that aren't renderable (no `$type` yet,
+* `null`, booleans).
+*/
+function generativeUIToJSX(node) {
+	return toJSX(node, 0);
+}
+/**
+* The deepest tree we serialize. Input is model-produced, so a runaway/
+* adversarial response could nest arbitrarily deep and overflow the stack — past
+* this depth (far beyond any real UI) we stop. Mirrors the renderer's bound.
+*/
+const MAX_DEPTH = 64;
+function toJSX(node, depth) {
+	if (depth > MAX_DEPTH) return "";
+	if (node == null || typeof node === "boolean") return "";
+	if (typeof node === "string") return node;
+	if (typeof node === "number") return String(node);
+	if (Array.isArray(node)) return node.map((child) => toJSX(child, depth + 1)).join("");
+	if (typeof node !== "object") return "";
+	const { [TYPE_KEY]: type, children, ...props } = node;
+	if (typeof type !== "string") return "";
+	const attrs = Object.entries(props).map(([key, value]) => formatAttr(key, value)).join("");
+	const inner = children === void 0 ? "" : toJSX(children, depth + 1);
+	return inner === "" ? `<${type}${attrs} />` : `<${type}${attrs}>${inner}</${type}>`;
+}
+/** Formats one prop as a JSX attribute (`id="x"`, `count={3}`, `open`, …). */
+function formatAttr(key, value) {
+	if (value === void 0) return "";
+	if (value === true) return ` ${key}`;
+	if (typeof value === "string") return /["\n]/.test(value) ? ` ${key}={${JSON.stringify(value)}}` : ` ${key}="${value}"`;
+	return ` ${key}={${JSON.stringify(value)}}`;
+}
+//#endregion
+export { generativeUIToJSX };
+
+//# sourceMappingURL=generativeUIToJSX.js.map

package/dist/generativeUIToJSX.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generativeUIToJSX.js","names":[],"sources":["../src/generativeUIToJSX.ts"],"sourcesContent":["import { TYPE_KEY } from \"./constants\";\n\n/**\n * Serializes a generative-UI node to a JSX-like string for display — the\n * \"view source\" of a model-produced tree. The wire form\n * `{ $type: \"Weather\", id: \"x\" }` becomes `<Weather id=\"x\" />`, and nested\n * `children` render between tags: `<Card title=\"Hi\"><Text>hello</Text></Card>`.\n *\n * It is a faithful textual rendering, not a parser: text children are emitted\n * verbatim (not HTML/JSX-escaped), so the result is meant to be shown, not\n * re-parsed. Returns `\"\"` for nodes that aren't renderable (no `$type` yet,\n * `null`, booleans).\n */\nexport function generativeUIToJSX(node: unknown): string {\n  return toJSX(node, 0);\n}\n\n/**\n * The deepest tree we serialize. Input is model-produced, so a runaway/\n * adversarial response could nest arbitrarily deep and overflow the stack — past\n * this depth (far beyond any real UI) we stop. Mirrors the renderer's bound.\n */\nconst MAX_DEPTH = 64;\n\nfunction toJSX(node: unknown, depth: number): string {\n  if (depth > MAX_DEPTH) return \"\";\n  if (node == null || typeof node === \"boolean\") return \"\";\n  if (typeof node === \"string\") return node;\n  if (typeof node === \"number\") return String(node);\n  if (Array.isArray(node))\n    return node.map((child) => toJSX(child, depth + 1)).join(\"\");\n  if (typeof node !== \"object\") return \"\";\n\n  const {\n    [TYPE_KEY]: type,\n    children,\n    ...props\n  } = node as Record<string, unknown>;\n  if (typeof type !== \"string\") return \"\";\n\n  const attrs = Object.entries(props)\n    .map(([key, value]) => formatAttr(key, value))\n    .join(\"\");\n  const inner = children === undefined ? \"\" : toJSX(children, depth + 1);\n\n  return inner === \"\"\n    ? `<${type}${attrs} />`\n    : `<${type}${attrs}>${inner}</${type}>`;\n}\n\n/** Formats one prop as a JSX attribute (`id=\"x\"`, `count={3}`, `open`, …). */\nfunction formatAttr(key: string, value: unknown): string {\n  if (value === undefined) return \"\";\n  if (value === true) return ` ${key}`;\n  if (typeof value === \"string\") {\n    // Plain double-quoted form when safe; expression form when a quote or\n    // newline would break the attribute.\n    return /[\"\\n]/.test(value)\n      ? ` ${key}={${JSON.stringify(value)}}`\n      : ` ${key}=\"${value}\"`;\n  }\n  return ` ${key}={${JSON.stringify(value)}}`;\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,kBAAkB,MAAuB;CACvD,OAAO,MAAM,MAAM,CAAC;AACtB;;;;;;AAOA,MAAM,YAAY;AAElB,SAAS,MAAM,MAAe,OAAuB;CACnD,IAAI,QAAQ,WAAW,OAAO;CAC9B,IAAI,QAAQ,QAAQ,OAAO,SAAS,WAAW,OAAO;CACtD,IAAI,OAAO,SAAS,UAAU,OAAO;CACrC,IAAI,OAAO,SAAS,UAAU,OAAO,OAAO,IAAI;CAChD,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,KAAK,KAAK,UAAU,MAAM,OAAO,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE;CAC7D,IAAI,OAAO,SAAS,UAAU,OAAO;CAErC,MAAM,GACH,WAAW,MACZ,UACA,GAAG,UACD;CACJ,IAAI,OAAO,SAAS,UAAU,OAAO;CAErC,MAAM,QAAQ,OAAO,QAAQ,KAAK,EAC/B,KAAK,CAAC,KAAK,WAAW,WAAW,KAAK,KAAK,CAAC,EAC5C,KAAK,EAAE;CACV,MAAM,QAAQ,aAAa,KAAA,IAAY,KAAK,MAAM,UAAU,QAAQ,CAAC;CAErE,OAAO,UAAU,KACb,IAAI,OAAO,MAAM,OACjB,IAAI,OAAO,MAAM,GAAG,MAAM,IAAI,KAAK;AACzC;;AAGA,SAAS,WAAW,KAAa,OAAwB;CACvD,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI,UAAU,MAAM,OAAO,IAAI;CAC/B,IAAI,OAAO,UAAU,UAGnB,OAAO,QAAQ,KAAK,KAAK,IACrB,IAAI,IAAI,IAAI,KAAK,UAAU,KAAK,EAAE,KAClC,IAAI,IAAI,IAAI,MAAM;CAExB,OAAO,IAAI,IAAI,IAAI,KAAK,UAAU,KAAK,EAAE;AAC3C"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { GenerativeUIComponent, GenerativeUIElement, GenerativeUILibrary, GenerativeUINode, GenerativeUIProps, GenerativeUIRenderContext, GenerativeUIStatus } from "./types.js";
+import { JSONGenerativeUIOptions, PresentTool, PresentToolOptions, PromptUserTool } from "./JSONGenerativeUI.shared.js";
+import { buildPresentParameters } from "./buildPresentParameters.js";
+import { TYPE_KEY } from "./constants.js";
+import { defineGenerativeComponents } from "./defineGenerativeComponents.js";
+import { generativeUIToJSX } from "./generativeUIToJSX.js";
+import { renderGenerativeUI } from "./renderGenerativeUI.js";
+import { JSONGenerativeUI } from "@assistant-ui/react-generative-ui/internal-json";
+export { type GenerativeUIComponent, type GenerativeUIElement, type GenerativeUILibrary, type GenerativeUINode, type GenerativeUIProps, type GenerativeUIRenderContext, type GenerativeUIStatus, JSONGenerativeUI, type JSONGenerativeUIOptions, type PresentTool, type PresentToolOptions, type PromptUserTool, TYPE_KEY, buildPresentParameters, defineGenerativeComponents, generativeUIToJSX, renderGenerativeUI };

package/dist/index.js

@@ -0,0 +1,7 @@
+import { TYPE_KEY } from "./constants.js";
+import { buildPresentParameters } from "./buildPresentParameters.js";
+import { renderGenerativeUI } from "./renderGenerativeUI.js";
+import { defineGenerativeComponents } from "./defineGenerativeComponents.js";
+import { generativeUIToJSX } from "./generativeUIToJSX.js";
+import { JSONGenerativeUI } from "@assistant-ui/react-generative-ui/internal-json";
+export { JSONGenerativeUI, TYPE_KEY, buildPresentParameters, defineGenerativeComponents, generativeUIToJSX, renderGenerativeUI };

package/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts

@@ -0,0 +1,141 @@
+//#region ../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts
+// ==================================================================================================
+// JSON Schema Draft 07
+// ==================================================================================================
+// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+// --------------------------------------------------------------------------------------------------
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7TypeName = "string" //
+| "number" | "integer" | "boolean" | "object" | "array" | "null";
+/**
+ * Primitive type
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
+ */
+type JSONSchema7Type = string //
+| number | boolean | JSONSchema7Object | JSONSchema7Array | null;
+// Workaround for infinite type recursion
+interface JSONSchema7Object {
+  [key: string]: JSONSchema7Type;
+}
+// Workaround for infinite type recursion
+// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
+interface JSONSchema7Array extends Array<JSONSchema7Type> {}
+/**
+ * Meta schema
+ *
+ * Recommended values:
+ * - 'http://json-schema.org/schema#'
+ * - 'http://json-schema.org/hyper-schema#'
+ * - 'http://json-schema.org/draft-07/schema#'
+ * - 'http://json-schema.org/draft-07/hyper-schema#'
+ *
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+ */
+type JSONSchema7Version = string;
+/**
+ * JSON Schema v7
+ * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
+ */
+type JSONSchema7Definition = JSONSchema7 | boolean;
+interface JSONSchema7 {
+  $id?: string | undefined;
+  $ref?: string | undefined;
+  $schema?: JSONSchema7Version | undefined;
+  $comment?: string | undefined;
+  /**
+   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
+   * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
+   */
+  $defs?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
+   */
+  type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
+  enum?: JSONSchema7Type[] | undefined;
+  const?: JSONSchema7Type | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
+   */
+  multipleOf?: number | undefined;
+  maximum?: number | undefined;
+  exclusiveMaximum?: number | undefined;
+  minimum?: number | undefined;
+  exclusiveMinimum?: number | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
+   */
+  maxLength?: number | undefined;
+  minLength?: number | undefined;
+  pattern?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
+   */
+  items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
+  additionalItems?: JSONSchema7Definition | undefined;
+  maxItems?: number | undefined;
+  minItems?: number | undefined;
+  uniqueItems?: boolean | undefined;
+  contains?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
+   */
+  maxProperties?: number | undefined;
+  minProperties?: number | undefined;
+  required?: string[] | undefined;
+  properties?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  patternProperties?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  additionalProperties?: JSONSchema7Definition | undefined;
+  dependencies?: {
+    [key: string]: JSONSchema7Definition | string[];
+  } | undefined;
+  propertyNames?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
+   */
+  if?: JSONSchema7Definition | undefined;
+  then?: JSONSchema7Definition | undefined;
+  else?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
+   */
+  allOf?: JSONSchema7Definition[] | undefined;
+  anyOf?: JSONSchema7Definition[] | undefined;
+  oneOf?: JSONSchema7Definition[] | undefined;
+  not?: JSONSchema7Definition | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
+   */
+  format?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
+   */
+  contentMediaType?: string | undefined;
+  contentEncoding?: string | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
+   */
+  definitions?: {
+    [key: string]: JSONSchema7Definition;
+  } | undefined;
+  /**
+   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+   */
+  title?: string | undefined;
+  description?: string | undefined;
+  default?: JSONSchema7Type | undefined;
+  readOnly?: boolean | undefined;
+  writeOnly?: boolean | undefined;
+  examples?: JSONSchema7Type | undefined;
+}
+//#endregion
+export { JSONSchema7 };
+//# sourceMappingURL=index.d.ts.map

package/dist/node_modules/.pnpm/@types_json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["JSONSchema4Object","JSONSchema4Array","key","JSONSchema4Type","Array","id","$ref","$schema","JSONSchema4Version","title","description","default","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","additionalItems","JSONSchema4","items","maxItems","minItems","uniqueItems","maxProperties","minProperties","required","additionalProperties","definitions","k","properties","patternProperties","dependencies","enum","type","JSONSchema4TypeName","allOf","anyOf","oneOf","not","extends","format","JSONSchema6Object","JSONSchema6Array","JSONSchema6Type","JSONSchema6","$id","JSONSchema6Version","JSONSchema6Definition","contains","propertyNames","const","JSONSchema6TypeName","examples","JSONSchema7Object","JSONSchema7Array","JSONSchema7Type","JSONSchema7","JSONSchema7Version","$comment","$defs","JSONSchema7Definition","JSONSchema7TypeName","if","then","else","contentMediaType","contentEncoding","readOnly","writeOnly","valid","errors","ValidationError","property","message","instance","schema","ValidationResult","value","result"],"sources":["../../../../../../../../../node_modules/.pnpm/@types+json-schema@7.0.15/node_modules/@types/json-schema/index.d.ts"],"x_google_ignoreList":[0],"mappings":";;;;;;;;;;KA+iBY,mBAAA;AAAA;;;;;KAaA,eAAA;AAAA,qBAIN,iBAAA,GACA,gBAAgB;AAAA;AAAA,UAIL,iBAAA;EAAA,CACZE,GAAAA,WAAc,eAAe;AAAA;AAAA;AAAA;AAAA,UAKjB,gBAAA,SAAyB,KAAK,CAAC,eAAA;;;;;;;;;;;;KAapC,kBAAA;;;;;KAMA,qBAAA,GAAwB,WAAW;AAAA,UAC9B,WAAA;EACb8C,GAAAA;EACA1C,IAAAA;EACAC,OAAAA,GAAU,kBAAA;EACVsD,QAAAA;;;;;EAMAC,KAAAA;IAAAA,CACK5D,GAAAA,WAAc,qBAAA;EAAA;;;;EAMnBkC,IAAAA,GAAO,mBAAA,GAAsB,mBAAA;EAC7BD,IAAAA,GAAO,eAAA;EACPkB,KAAAA,GAAQ,eAAA;;;;EAKRzC,UAAAA;EACAC,OAAAA;EACAC,gBAAAA;EACAC,OAAAA;EACAC,gBAAAA;;;;EAKAC,SAAAA;EACAC,SAAAA;EACAC,OAAAA;;;;EAKAG,KAAAA,GAAQ,qBAAA,GAAwB,qBAAA;EAChCF,eAAAA,GAAkB,qBAAA;EAClBG,QAAAA;EACAC,QAAAA;EACAC,WAAAA;EACA0B,QAAAA,GAAW,qBAAA;;;;EAKXzB,aAAAA;EACAC,aAAAA;EACAC,QAAAA;EACAI,UAAAA;IAAAA,CACK9B,GAAAA,WAAc,qBAAA;EAAA;EAEnB+B,iBAAAA;IAAAA,CACK/B,GAAAA,WAAc,qBAAA;EAAA;EAEnB2B,oBAAAA,GAAuB,qBAAA;EACvBK,YAAAA;IAAAA,CACKhC,GAAAA,WAAc,qBAAA;EAAA;EAEnBkD,aAAAA,GAAgB,qBAAA;;;;EAKhBa,EAAAA,GAAK,qBAAA;EACLC,IAAAA,GAAO,qBAAA;EACPC,IAAAA,GAAO,qBAAA;;;;EAKP7B,KAAAA,GAAQ,qBAAA;EACRC,KAAAA,GAAQ,qBAAA;EACRC,KAAAA,GAAQ,qBAAA;EACRC,GAAAA,GAAM,qBAAA;;;;EAKNE,MAAAA;;;;EAKAyB,gBAAAA;EACAC,eAAAA;;;;EAKAvC,WAAAA;IAAAA,CACK5B,GAAAA,WAAc,qBAAA;EAAA;;;;EAMnBO,KAAAA;EACAC,WAAAA;EACAC,OAAAA,GAAU,eAAA;EACV2D,QAAAA;EACAC,SAAAA;EACAhB,QAAAA,GAAW,eAAA;AAAA"}

package/dist/renderGenerativeUI.d.ts

@@ -0,0 +1,17 @@
+import { GenerativeUILibrary, GenerativeUIRenderContext } from "./types.js";
+import { ReactNode } from "react";
+
+//#region src/renderGenerativeUI.d.ts
+/**
+ * Renders a generative-ui tree against a {@link GenerativeUILibrary}.
+ *
+ * The model emits each node as a flat object `{ $type, ...props }`. We first
+ * normalize that wire form into React-shaped elements (`{ type, props }`), then
+ * render: each `type` is looked up in the library and its `props` are passed
+ * to the component's `render(props, context)`, with `children` rendered
+ * recursively so components can nest.
+ */
+declare function renderGenerativeUI(node: unknown, library: GenerativeUILibrary, context?: GenerativeUIRenderContext): ReactNode;
+//#endregion
+export { renderGenerativeUI };
+//# sourceMappingURL=renderGenerativeUI.d.ts.map

package/dist/renderGenerativeUI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderGenerativeUI.d.ts","names":[],"sources":["../src/renderGenerativeUI.tsx"],"mappings":";;;;;;AAoBA;;;;;;;iBAAgB,kBAAA,CACd,IAAA,WACA,OAAA,EAAS,mBAAA,EACT,OAAA,GAAS,yBAAA,GACR,SAAA"}

package/dist/renderGenerativeUI.js

@@ -0,0 +1,85 @@
+import { TYPE_KEY } from "./constants.js";
+import { Fragment } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/renderGenerativeUI.tsx
+const DEFAULT_CONTEXT = { status: "done" };
+/**
+* Renders a generative-ui tree against a {@link GenerativeUILibrary}.
+*
+* The model emits each node as a flat object `{ $type, ...props }`. We first
+* normalize that wire form into React-shaped elements (`{ type, props }`), then
+* render: each `type` is looked up in the library and its `props` are passed
+* to the component's `render(props, context)`, with `children` rendered
+* recursively so components can nest.
+*/
+function renderGenerativeUI(node, library, context = DEFAULT_CONTEXT) {
+	return renderNode(normalizeNode(node), library, context);
+}
+/**
+* The deepest tree we normalize. The input comes from the model, so a runaway
+* or adversarial response could nest arbitrarily deep and overflow the stack;
+* past this depth we stop (far beyond any real UI). Bounding normalization
+* bounds rendering too, since it only walks the normalized tree.
+*/
+const MAX_DEPTH = 64;
+/** Converts the flat wire form into a normalized {@link GenerativeUINode}. */
+function normalizeNode(node, depth = 0) {
+	if (depth > MAX_DEPTH) return null;
+	if (node == null || typeof node === "boolean") return null;
+	if (typeof node === "string" || typeof node === "number") return node;
+	if (Array.isArray(node)) return node.map((child) => normalizeNode(child, depth + 1));
+	if (typeof node !== "object") return null;
+	const { [TYPE_KEY]: type, ...props } = node;
+	if (typeof type !== "string") return null;
+	if ("children" in props) props["children"] = normalizeNode(props["children"], depth + 1);
+	return {
+		type,
+		props
+	};
+}
+function renderNode(node, library, context) {
+	if (node == null || typeof node === "boolean") return null;
+	if (typeof node === "string" || typeof node === "number") return node;
+	if (Array.isArray(node)) return node.map((child, index) => /* @__PURE__ */ jsx(Fragment, { children: renderNode(child, library, context) }, `${index}:${nodeKind(child)}`));
+	return renderElement(node, library, context);
+}
+function renderElement(element, library, context) {
+	const entry = library[element.type];
+	if (!entry) {
+		reportUnknownComponent(element.type, Object.keys(library));
+		return null;
+	}
+	if (!entry.streamProperties && context.status === "streaming") return null;
+	const { children, ...rest } = element.props;
+	const props = {
+		...rest,
+		$status: context.status
+	};
+	if (children !== void 0) props["children"] = renderNode(children, library, context);
+	return /* @__PURE__ */ jsx(GenerativeUIComponentRenderer, {
+		render: entry.render,
+		props
+	});
+}
+/**
+* Mounts a single node's `render` on its own fiber so the function may use
+* hooks and hold state independently of its siblings and parent.
+*/
+function GenerativeUIComponentRenderer({ render, props }) {
+	return render(props);
+}
+/** A coarse kind tag for a child, used in its list key so a node changing kind
+* at a given index forces a remount rather than a wrong-fiber reuse. */
+function nodeKind(node) {
+	if (node == null || typeof node === "boolean") return "";
+	if (typeof node === "string" || typeof node === "number") return "#text";
+	if (Array.isArray(node)) return "#array";
+	return node.type;
+}
+function reportUnknownComponent(type, available) {
+	if (process.env["NODE_ENV"] !== "production") console.error(`[@assistant-ui/react-generative-ui] Unknown component "${type}". Available components: ${available.join(", ") || "(none)"}.`);
+}
+//#endregion
+export { renderGenerativeUI };
+
+//# sourceMappingURL=renderGenerativeUI.js.map

package/dist/renderGenerativeUI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderGenerativeUI.js","names":[],"sources":["../src/renderGenerativeUI.tsx"],"sourcesContent":["import { Fragment, type ReactNode } from \"react\";\nimport { TYPE_KEY } from \"./constants\";\nimport type {\n  GenerativeUIElement,\n  GenerativeUILibrary,\n  GenerativeUINode,\n  GenerativeUIRenderContext,\n} from \"./types\";\n\nconst DEFAULT_CONTEXT: GenerativeUIRenderContext = { status: \"done\" };\n\n/**\n * Renders a generative-ui tree against a {@link GenerativeUILibrary}.\n *\n * The model emits each node as a flat object `{ $type, ...props }`. We first\n * normalize that wire form into React-shaped elements (`{ type, props }`), then\n * render: each `type` is looked up in the library and its `props` are passed\n * to the component's `render(props, context)`, with `children` rendered\n * recursively so components can nest.\n */\nexport function renderGenerativeUI(\n  node: unknown,\n  library: GenerativeUILibrary,\n  context: GenerativeUIRenderContext = DEFAULT_CONTEXT,\n): ReactNode {\n  return renderNode(normalizeNode(node), library, context);\n}\n\n/**\n * The deepest tree we normalize. The input comes from the model, so a runaway\n * or adversarial response could nest arbitrarily deep and overflow the stack;\n * past this depth we stop (far beyond any real UI). Bounding normalization\n * bounds rendering too, since it only walks the normalized tree.\n */\nconst MAX_DEPTH = 64;\n\n/** Converts the flat wire form into a normalized {@link GenerativeUINode}. */\nfunction normalizeNode(node: unknown, depth = 0): GenerativeUINode {\n  if (depth > MAX_DEPTH) return null;\n  if (node == null || typeof node === \"boolean\") return null;\n  if (typeof node === \"string\" || typeof node === \"number\") return node;\n  if (Array.isArray(node))\n    return node.map((child) => normalizeNode(child, depth + 1));\n  if (typeof node !== \"object\") return null;\n\n  const { [TYPE_KEY]: type, ...props } = node as Record<string, unknown>;\n  // Args stream in incrementally; a node whose `$type` has not arrived yet is\n  // not an error, it just isn't renderable.\n  if (typeof type !== \"string\") return null;\n\n  if (\"children\" in props) {\n    props[\"children\"] = normalizeNode(props[\"children\"], depth + 1);\n  }\n  return { type, props } as GenerativeUIElement;\n}\n\nfunction renderNode(\n  node: GenerativeUINode,\n  library: GenerativeUILibrary,\n  context: GenerativeUIRenderContext,\n): ReactNode {\n  if (node == null || typeof node === \"boolean\") return null;\n  if (typeof node === \"string\" || typeof node === \"number\") return node;\n  if (Array.isArray(node)) {\n    // The wire format has no per-node id, so the key is positional. Pairing the\n    // index with the node's kind means that when the model splices or reorders\n    // `children` and the kind at an index changes, the key changes and React\n    // remounts instead of handing a streaming node's hook state to a different\n    // component.\n    return node.map((child, index) => (\n      <Fragment key={`${index}:${nodeKind(child)}`}>\n        {renderNode(child, library, context)}\n      </Fragment>\n    ));\n  }\n  return renderElement(node, library, context);\n}\n\nfunction renderElement(\n  element: GenerativeUIElement,\n  library: GenerativeUILibrary,\n  context: GenerativeUIRenderContext,\n): ReactNode {\n  const entry = library[element.type];\n  if (!entry) {\n    reportUnknownComponent(element.type, Object.keys(library));\n    return null;\n  }\n\n  // Components that opt out of prop streaming wait until their props are\n  // complete rather than rendering from a partial parse.\n  if (!entry.streamProperties && context.status === \"streaming\") return null;\n\n  // Inject the framework props last so the model can never override them.\n  const { children, ...rest } = element.props;\n  const props: Record<string, unknown> = { ...rest, $status: context.status };\n  if (children !== undefined) {\n    props[\"children\"] = renderNode(children, library, context);\n  }\n\n  return <GenerativeUIComponentRenderer render={entry.render} props={props} />;\n}\n\n/**\n * Mounts a single node's `render` on its own fiber so the function may use\n * hooks and hold state independently of its siblings and parent.\n */\nfunction GenerativeUIComponentRenderer({\n  render,\n  props,\n}: {\n  render: (props: any) => ReactNode;\n  props: Record<string, unknown>;\n}): ReactNode {\n  return render(props);\n}\n\n/** A coarse kind tag for a child, used in its list key so a node changing kind\n * at a given index forces a remount rather than a wrong-fiber reuse. */\nfunction nodeKind(node: GenerativeUINode): string {\n  if (node == null || typeof node === \"boolean\") return \"\";\n  if (typeof node === \"string\" || typeof node === \"number\") return \"#text\";\n  if (Array.isArray(node)) return \"#array\";\n  return node.type;\n}\n\nfunction reportUnknownComponent(type: string, available: string[]): void {\n  if (process.env[\"NODE_ENV\"] !== \"production\") {\n    // eslint-disable-next-line no-console\n    console.error(\n      `[@assistant-ui/react-generative-ui] Unknown component \"${type}\". ` +\n        `Available components: ${available.join(\", \") || \"(none)\"}.`,\n    );\n  }\n}\n"],"mappings":";;;;AASA,MAAM,kBAA6C,EAAE,QAAQ,OAAO;;;;;;;;;;AAWpE,SAAgB,mBACd,MACA,SACA,UAAqC,iBAC1B;CACX,OAAO,WAAW,cAAc,IAAI,GAAG,SAAS,OAAO;AACzD;;;;;;;AAQA,MAAM,YAAY;;AAGlB,SAAS,cAAc,MAAe,QAAQ,GAAqB;CACjE,IAAI,QAAQ,WAAW,OAAO;CAC9B,IAAI,QAAQ,QAAQ,OAAO,SAAS,WAAW,OAAO;CACtD,IAAI,OAAO,SAAS,YAAY,OAAO,SAAS,UAAU,OAAO;CACjE,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO,KAAK,KAAK,UAAU,cAAc,OAAO,QAAQ,CAAC,CAAC;CAC5D,IAAI,OAAO,SAAS,UAAU,OAAO;CAErC,MAAM,GAAG,WAAW,MAAM,GAAG,UAAU;CAGvC,IAAI,OAAO,SAAS,UAAU,OAAO;CAErC,IAAI,cAAc,OAChB,MAAM,cAAc,cAAc,MAAM,aAAa,QAAQ,CAAC;CAEhE,OAAO;EAAE;EAAM;CAAM;AACvB;AAEA,SAAS,WACP,MACA,SACA,SACW;CACX,IAAI,QAAQ,QAAQ,OAAO,SAAS,WAAW,OAAO;CACtD,IAAI,OAAO,SAAS,YAAY,OAAO,SAAS,UAAU,OAAO;CACjE,IAAI,MAAM,QAAQ,IAAI,GAMpB,OAAO,KAAK,KAAK,OAAO,UACtB,oBAAC,UAAD,EAAA,UACG,WAAW,OAAO,SAAS,OAAO,EAC3B,GAFK,GAAG,MAAM,GAAG,SAAS,KAAK,GAE/B,CACX;CAEH,OAAO,cAAc,MAAM,SAAS,OAAO;AAC7C;AAEA,SAAS,cACP,SACA,SACA,SACW;CACX,MAAM,QAAQ,QAAQ,QAAQ;CAC9B,IAAI,CAAC,OAAO;EACV,uBAAuB,QAAQ,MAAM,OAAO,KAAK,OAAO,CAAC;EACzD,OAAO;CACT;CAIA,IAAI,CAAC,MAAM,oBAAoB,QAAQ,WAAW,aAAa,OAAO;CAGtE,MAAM,EAAE,UAAU,GAAG,SAAS,QAAQ;CACtC,MAAM,QAAiC;EAAE,GAAG;EAAM,SAAS,QAAQ;CAAO;CAC1E,IAAI,aAAa,KAAA,GACf,MAAM,cAAc,WAAW,UAAU,SAAS,OAAO;CAG3D,OAAO,oBAAC,+BAAD;EAA+B,QAAQ,MAAM;EAAe;CAAQ,CAAA;AAC7E;;;;;AAMA,SAAS,8BAA8B,EACrC,QACA,SAIY;CACZ,OAAO,OAAO,KAAK;AACrB;;;AAIA,SAAS,SAAS,MAAgC;CAChD,IAAI,QAAQ,QAAQ,OAAO,SAAS,WAAW,OAAO;CACtD,IAAI,OAAO,SAAS,YAAY,OAAO,SAAS,UAAU,OAAO;CACjE,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO;CAChC,OAAO,KAAK;AACd;AAEA,SAAS,uBAAuB,MAAc,WAA2B;CACvE,IAAI,QAAQ,IAAI,gBAAgB,cAE9B,QAAQ,MACN,0DAA0D,KAAK,2BACpC,UAAU,KAAK,IAAI,KAAK,SAAS,EAC9D;AAEJ"}

package/dist/types.d.ts

@@ -0,0 +1,94 @@
+import { ReactNode } from "react";
+import { ZodType } from "zod";
+
+//#region src/types.d.ts
+/** Whether a node's props are still streaming in or have fully arrived. */
+type GenerativeUIStatus = "streaming" | "done";
+/** The render context threaded through {@link renderGenerativeUI}. */
+type GenerativeUIRenderContext = {
+  /** Whether the tool call's arguments are still streaming or are complete. */status: GenerativeUIStatus;
+};
+/**
+ * Props a component's `render` receives: its model props, rendered `children`,
+ * and the injected `$status`. `$status` is the discriminant — when it is
+ * `"done"`, `P` is complete; while `"streaming"`, `P` is partial. It is named
+ * `$status` (not `status`) so it never collides with a real `status` prop, the
+ * same reservation as `$type`.
+ */
+type StreamingRenderProps<P> = (Partial<P> & {
+  children?: ReactNode;
+  $status: "streaming";
+}) | (P & {
+  children?: ReactNode;
+  $status: "done";
+});
+/** Props for a component that only renders once complete — `$status` is always `"done"`. */
+type StaticRenderProps<P> = P & {
+  children?: ReactNode;
+  $status: "done";
+};
+/**
+ * A component the model is allowed to render, with the schema for its props.
+ *
+ * Components opt into prop streaming with `streamProperties`: they render as
+ * props arrive, so `render` sees `Partial<P>` while `$status` is `"streaming"`
+ * and the full `P` once it is `"done"`. By default a component opts out and is
+ * only rendered once its props are complete.
+ *
+ * `render` is a function of `props`, not a React component. Direct hook use is
+ * fine (each node is mounted on its own fiber), but a given node must keep its
+ * `type` across renders for hook identity to be stable.
+ */
+type GenerativeUIComponent<P = any> = {
+  /** Natural-language description shown to the model when selecting the component. */description: string; /** Schema for the props the model must provide. Drives the tool parameters. */
+  properties: ZodType<P>;
+  /**
+   * Render from partially-streamed props. Widened to `boolean | undefined`
+   * so a non-literal value (e.g. a variable) still resolves to this branch
+   * cleanly rather than matching neither; the strict `false | undefined`
+   * branch below is the only one that promises complete props.
+   */
+  streamProperties: boolean | undefined;
+  render: (props: StreamingRenderProps<P>) => ReactNode;
+} | {
+  description: string;
+  properties: ZodType<P>; /** Render only once props are complete (the default). */
+  streamProperties?: false | undefined;
+  render: (props: StaticRenderProps<P>) => ReactNode;
+};
+/**
+ * The consumer-provided allowlist of components the model is permitted to
+ * render. Keys are the `type` values referenced in the generative-ui tree
+ * (e.g. `"Card"`, `"Button"`); values describe each component.
+ *
+ * This registry is the security boundary — any `type` not present is rejected.
+ */
+type GenerativeUILibrary = Record<string, GenerativeUIComponent>;
+/**
+ * A component invocation — mirrors React's `ReactElement`.
+ *
+ * `type` selects a component from the {@link GenerativeUILibrary}; `props` are
+ * passed to it. The `children` prop is special: it is itself a renderable
+ * {@link GenerativeUINode}, drawn as generative UI rather than passed as data.
+ *
+ * On the wire the model emits the flattened form `{ $type, ...props }`, where
+ * `$type` names the component so a real `type` prop never collides. This is the
+ * normalized shape the renderer works with, the same way React normalizes
+ * `createElement` arguments into an element.
+ */
+type GenerativeUIElement = {
+  type: string;
+  props: GenerativeUIProps;
+};
+/** Props passed to a component — mirrors a React component's props. */
+type GenerativeUIProps = {
+  children?: GenerativeUINode;
+} & Record<string, unknown>;
+/**
+ * Anything renderable as generative UI — mirrors React's `ReactNode`: an
+ * element, primitive text, or a list of nodes.
+ */
+type GenerativeUINode = GenerativeUIElement | string | number | boolean | null | undefined | GenerativeUINode[];
+//#endregion
+export { GenerativeUIComponent, GenerativeUIElement, GenerativeUILibrary, GenerativeUINode, GenerativeUIProps, GenerativeUIRenderContext, GenerativeUIStatus };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;KAIY,kBAAA;AAAZ;AAAA,KAGY,yBAAA;+EAEV,MAAA,EAAQ,kBAAkB;AAAA;AAF5B;;;;AAE4B;AAC1B;;AAHF,KAYK,oBAAA,OACA,OAAA,CAAQ,CAAA;EAAO,QAAA,GAAW,SAAA;EAAW,OAAA;AAAA,MACrC,CAAA;EAAM,QAAA,GAAW,SAAA;EAAW,OAAA;AAAA;;KAG5B,iBAAA,MAAuB,CAAA;EAAM,QAAA,GAAW,SAAS;EAAE,OAAA;AAAA;;;;;;;;AAHhB;AAAA;;;;KAiB5B,qBAAA;EAdgB,oFAiBtB,WAAA,UAjBuC;EAmBvC,UAAA,EAAY,OAAA,CAAQ,CAAA;EAnBqC;AAAA;AAc/D;;;;EAYM,gBAAA;EACA,MAAA,GAAS,KAAA,EAAO,oBAAA,CAAqB,CAAA,MAAO,SAAA;AAAA;EAG5C,WAAA;EACA,UAAA,EAAY,OAAA,CAAQ,CAAA,GAAR;EAEZ,gBAAA;EACA,MAAA,GAAS,KAAA,EAAO,iBAAA,CAAkB,CAAA,MAAO,SAAA;AAAA;;;;;;;;KAUnC,mBAAA,GAAsB,MAAM,SAAS,qBAAA;;;;;;;;;;;;;KAcrC,mBAAA;EACV,IAAA;EACA,KAAA,EAAO,iBAAiB;AAAA;AA1B8B;AAAA,KA8B5C,iBAAA;EACV,QAAA,GAAW,gBAAA;AAAA,IACT,MAAM;;AAtB4D;AActE;;KAcY,gBAAA,GACR,mBAAA,kDAMA,gBAAgB"}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@assistant-ui/react-generative-ui",
+  "version": "0.0.2",
+  "description": "Generative UI components for assistant-ui",
+  "keywords": [
+    "generative-ui",
+    "assistant-ui",
+    "react",
+    "ai",
+    "chat",
+    "rendering"
+  ],
+  "author": "AgentbaseAI Inc.",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./internal-json": {
+      "react-server": {
+        "types": "./dist/JSONGenerativeUI.server.d.ts",
+        "default": "./dist/JSONGenerativeUI.server.js"
+      },
+      "default": {
+        "types": "./dist/JSONGenerativeUI.client.d.ts",
+        "default": "./dist/JSONGenerativeUI.client.js"
+      }
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "assistant-stream": "^0.3.20"
+  },
+  "peerDependencies": {
+    "@assistant-ui/react": "^0.14.14",
+    "@types/react": "*",
+    "react": "^18 || ^19",
+    "zod": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15",
+    "@types/react": "^19.2.15",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "vitest": "^4.1.7",
+    "zod": "^4.4.3",
+    "@assistant-ui/x-buildutils": "0.0.11",
+    "@assistant-ui/react": "0.14.14"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "homepage": "https://www.assistant-ui.com/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/assistant-ui/assistant-ui.git",
+    "directory": "packages/react-generative-ui"
+  },
+  "bugs": {
+    "url": "https://github.com/assistant-ui/assistant-ui/issues"
+  },
+  "scripts": {
+    "build": "aui-build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/src/JSONGenerativeUI.client.tsx

@@ -0,0 +1,66 @@
+import type { ReactNode } from "react";
+import { buildPresentParameters } from "./buildPresentParameters";
+import {
+  presentToolBase,
+  promptUserToolBase,
+  type JSONGenerativeUIOptions,
+  type PresentParameters,
+  type PresentTool,
+  type PresentToolOptions,
+  type PromptUserTool,
+} from "./JSONGenerativeUI.shared";
+import { renderGenerativeUI } from "./renderGenerativeUI";
+import type { GenerativeUILibrary, GenerativeUIStatus } from "./types";
+
+/** Maps a tool-call part status to the generative-UI streaming status. Only a
+ * `complete` call has fully-arrived args; `running` and `incomplete`
+ * (aborted/errored, so args may be partial) both render as `"streaming"` so a
+ * non-streaming component is never handed partial props. */
+function uiStatus(status: { type: string }): GenerativeUIStatus {
+  return status.type === "complete" ? "done" : "streaming";
+}
+
+/**
+ * Client build of {@link JSONGenerativeUI}, resolved through the package's
+ * `default` export condition (browser and SSR).
+ *
+ * `present` is a frontend tool that renders the model's `{ $type, ...props }`
+ * tree against the library and resolves immediately. `prompt_user` is a
+ * human-in-the-loop tool: the model pauses and the rendered UI supplies the
+ * result. Both draw the tree the same way, so they share one `render`.
+ */
+export class JSONGenerativeUI {
+  private readonly library: GenerativeUILibrary;
+  private readonly parameters: PresentParameters;
+
+  constructor(options: JSONGenerativeUIOptions) {
+    this.library = options.library;
+    this.parameters = buildPresentParameters(options.library);
+  }
+
+  private readonly render = ({
+    args,
+    status,
+  }: {
+    args: unknown;
+    status: { type: string };
+  }): ReactNode =>
+    renderGenerativeUI(args, this.library, { status: uiStatus(status) });
+
+  present(options?: PresentToolOptions): PresentTool {
+    return {
+      ...presentToolBase(this.parameters, options),
+      unstable_backendDefault: { parameters: true },
+      execute: async () => ({}),
+      render: this.render,
+    };
+  }
+
+  promptUser(): PromptUserTool {
+    return {
+      ...promptUserToolBase(this.parameters),
+      unstable_backendDefault: { parameters: true },
+      render: this.render,
+    };
+  }
+}