@dudousxd/nestjs-agent-core 0.44.1 → 0.45.1

package/dist/genui/index.cjs

@@ -41,6 +41,7 @@ __export(genui_exports, {
   isStandardSchema: () => isStandardSchema,
   jsonStandardSchema: () => jsonStandardSchema,
   negotiateCatalog: () => negotiateCatalog,
+  partialTree: () => partialTree,
   prepareUiEmission: () => prepareUiEmission,
   showToolJsonSchema: () => showToolJsonSchema,
   snapshotComponentPresentation: () => snapshotComponentPresentation,
@@ -50,6 +51,7 @@ __export(genui_exports, {
   toSnakeCase: () => toSnakeCase,
   toolNameFor: () => toolNameFor,
   treeJsonSchema: () => treeJsonSchema,
+  treeNodeId: () => treeNodeId,
   treeToFlatSpec: () => treeToFlatSpec,
   treeToText: () => treeToText,
   validatePresentationBatch: () => validatePresentationBatch,
@@ -414,6 +416,7 @@ function defineComponent(definition) {
   }
   if (definition.version !== void 0 && (!Number.isSafeInteger(definition.version) || definition.version <= 0)) throw new RangeError("genui: component version must be a positive safe integer");
   if (definition.fallbackText !== void 0 && typeof definition.fallbackText !== "function") throw new TypeError("genui: fallbackText must be a function");
+  if (definition.streaming !== void 0 && definition.streaming !== "partial" && definition.streaming !== "complete") throw new TypeError("genui: streaming must be 'partial' or 'complete'");
   return definition;
 }
 __name(defineComponent, "defineComponent");
@@ -498,6 +501,97 @@ function toolNameFor(component, prefix = "ui__show_") {
 }
 __name(toolNameFor, "toolNameFor");
 
+// src/genui/progressive.ts
+function treeNodeId(parentId, index) {
+  return `${parentId}.${index}`;
+}
+__name(treeNodeId, "treeNodeId");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function partialTree(catalog, input, options = {}) {
+  const maxDepth = options.limits?.maxDepth ?? 12;
+  const maxNodes = options.limits?.maxNodes ?? 200;
+  const fallback = options.streaming ?? "complete";
+  let nodes = 0;
+  let broken = false;
+  const visit = /* @__PURE__ */ __name((value, id, depth) => {
+    if (broken) return void 0;
+    if (!isRecord(value)) {
+      if (value !== void 0) broken = true;
+      return void 0;
+    }
+    const open = input.isOpen(value);
+    const type = value.type;
+    if (typeof type !== "string" || open && input.pendingMember(value) === "type") {
+      if (!open) broken = true;
+      return void 0;
+    }
+    const definition = catalog.get(type);
+    nodes += 1;
+    if (definition === void 0 || definition.internal === true || nodes > maxNodes || depth > maxDepth) {
+      broken = true;
+      return void 0;
+    }
+    const mode = definition.streaming ?? fallback;
+    if (mode === "complete") {
+      const checked = open ? void 0 : validatePropsSync(definition.props, value.props ?? {}, catalog.validator);
+      if (checked === void 0 || !checked.ok) {
+        return {
+          id,
+          type,
+          props: {},
+          incomplete: true,
+          held: true
+        };
+      }
+      const children2 = childrenOf(value, id, depth, definition.children === true);
+      return {
+        id,
+        type,
+        props: checked.value,
+        ...children2 !== void 0 && children2.length > 0 ? {
+          children: children2
+        } : {}
+      };
+    }
+    const props = isRecord(value.props) ? value.props : {};
+    const children = childrenOf(value, id, depth, definition.children === true);
+    return {
+      id,
+      type,
+      props,
+      ...children !== void 0 && children.length > 0 ? {
+        children
+      } : {},
+      ...open ? {
+        incomplete: true
+      } : {}
+    };
+  }, "visit");
+  const childrenOf = /* @__PURE__ */ __name((value, id, depth, takesChildren) => {
+    const raw = value.children;
+    if (!Array.isArray(raw)) return void 0;
+    if (raw.length > 0 && !takesChildren) {
+      broken = true;
+      return void 0;
+    }
+    const children = [];
+    for (const [index, child] of raw.entries()) {
+      const next = visit(child, treeNodeId(id, index), depth + 1);
+      if (next !== void 0) children.push(next);
+    }
+    return children;
+  }, "childrenOf");
+  const root = visit(input.value, "root", 1);
+  if (broken) return null;
+  return {
+    root: root ?? null
+  };
+}
+__name(partialTree, "partialTree");
+
 // src/genui/tree.ts
 var GENUI_TREE_COMPONENT = "genui:tree";
 async function validateTree(catalog, tree, limits = {}, phase = "output") {
@@ -630,34 +724,120 @@ async function validateTree(catalog, tree, limits = {}, phase = "output") {
   };
 }
 __name(validateTree, "validateTree");
-function treeJsonSchema(catalog) {
+function treeJsonSchema(catalog, options = {}) {
+  const components = catalog.modelComponents();
+  const names = components.map((component) => component.name);
+  if (options.schema === "loose") {
+    return {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: names,
+          description: "Component name from the catalog"
+        },
+        props: {
+          type: "object",
+          description: "The component's props, as the catalog describes them"
+        },
+        children: {
+          type: "array",
+          items: {
+            $ref: "#"
+          },
+          description: "Nested elements, only for components that take children. A literal JSON array, never a JSON-stringified one."
+        }
+      },
+      required: [
+        "type",
+        "props"
+      ]
+    };
+  }
+  const defs = {};
+  const childrenSchema = {
+    type: "array",
+    items: {
+      $ref: "#/$defs/node"
+    },
+    description: "Nested elements. A literal JSON array, never a JSON-stringified one."
+  };
+  for (const component of components) {
+    defs[`props_${component.name}`] = embeddableProps(toJsonSchema(component.props));
+    defs[`node_${component.name}`] = {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          enum: [
+            component.name
+          ]
+        },
+        props: {
+          $ref: `#/$defs/props_${component.name}`
+        },
+        ...component.children === true ? {
+          children: childrenSchema
+        } : {}
+      },
+      required: [
+        "type",
+        "props"
+      ],
+      additionalProperties: false
+    };
+  }
+  defs.node = {
+    anyOf: components.map((component) => ({
+      $ref: `#/$defs/node_${component.name}`
+    }))
+  };
   return {
     type: "object",
     properties: {
       type: {
         type: "string",
-        enum: catalog.modelComponents().map((component) => component.name),
-        description: "Component name from the catalog"
+        enum: names,
+        description: "Component name from the catalog. A single component (no children) is a valid tree."
       },
       props: {
-        type: "object",
-        description: "The component's props, as the catalog describes them"
+        description: "The component's props: the schema of the component named by `type`",
+        anyOf: components.map((component) => ({
+          $ref: `#/$defs/props_${component.name}`
+        }))
       },
       children: {
-        type: "array",
-        items: {
-          $ref: "#"
-        },
+        ...childrenSchema,
         description: "Nested elements, only for components that take children. A literal JSON array, never a JSON-stringified one."
       }
     },
     required: [
       "type",
       "props"
-    ]
+    ],
+    additionalProperties: false,
+    $defs: defs
   };
 }
 __name(treeJsonSchema, "treeJsonSchema");
