@dudousxd/nestjs-agent-react 0.18.0 → 0.20.0

package/dist/genui-json-render.d.cts

@@ -1,6 +1,9 @@
 import * as React from 'react';
 import { ComponentRegistry } from '@json-render/react';
-import { c as GenerativeUIElement, i as GenuiRenderer, h as GenuiRegistry } from './types-DFD-soWU.cjs';
+import { n as GenuiProviderProps$1, c as GenerativeUIElement, q as GenuiRenderer, p as GenuiRegistry } from './generative-ui-C53b3FoA.cjs';
+import './model-gHqjNjLJ.cjs';
+import '@dudousxd/nestjs-agent-core';
+import 'ai';
 
 /** A json-render flat spec: `{ root, elements: { [id]: { type, props, children } } }`. */
 interface JsonRenderFlatSpec {
@@ -30,5 +33,15 @@ declare function JsonRenderTree({ root, registry, initialState }: JsonRenderTree
 declare function jsonRenderTree(registry: ComponentRegistry): GenuiRenderer<{
     root?: GenerativeUIElement;
 }>;
+interface GenuiProviderProps extends GenuiProviderProps$1 {
+    /**
+     * Draw composed tree frames through json-render: pass your json-render registry, or `true` to
+     * derive one from `registry` ({@link toJsonRenderRegistry}). Omitted → trees render natively.
+     * An explicit `treeRenderer` wins over it.
+     */
+    jsonRender?: ComponentRegistry | true;
+}
+/** `GenuiProvider` from `/genui`, plus the {@link GenuiProviderProps.jsonRender} option. */
+declare function GenuiProvider({ jsonRender, treeRenderer, registry, ...rest }: GenuiProviderProps): React.JSX.Element;
 
-export { type JsonRenderFlatSpec, JsonRenderTree, type JsonRenderTreeProps, jsonRenderTree, toJsonRenderRegistry, treeToJsonRenderSpec };
+export { GenuiProvider, type GenuiProviderProps, type JsonRenderFlatSpec, JsonRenderTree, type JsonRenderTreeProps, jsonRenderTree, toJsonRenderRegistry, treeToJsonRenderSpec };

package/dist/genui-json-render.d.ts

@@ -1,6 +1,9 @@
 import * as React from 'react';
 import { ComponentRegistry } from '@json-render/react';
-import { c as GenerativeUIElement, i as GenuiRenderer, h as GenuiRegistry } from './types-DFD-soWU.js';
+import { n as GenuiProviderProps$1, c as GenerativeUIElement, q as GenuiRenderer, p as GenuiRegistry } from './generative-ui-BhXFni8j.js';
+import './model-gHqjNjLJ.js';
+import '@dudousxd/nestjs-agent-core';
+import 'ai';
 
 /** A json-render flat spec: `{ root, elements: { [id]: { type, props, children } } }`. */
 interface JsonRenderFlatSpec {
@@ -30,5 +33,15 @@ declare function JsonRenderTree({ root, registry, initialState }: JsonRenderTree
 declare function jsonRenderTree(registry: ComponentRegistry): GenuiRenderer<{
     root?: GenerativeUIElement;
 }>;
+interface GenuiProviderProps extends GenuiProviderProps$1 {
+    /**
+     * Draw composed tree frames through json-render: pass your json-render registry, or `true` to
+     * derive one from `registry` ({@link toJsonRenderRegistry}). Omitted → trees render natively.
+     * An explicit `treeRenderer` wins over it.
+     */
+    jsonRender?: ComponentRegistry | true;
+}
+/** `GenuiProvider` from `/genui`, plus the {@link GenuiProviderProps.jsonRender} option. */
+declare function GenuiProvider({ jsonRender, treeRenderer, registry, ...rest }: GenuiProviderProps): React.JSX.Element;
 
-export { type JsonRenderFlatSpec, JsonRenderTree, type JsonRenderTreeProps, jsonRenderTree, toJsonRenderRegistry, treeToJsonRenderSpec };
+export { GenuiProvider, type GenuiProviderProps, type JsonRenderFlatSpec, JsonRenderTree, type JsonRenderTreeProps, jsonRenderTree, toJsonRenderRegistry, treeToJsonRenderSpec };

package/dist/genui-json-render.js

@@ -3,7 +3,502 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/genui/json-render.tsx
 import { JSONUIProvider, Renderer } from "@json-render/react";
-import { useMemo } from "react";
+import { useMemo as useMemo3 } from "react";
+
+// src/genui/generative-ui.tsx
+import { Component, createContext as createContext2, useCallback, useContext as useContext2, useMemo as useMemo2 } from "react";
+
+// src/components/ambient-ui.ts
+import { createContext, useContext } from "react";
+function sharedContext(key) {
+  const symbol = Symbol.for(key);
+  const holder = globalThis;
+  const existing = holder[symbol];
+  if (existing !== void 0) return existing;
+  const created = createContext(null);
+  holder[symbol] = created;
+  return created;
+}
+__name(sharedContext, "sharedContext");
+var AmbientRenderUiContext = sharedContext("@dudousxd/nestjs-agent-react:ambient-render-ui");
+
+// src/genui/use-generative-ui.ts
+import { useEffect, useMemo, useState } from "react";
+
+// src/genui/types.ts
+var GENUI_TREE_COMPONENT = "genui:tree";
+
+// src/genui/use-generative-ui.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function toGenerativeUIItem(part) {
+  if (!isRecord(part)) return null;
+  const source = part.type === "data-ui" && isRecord(part.data) ? part.data : part;
+  if (typeof source.component !== "string") return null;
+  const id = typeof source.id === "string" ? source.id : typeof part.id === "string" ? part.id : null;
+  if (id === null) return null;
+  return {
+    id,
+    component: source.component,
+    props: isRecord(source.props) ? source.props : {},
+    version: typeof source.version === "number" ? source.version : null,
+    toolCallId: typeof source.toolCallId === "string" ? source.toolCallId : null
+  };
+}
+__name(toGenerativeUIItem, "toGenerativeUIItem");
+var resolverCaches = /* @__PURE__ */ new WeakMap();
+function resolveCached(resolve, name, version) {
+  let cache = resolverCaches.get(resolve);
+  if (cache === void 0) {
+    cache = /* @__PURE__ */ new Map();
+    resolverCaches.set(resolve, cache);
+  }
+  const key = `${name}@${version ?? ""}`;
+  const hit = cache.get(key);
+  if (hit !== void 0) return hit;
+  let entry;
+  try {
+    const result = resolve(name, version);
+    if (result instanceof Promise) {
+      entry = {
+        resolution: {
+          status: "loading"
+        },
+        settled: null
+      };
+      entry.settled = result.then((Component2) => {
+        entry.resolution = Component2 ? {
+          status: "ready",
+          Component: Component2
+        } : {
+          status: "unknown"
+        };
+      }, (error) => {
+        entry.resolution = {
+          status: "error",
+          error
+        };
+      });
+    } else {
+      entry = {
+        resolution: result ? {
+          status: "ready",
+          Component: result
+        } : {
+          status: "unknown"
+        },
+        settled: null
+      };
+    }
+  } catch (error) {
+    entry = {
+      resolution: {
+        status: "error",
+        error
+      },
+      settled: null
+    };
+  }
+  cache.set(key, entry);
+  return entry;
+}
+__name(resolveCached, "resolveCached");
+function useResolvedComponent(name, version, registry, resolve, fallbackTree) {
+  const [, setTick] = useState(0);
+  const own = registry[name];
+  const entry = own !== void 0 || resolve === void 0 ? null : resolveCached(resolve, name, version);
+  const pending = entry?.resolution.status === "loading" ? entry.settled : null;
+  useEffect(() => {
+    if (pending === null) return;
+    let live = true;
+    void pending.then(() => {
+      if (live) setTick((tick) => tick + 1);
+    });
+    return () => {
+      live = false;
+    };
+  }, [
+    pending
+  ]);
+  if (own !== void 0) return {
+    status: "ready",
+    Component: own
+  };
+  if (entry !== null && entry.resolution.status !== "unknown") return entry.resolution;
+  if (name === GENUI_TREE_COMPONENT && fallbackTree !== void 0) {
+    return {
+      status: "ready",
+      Component: fallbackTree
+    };
+  }
+  return {
+    status: "unknown"
+  };
+}
+__name(useResolvedComponent, "useResolvedComponent");
+function useValidatedProps(catalog, name, props) {
+  const checked = catalog?.has(name) === true;
+  const immediate = useMemo(() => {
+    if (!checked || catalog === void 0) return {
+      status: "ok",
+      props
+    };
+    const result = catalog.validateSync?.(name, props);
+    if (result === void 0) return null;
+    return result.ok ? {
+      status: "ok",
+      props: result.value
+    } : {
+      status: "invalid",
+      issues: result.issues
+    };
+  }, [
+    checked,
+    catalog,
+    name,
+    props
+  ]);
+  const [late, setLate] = useState(null);
+  useEffect(() => {
+    if (immediate !== null || catalog === void 0) return;
+    let live = true;
+    catalog.validate(name, props).then((result) => {
+      if (!live) return;
+      setLate({
+        props,
+        result: result.ok ? {
+          status: "ok",
+          props: result.value
+        } : {
+          status: "invalid",
+          issues: result.issues
+        }
+      });
+    }, (error) => {
+      if (!live) return;
+      setLate({
+        props,
+        result: {
+          status: "invalid",
+          issues: [
+            {
+              path: [],
+              message: error instanceof Error ? error.message : String(error)
+            }
+          ]
+        }
+      });
+    });
+    return () => {
+      live = false;
+    };
+  }, [
+    immediate,
+    catalog,
+    name,
+    props
+  ]);
+  if (immediate !== null) return immediate;
+  return late !== null && late.props === props ? late.result : {
+    status: "pending"
+  };
+}
+__name(useValidatedProps, "useValidatedProps");
+function useGenerativeUIState(part, options, fallbackTree) {
+  const item = useMemo(() => toGenerativeUIItem(part), [
+    part
+  ]);
+  const name = item?.component ?? "";
+  const resolution = useResolvedComponent(name, item?.version ?? null, options.registry, item === null ? void 0 : options.resolveComponent, fallbackTree);
+  const empty = useMemo(() => ({}), []);
+  const validation = useValidatedProps(item === null || name === GENUI_TREE_COMPONENT ? void 0 : options.catalog, name, item?.props ?? empty);
+  if (item === null) return null;
+  if (resolution.status === "loading") return {
+    status: "loading",
+    item
+  };
+  if (resolution.status === "unknown") return {
+    status: "problem",
+    reason: "unknown",
+    item
+  };
+  if (resolution.status === "error") {
+    return {
+      status: "problem",
+      reason: "error",
+      item,
+      error: resolution.error
+    };
+  }
+  if (validation.status === "pending") return {
+    status: "loading",
+    item
+  };
+  if (validation.status === "invalid") {
+    return {
+      status: "problem",
+      reason: "invalid",
+      item,
+      issues: validation.issues
+    };
+  }
+  return {
+    status: "ready",
+    item,
+    Component: resolution.Component,
+    props: validation.props
+  };
+}
+__name(useGenerativeUIState, "useGenerativeUIState");
+
+// src/genui/generative-ui.tsx
+var TreeScopeContext = /* @__PURE__ */ createContext2(null);
+function renderFallback(fallback, problem) {
+  if (typeof fallback === "function") return fallback(problem);
+  return fallback ?? null;
+}
+__name(renderFallback, "renderFallback");
+var ItemBoundary = class ItemBoundary2 extends Component {
+  static {
+    __name(this, "ItemBoundary");
+  }
+  state = {
+    error: void 0,
+    failed: false
+  };
+  static getDerivedStateFromError(error) {
+    return {
+      error,
+      failed: true
+    };
+  }
+  componentDidCatch(error, _info) {
+    this.props.onError?.(error, this.props.item);
+  }
+  componentDidUpdate(previous) {
+    if (this.state.failed && previous.item !== this.props.item) {
+      this.setState({
+        error: void 0,
+        failed: false
+      });
+    }
+  }
+  render() {
+    if (this.state.failed) {
+      return renderFallback(this.props.fallback, {
+        reason: "error",
+        item: this.props.item,
+        error: this.state.error
+      });
+    }
+    return this.props.children;
+  }
+};
+function nodeItem(node, id) {
+  return {
+    id,
+    component: node.type,
+    props: node.props ?? {},
+    version: null,
+    toolCallId: null
+  };
+}
+__name(nodeItem, "nodeItem");
+function TreeNode({ node, id }) {
+  const scope = useContext2(TreeScopeContext);
+  const item = useMemo2(() => nodeItem(node, id), [
+    node,
+    id
+  ]);
+  const resolution = useResolvedComponent(node.type, null, scope?.options.registry ?? {}, scope?.options.resolveComponent);
+  const validation = useValidatedProps(scope?.options.catalog, node.type, item.props);
+  if (scope === null) return null;
+  if (resolution.status === "loading" || validation.status === "pending") return scope.loading;
+  if (resolution.status === "unknown") {
+    return renderFallback(scope.fallback, {
+      reason: "unknown",
+      item
+    });
+  }
+  if (resolution.status === "error") {
+    return renderFallback(scope.fallback, {
+      reason: "error",
+      item,
+      error: resolution.error
+    });
+  }
+  if (validation.status === "invalid") {
+    return renderFallback(scope.fallback, {
+      reason: "invalid",
+      item,
+      issues: validation.issues
+    });
+  }
+  const Renderer2 = resolution.Component;
+  const children = Array.isArray(node.children) ? node.children : [];
+  return /* @__PURE__ */ React.createElement(Renderer2, validation.props, children.length > 0 ? children.map((child, index) => {
+    const childId = `${id}.${index}`;
+    return /* @__PURE__ */ React.createElement(ItemBoundary, {
+      key: childId,
+      item: nodeItem(child, childId),
+      fallback: scope.fallback,
+      onError: scope.onError
+    }, /* @__PURE__ */ React.createElement(TreeNode, {
+      node: child,
+      id: childId
+    }));
+  }) : void 0);
+}
+__name(TreeNode, "TreeNode");
+function GenuiTree({ root }) {
+  if (root === void 0 || root === null || typeof root.type !== "string") return null;
+  return /* @__PURE__ */ React.createElement(TreeNode, {
+    node: root,
+    id: "root"
+  });
+}
+__name(GenuiTree, "GenuiTree");
+function GenerativeUIScope({ registry, catalog, resolveComponent, fallback, loading = null, onError, children }) {
+  const scope = useMemo2(() => ({
+    options: {
+      registry,
+      ...catalog !== void 0 ? {
+        catalog
+      } : {},
+      ...resolveComponent !== void 0 ? {
+        resolveComponent
+      } : {}
+    },
+    fallback,
+    loading,
+    onError
+  }), [
+    registry,
+    catalog,
+    resolveComponent,
+    fallback,
+    loading,
+    onError
+  ]);
+  return /* @__PURE__ */ React.createElement(TreeScopeContext.Provider, {
+    value: scope
+  }, children);
+}
+__name(GenerativeUIScope, "GenerativeUIScope");
+var GenuiContext = sharedContext("@dudousxd/nestjs-agent-react:genui-provider");
+function GenuiProvider({ registry, catalog, resolveComponent, treeRenderer, fallback, loading, onError, children }) {
+  const value = useMemo2(() => ({
+    ...registry !== void 0 ? {
+      registry
+    } : {},
+    ...catalog !== void 0 ? {
+      catalog
+    } : {},
+    ...resolveComponent !== void 0 ? {
+      resolveComponent
+    } : {},
+    ...treeRenderer !== void 0 ? {
+      treeRenderer
+    } : {},
+    ...fallback !== void 0 ? {
+      fallback
+    } : {},
+    ...loading !== void 0 ? {
+      loading
+    } : {},
+    ...onError !== void 0 ? {
+      onError
+    } : {}
+  }), [
+    registry,
+    catalog,
+    resolveComponent,
+    treeRenderer,
+    fallback,
+    loading,
+    onError
+  ]);
+  const renderUi = useCallback((block) => /* @__PURE__ */ React.createElement(GenerativeUI, {
+    part: block
+  }), []);
+  return /* @__PURE__ */ React.createElement(GenuiContext.Provider, {
+    value
+  }, /* @__PURE__ */ React.createElement(AmbientRenderUiContext.Provider, {
+    value: renderUi
+  }, children));
+}
+__name(GenuiProvider, "GenuiProvider");
+var NO_REGISTRY = {};
+function useMergedOptions(own) {
+  const provided = useContext2(GenuiContext);
+  const registry = own.registry ?? provided?.registry ?? NO_REGISTRY;
+  const catalog = own.catalog ?? provided?.catalog;
+  const resolveComponent = own.resolveComponent ?? provided?.resolveComponent;
+  const treeRenderer = own.treeRenderer ?? provided?.treeRenderer;
+  return useMemo2(() => ({
+    registry,
+    ...catalog !== void 0 ? {
+      catalog
+    } : {},
+    ...resolveComponent !== void 0 ? {
+      resolveComponent
+    } : {},
+    ...treeRenderer !== void 0 ? {
+      treeRenderer
+    } : {}
+  }), [
+    registry,
+    catalog,
+    resolveComponent,
+    treeRenderer
+  ]);
+}
+__name(useMergedOptions, "useMergedOptions");
+function GenerativeUI({ part, registry, catalog, resolveComponent, treeRenderer, fallback: ownFallback, loading: ownLoading, onError: ownOnError }) {
+  const provided = useContext2(GenuiContext);
+  const fallback = ownFallback ?? provided?.fallback;
+  const loading = ownLoading ?? provided?.loading ?? null;
+  const onError = ownOnError ?? provided?.onError;
+  const options = useMergedOptions({
+    ...registry !== void 0 ? {
+      registry
+    } : {},
+    ...catalog !== void 0 ? {
+      catalog
+    } : {},
+    ...resolveComponent !== void 0 ? {
+      resolveComponent
+    } : {},
+    ...treeRenderer !== void 0 ? {
+      treeRenderer
+    } : {}
+  });
+  const state = useGenerativeUIState(part, options, options.treeRenderer ?? GenuiTree);
+  if (state === null) return null;
+  if (state.status === "loading") return loading;
+  if (state.status === "problem") {
+    const { status: _status, ...problem } = state;
+    return renderFallback(fallback, problem);
+  }
+  const Renderer2 = state.Component;
+  return /* @__PURE__ */ React.createElement(GenerativeUIScope, {
+    ...options,
+    fallback,
+    loading,
+    ...onError !== void 0 ? {
+      onError
+    } : {}
+  }, /* @__PURE__ */ React.createElement(ItemBoundary, {
+    item: state.item,
+    fallback,
+    onError
+  }, /* @__PURE__ */ React.createElement(Renderer2, state.props)));
+}
+__name(GenerativeUI, "GenerativeUI");
+
+// src/genui/json-render.tsx
 function treeToJsonRenderSpec(root) {
   const elements = {};
   let next = 0;
@@ -32,7 +527,7 @@ function toJsonRenderRegistry(registry) {
 }
 __name(toJsonRenderRegistry, "toJsonRenderRegistry");
 function JsonRenderTree({ root, registry, initialState }) {
-  const spec = useMemo(() => root === void 0 ? null : treeToJsonRenderSpec(root), [
+  const spec = useMemo3(() => root === void 0 ? null : treeToJsonRenderSpec(root), [
     root
   ]);
   if (spec === null) return null;
@@ -58,7 +553,28 @@ function jsonRenderTree(registry) {
   }, "JsonRenderTreeFrame");
 }
 __name(jsonRenderTree, "jsonRenderTree");
+function GenuiProvider2({ jsonRender, treeRenderer, registry, ...rest }) {
+  const derived = useMemo3(() => {
+    if (jsonRender === void 0) return void 0;
+    return jsonRenderTree(jsonRender === true ? toJsonRenderRegistry(registry ?? {}) : jsonRender);
+  }, [
+    jsonRender,
+    registry
+  ]);
+  const tree = treeRenderer ?? derived;
+  return /* @__PURE__ */ React.createElement(GenuiProvider, {
+    ...rest,
+    ...registry !== void 0 ? {
+      registry
+    } : {},
+    ...tree !== void 0 ? {
+      treeRenderer: tree
+    } : {}
+  });
+}
+__name(GenuiProvider2, "GenuiProvider");
 export {
+  GenuiProvider2 as GenuiProvider,
   JsonRenderTree,
   jsonRenderTree,
   toJsonRenderRegistry,