+function embeddableProps(schema) {
+  if (schema === void 0 || typeof schema !== "object" || schema === null) {
+    return {
+      type: "object"
+    };
+  }
+  const references = /* @__PURE__ */ __name((value) => {
+    if (Array.isArray(value)) return value.some(references);
+    if (typeof value !== "object" || value === null) return false;
+    return Object.entries(value).some(([key, nested]) => key === "$ref" || key === "$defs" || key === "definitions" || references(nested));
+  }, "references");
+  if (references(schema)) return {
+    type: "object"
+  };
+  const { $schema: _schema, ...rest } = schema;
+  return rest;
+}
+__name(embeddableProps, "embeddableProps");
 function treeToFlatSpec(root) {
   const elements = {};
   let next = 0;
@@ -928,9 +1108,9 @@ __name(prepareUiEmission, "prepareUiEmission");
 // src/genui/tools.ts
 var GENUI_SHOW_TOOL = "ui__show";
 function genuiTools(catalog, options = {}) {
-  const tools = options.mode === "tree" ? [
+  const tools = options.mode === "per-component" ? flatComponents(catalog).map((component) => componentTool(catalog, component, options)) : [
     treeTool(catalog, options)
-  ] : flatComponents(catalog).map((component) => componentTool(catalog, component, options));
+  ];
   if (options.showTool !== void 0 && options.showTool !== false) {
     tools.push(showTool(catalog, options));
   }
@@ -1041,6 +1221,9 @@ function treeTool(catalog, options) {
     })
   ].join("\n"), "describeFor");
   const dynamic = options.resolveCatalog !== void 0;
+  const treeSchemaOptions = options.treeSchema !== void 0 ? {
+    schema: options.treeSchema
+  } : {};
   const handler = {
     async execute(input, ctx) {
       const resolved = await catalogFor(catalog, options, scopeOf(ctx));
@@ -1049,6 +1232,10 @@ function treeTool(catalog, options) {
         throw new Error(`invalid UI tree: ${formatIssues(result.issues)}`);
       }
       const root = result.value;
+      const single = flatComponent(resolved, root.type);
+      if (root.children === void 0 && single !== void 0) {
+        return push(ctx, root.type, root.props, single.version);
+      }
       return push(ctx, GENUI_TREE_COMPONENT, {
         root
       });
@@ -1059,7 +1246,36 @@ function treeTool(catalog, options) {
     return {
       available: resolved.modelComponents().length > 0,
       description: describeFor(resolved),
-      inputSchema: permissiveSchema(treeJsonSchema(resolved))
+      inputSchema: permissiveSchema(treeJsonSchema(resolved, treeSchemaOptions))
+    };
+  };
+  handler.previewInput = async (scope) => {
+    const resolved = negotiateCatalog(await catalogFor(catalog, options, scopeOf(scope)), scope.uiCapabilities);
+    const streaming = options.streaming ?? "complete";
+    if (!resolved.modelComponents().some((each) => (each.streaming ?? streaming) === "partial")) {
+      return void 0;
+    }
+    return {
+      ...options.streamingThrottleMs !== void 0 ? {
+        throttleMs: options.streamingThrottleMs
+      } : {},
+      render(input) {
+        const tree = partialTree(resolved, input, {
+          streaming,
+          ...options.treeLimits !== void 0 ? {
+            limits: options.treeLimits
+          } : {}
+        });
+        if (tree === null) return null;
+        if (tree.root === null) return void 0;
+        return {
+          component: GENUI_TREE_COMPONENT,
+          props: {
+            root: tree.root
+          },
+          version: 1
+        };
+      }
     };
   };
   return {
@@ -1067,7 +1283,7 @@ function treeTool(catalog, options) {
       name,
       kind: "read",
       description: describeFor(catalog),
-      inputSchema: dynamic ? permissiveSchema(treeJsonSchema(catalog)) : asyncJsonStandardSchema(treeJsonSchema(catalog), async (value) => {
+      inputSchema: dynamic ? permissiveSchema(treeJsonSchema(catalog, treeSchemaOptions)) : asyncJsonStandardSchema(treeJsonSchema(catalog, treeSchemaOptions), async (value) => {
         const result = await validateTree(catalog, value, options.treeLimits, "input");
         return result.ok ? {
           value: result.value
@@ -1916,6 +2132,7 @@ __name(canonicalJson, "canonicalJson");
   isStandardSchema,
   jsonStandardSchema,
   negotiateCatalog,
+  partialTree,
   prepareUiEmission,
   showToolJsonSchema,
   snapshotComponentPresentation,
@@ -1925,6 +2142,7 @@ __name(canonicalJson, "canonicalJson");
   toSnakeCase,
   toolNameFor,
   treeJsonSchema,
+  treeNodeId,
   treeToFlatSpec,
   treeToText,
   validatePresentationBatch,