@fieldwangai/agentflow 0.1.157 → 0.1.160

package/bin/lib/flow-dsl/lint.mjs

@@ -18,6 +18,7 @@ import fs from "fs";
 import path from "path";
 import { parse as acornParse } from "acorn";
 
+import { slotTypeCompatibility } from "../../../shared/slot-types.js";
 import { CTRL_SLOTS, RUN_DEFINITIONS, DEFINITIONS, definitionOf } from "./defs.mjs";
 import { packageResolverFor, scanAvailableNodePackages } from "./packages.mjs";
 import { FLOW_SOURCE_FILENAME } from "./index.mjs";
@@ -43,7 +44,21 @@ const BANNED_SYNTAX = {
 };
 
 /** 这两类节点的槽位由实例自己定义，不受定义表约束。 */
-const CUSTOM_SLOTS_ALLOWED = new Set(["agent_subAgent", "tool_nodejs"]);
+const CUSTOM_SLOTS_ALLOWED = new Set(["agent_subAgent", "tool_nodejs", "control_subflow_call"]);
+
+function declaredSlot(node, kind, name) {
+  const slots = node?.packageDef?.[kind]
+    || definitionOf(node?.definitionId)?.[kind === "input" ? "input" : "output"]
+    || [];
+  return slots.find((slot) => String(slot?.name || "") === String(name || "")) || null;
+}
+
+function declaredSlotType(node, kind, name) {
+  const slot = declaredSlot(node, kind, name);
+  if (slot?.type) return String(slot.type);
+  if (kind === "input" && node?.inputTypes?.[name]) return String(node.inputTypes[name]);
+  return "";
+}
 
 function walk(node, visit) {
   if (!node || typeof node !== "object") return;
@@ -131,6 +146,28 @@ export function lintFlowDir(flowDir, opts = {}) {
   }
 
   const N = ir.nodes;
+  const subflows = ir?.subflows && typeof ir.subflows === "object" ? ir.subflows : {};
+
+  const ownerOf = new Map();
+  for (const [subflowId, subflow] of Object.entries(subflows)) {
+    if (!(subflow.roots || []).length) errors.push(`${subflowId}: 子流程没有执行入口`);
+    for (const nodeId of subflow.nodeIds || []) {
+      if (!N[nodeId]) errors.push(`${subflowId}: 成员 ${nodeId} 不存在`);
+      if (ownerOf.has(nodeId) && ownerOf.get(nodeId) !== subflowId) {
+        errors.push(`${nodeId}: 不能同时属于子流程 ${ownerOf.get(nodeId)} 和 ${subflowId}`);
+      } else ownerOf.set(nodeId, subflowId);
+    }
+    for (const [name, binding] of Object.entries(subflow.inputs || {})) {
+      if (N[binding.nodeId]?.definitionId !== "workspace_subflow_input") {
+        errors.push(`${subflowId}.${name}: 输入代理 ${binding.nodeId} 不是 flow.input`);
+      }
+    }
+    for (const [name, binding] of Object.entries(subflow.outputs || {})) {
+      if (!ownerOf.has(binding.nodeId) && !(subflow.nodeIds || []).includes(binding.nodeId)) {
+        errors.push(`${subflowId}.${name}: 输出来源 ${binding.nodeId} 不在子流程内`);
+      }
+    }
+  }
 
   for (const [id, node] of Object.entries(N)) {
     const definitionId = node.definitionId;
@@ -139,6 +176,53 @@ export function lintFlowDir(flowDir, opts = {}) {
       errors.push(`${id}: 未知节点类型 ${definitionId}`);
       continue;
     }
+    if (definitionId === "control_subflow_call" && !subflows[node.attrs?.subflowId]) {
+      errors.push(`${id}: 引用的子流程 ${node.attrs?.subflowId || "(empty)"} 不存在`);
+    }
+    if (definitionId === "control_while") {
+      const conditionId = String(node.attrs?.conditionSubflowId || "");
+      const bodyId = String(node.attrs?.bodySubflowId || "");
+      const hasSubflowRefs = Boolean(conditionId || bodyId);
+      if (hasSubflowRefs && node.script) {
+        errors.push(`${id}: control.while 不能同时声明 step 脚本和 Condition/Body 子流程`);
+      } else if (hasSubflowRefs) {
+        if (!conditionId || !bodyId) {
+          errors.push(`${id}: control.while 必须同时声明 Condition 和 Body 子流程`);
+        } else if (conditionId === bodyId) {
+          errors.push(`${id}: control.while 的 Condition 和 Body 必须是不同子流程`);
+        }
+        const condition = subflows[conditionId];
+        const body = subflows[bodyId];
+        if (!condition) errors.push(`${id}: Condition 子流程 ${conditionId || "(empty)"} 不存在`);
+        if (!body) errors.push(`${id}: Body 子流程 ${bodyId || "(empty)"} 不存在`);
+        for (const name of ["state", "iteration"]) {
+          if (condition && !condition.inputs?.[name]) errors.push(`${id}: Condition 子流程 ${conditionId} 缺少输入 ${name}`);
+        }
+        if (condition && !condition.outputs?.decision) {
+          errors.push(`${id}: Condition 子流程 ${conditionId} 缺少输出 decision`);
+        }
+        for (const name of ["state", "iteration", "idempotencyKey"]) {
+          if (body && !body.inputs?.[name]) errors.push(`${id}: Body 子流程 ${bodyId} 缺少输入 ${name}`);
+        }
+        if (body && !body.outputs?.state) errors.push(`${id}: Body 子流程 ${bodyId} 缺少输出 state`);
+        for (const [contract, name, expected] of [
+          [condition?.inputs, "state", "json"],
+          [condition?.inputs, "iteration", "text"],
+          [condition?.outputs, "decision", "text"],
+          [body?.inputs, "state", "json"],
+          [body?.inputs, "iteration", "text"],
+          [body?.inputs, "idempotencyKey", "text"],
+          [body?.outputs, "state", "json"],
+        ]) {
+          const actual = String(contract?.[name]?.type || "");
+          if (actual && actual !== expected) {
+            errors.push(`${id}: While 契约 ${name} 必须是 ${expected}，当前是 ${actual}`);
+          }
+        }
+      } else if (!node.script) {
+        errors.push(`${id}: control.while 需要 step 脚本，或 Condition/Body 两个子流程`);
+      }
+    }
     // 运行时支持程度来自各节点 .md 的 runtime: 字段，不是这里的第二份清单
     if (def.runtime === "degraded") {
       warnings.push(`${id}: ${definitionId} 无专用 handler，靠通用 agent + 输出契约工作；结果必须恰好是 true/false`);
@@ -171,6 +255,11 @@ export function lintFlowDir(flowDir, opts = {}) {
       errors.push(`边引用了未声明的节点 ${dst}`);
       continue;
     }
+    const srcOwner = ownerOf.get(src) || "";
+    const dstOwner = ownerOf.get(dst) || "";
+    if (srcOwner !== dstOwner) {
+      errors.push(`子流程边界禁止直接连线: ${src}.${fromSlot} (${srcOwner || "父流程"}) -> ${dst}.${toSlot} (${dstOwner || "父流程"})；请通过 flow.call 契约传值`);
+    }
     const def = lookupDef(N[src].definitionId);
     if (def && !CTRL_SLOTS.has(fromSlot)
       && !def.output.some((s) => s.name === fromSlot)
@@ -186,6 +275,18 @@ export function lintFlowDir(flowDir, opts = {}) {
     if (CTRL_SLOTS.has(fromSlot) && def && !def.output.some((s) => s.name === fromSlot)) {
       errors.push(`${src}[${N[src].definitionId}] 没有 ${fromSlot} 槽，控制流串不下去`);
     }
+    const sourceType = declaredSlotType(N[src], "output", fromSlot);
+    // 自定义输入槽没有独立声明时会跟随上游类型，因此只对有明确目标类型的边做校验。
+    const targetType = declaredSlotType(N[dst], "input", toSlot);
+    if (sourceType && targetType) {
+      const compatibility = slotTypeCompatibility(sourceType, targetType);
+      if (!compatibility.compatible) {
+        errors.push(
+          `类型不兼容: ${src}.${fromSlot}(${compatibility.source}) -> `
+          + `${dst}.${toSlot}(${compatibility.target})；请改用同类型引脚或显式转换节点`,
+        );
+      }
+    }
     const target = `${dst}|${toSlot}`;
     if (inputSeen.has(target)) {
       errors.push(`fan-in 禁止: ${dst}.${toSlot} 被 ${inputSeen.get(target)} 和 ${src} 同时连入`);
@@ -211,6 +312,32 @@ export function lintFlowDir(flowDir, opts = {}) {
   };
   for (const id of Object.keys(N)) if (!color.has(id)) visit(id);
 
+  // 图本身仍是 DAG，但子流程调用关系也不能递归，否则会形成运行时调用环。
+  const callGraph = new Map(Object.keys(subflows).map((id) => [id, []]));
+  for (const [nodeId, node] of Object.entries(N)) {
+    const owner = ownerOf.get(nodeId);
+    if (!owner) continue;
+    if (node.definitionId === "control_subflow_call") {
+      const target = String(node.attrs?.subflowId || "");
+      if (target) callGraph.get(owner)?.push(target);
+    }
+    if (node.definitionId === "control_while") {
+      for (const target of [node.attrs?.conditionSubflowId, node.attrs?.bodySubflowId]) {
+        if (target) callGraph.get(owner)?.push(String(target));
+      }
+    }
+  }
+  const callColor = new Map();
+  const visitCall = (id) => {
+    callColor.set(id, 1);
+    for (const next of callGraph.get(id) || []) {
+      if (callColor.get(next) === 1) errors.push(`子流程递归调用禁止: ${id} -> ${next}`);
+      else if (!callColor.has(next)) visitCall(next);
+    }
+    callColor.set(id, 2);
+  };
+  for (const id of callGraph.keys()) if (!callColor.has(id)) visitCall(id);
+
   for (const [id, node] of Object.entries(N)) {
     if (node.definitionId !== "control_if") continue;
     const edge = ir.edges.find((e) => e.endsWith(`|${id}|prediction`));
@@ -218,8 +345,6 @@ export function lintFlowDir(flowDir, opts = {}) {
       errors.push(`${id}: control.if 的 prediction 未接线`);
     } else {
       const [src, slot] = edge.split("|");
-      const type = lookupDef(N[src]?.definitionId)?.output.find((s) => s.name === slot)?.type;
-      if (type && type !== "bool") errors.push(`${id}: prediction 只能接 bool，${src}.${slot} 是 ${type}`);
     }
     for (const [slot, label] of [["next1", "then"], ["next2", "else"]]) {
       if (!ir.edges.some((e) => e.startsWith(`${id}|${slot}|`))) warnings.push(`${id}: control.if 缺 ${label} 分支`);

package/bin/lib/flow-dsl/parser.mjs

@@ -122,6 +122,8 @@ export function parseFlowSource(source, opts = {}) {
   const pendingIf = [];
   const runDecls = [];
   const destructures = [];
+  const subflows = {};
+  const subflowOf = new Map();
 
   // 先扫一遍解构声明：`const { storyId } = node;` 让后面引用 storyId 时能还原成边
   for (const stmt of ast.body) {
@@ -151,7 +153,7 @@ export function parseFlowSource(source, opts = {}) {
     if (tpl?.type !== "TemplateLiteral" || !tpl.expressions.length) return null;
     // 本节点自己就有这个名字 -> `${x}` 是运行时占位符，原样留在正文里，不是 JS 插值
     const def = definitionOf(definitionId);
-    const isScript = definitionId === "tool_nodejs";
+    const isScript = definitionId === "tool_nodejs" || definitionId === "control_while";
     const ownSlot = (name) => def.input.some((s) => s.name === name)
       || nodes[id].extraIn.includes(name)
       || nodes[id].inputs[name] !== undefined
@@ -258,6 +260,35 @@ export function parseFlowSource(source, opts = {}) {
     return out;
   };
 
+  const flatItemIds = (items, out = []) => {
+    for (const item of items || []) {
+      if (typeof item === "string") out.push(item);
+      else if (item?.fork) for (const branch of item.fork) flatItemIds(branch, out);
+    }
+    return out;
+  };
+
+  const rootItemIds = (items) => {
+    const first = items?.[0];
+    if (typeof first === "string") return [first];
+    if (!first?.fork) return [];
+    return first.fork.map((branch) => flatItemIds(branch)[0]).filter(Boolean);
+  };
+
+  const objectEntries = (node, context) => {
+    if (!node || node.type !== "ObjectExpression") {
+      unresolvedAt(node, `${context} 必须是对象字面量`);
+      return [];
+    }
+    return node.properties.map((prop) => {
+      if (prop.type !== "Property" || prop.computed || prop.kind !== "init") {
+        unresolvedAt(prop, `${context} 只能包含静态字段`);
+        return null;
+      }
+      return [String(prop.key.name ?? prop.key.value ?? ""), prop.value];
+    }).filter(Boolean);
+  };
+
   function linkChain(head, items) {
     let prev = head;
     let slot = "next";
@@ -300,11 +331,98 @@ export function parseFlowSource(source, opts = {}) {
       const path = apiCalleePath(init.callee);
       const args = [...init.arguments];
 
+      if (path === "flow.input") {
+        const name = stringOf(args[0]);
+        const type = stringOf(args[1]) || "text";
+        if (!name) unresolvedAt(init, `${id}: flow.input 的第一个参数必须是输入名`);
+        nodes[id] = {
+          definitionId: "workspace_subflow_input",
+          inputs: {},
+          inputTypes: {},
+          outputs: {},
+          extraIn: [],
+          extraOut: [],
+          declaredOut: [],
+          attrs: { subflowInputName: name || id, subflowInputType: type },
+          packageDef: { input: [], output: [{ name: "value", type }] },
+          label: name || id,
+        };
+        continue;
+      }
+
       const first = args[0];
       const hasLabel = first
         && ((first.type === "Literal" && typeof first.value === "string") || first.type === "TemplateLiteral");
       const label = hasLabel ? stringOf(args.shift()) : null;
 
+      if (path === "flow.subflow") {
+        const inputObject = args.shift();
+        const sequence = args.shift();
+        const outputObject = args.shift();
+        const items = sequence?.type === "CallExpression" && apiCalleePath(sequence.callee) === "flow"
+          ? itemsOf(sequence)
+          : [];
+        // The visual editor persists an empty flow() while its START/RETURN
+        // contract is still being wired. Keep that draft round-trippable;
+        // lint already reports a missing execution root and runtime refuses it.
+        const inputs = {};
+        for (const [name, value] of objectEntries(inputObject, `${id} inputs`)) {
+          if (value.type !== "Identifier" || nodes[value.name]?.definitionId !== "workspace_subflow_input") {
+            unresolvedAt(value, `${id}.${name}: 子流程输入必须引用 flow.input 变量`);
+            continue;
+          }
+          const proxy = nodes[value.name];
+          inputs[name] = {
+            nodeId: value.name,
+            slot: "value",
+            type: String(proxy.attrs?.subflowInputType || "text"),
+          };
+        }
+        const outputs = {};
+        for (const [name, value] of objectEntries(outputObject, `${id} outputs`)) {
+          const member = memberPath(value);
+          const ref = member || (value.type === "Identifier" ? varOf.get(value.name) : null);
+          if (!ref) {
+            unresolvedAt(value, `${id}.${name}: 子流程输出必须引用内部节点输出`);
+            continue;
+          }
+          const sourceNode = nodes[ref[0]];
+          const declaredSlot = sourceNode?.packageDef?.output?.find((slot) => slot.name === ref[1])
+            || definitionOf(sourceNode?.definitionId).output.find((slot) => slot.name === ref[1]);
+          outputs[name] = { nodeId: ref[0], slot: ref[1], type: String(declaredSlot?.type || "text") };
+        }
+        const roots = rootItemIds(items);
+        subflows[id] = { id, label: label || id, inputs, outputs, roots, nodeIds: [] };
+        subflowOf.set(id, subflows[id]);
+        linkChain(null, items);
+        continue;
+      }
+
+      if (path === "flow.call") {
+        const ref = args.shift();
+        const subflow = ref?.type === "Identifier" ? subflowOf.get(ref.name) : null;
+        if (!subflow) unresolvedAt(ref, `${id}: flow.call 第二个参数必须引用前面声明的 flow.subflow`);
+        const inputSlots = Object.entries(subflow?.inputs || {}).map(([name, binding]) => ({ name, type: binding.type || "text" }));
+        const outputSlots = Object.entries(subflow?.outputs || {}).map(([name, binding]) => ({ name, type: binding.type || "text" }));
+        nodes[id] = {
+          definitionId: "control_subflow_call",
+          inputs: {},
+          inputTypes: {},
+          outputs: {},
+          extraIn: inputSlots.map((slot) => slot.name),
+          extraOut: outputSlots.map((slot) => slot.name),
+          declaredOut: outputSlots.map((slot) => slot.name),
+          attrs: { subflowId: ref?.name || "" },
+          packageDef: {
+            input: [{ name: "prev", type: "node" }, ...inputSlots],
+            output: [{ name: "next", type: "node" }, ...outputSlots],
+          },
+        };
+        if (label) nodes[id].label = label;
+        readPins(id, "control_subflow_call", args[0]);
+        continue;
+      }
+
       if (path === "flow" || path === "flow.schedule") {
         const body = path === "flow.schedule" ? stringOf(args.shift()) : null;
         runDecls.push({
@@ -364,7 +482,22 @@ export function parseFlowSource(source, opts = {}) {
       }
       readPins(id, definitionId, args[0]);
 
-      if (definitionId === "control_if") {
+      if (definitionId === "control_while" && args[1]?.type === "Identifier") {
+        const conditionRef = args[1];
+        const bodyRef = args[2];
+        const conditionSubflow = subflowOf.get(conditionRef.name);
+        const bodySubflow = bodyRef?.type === "Identifier" ? subflowOf.get(bodyRef.name) : null;
+        if (!conditionSubflow) {
+          unresolvedAt(conditionRef, `${id}: control.while 第三个参数必须引用前面声明的 Condition 子流程`);
+        }
+        if (!bodySubflow) {
+          unresolvedAt(bodyRef || args[1], `${id}: control.while 第四个参数必须引用前面声明的 Body 子流程`);
+        }
+        nodes[id].attrs.conditionSubflowId = conditionRef.name || "";
+        nodes[id].attrs.bodySubflowId = bodyRef?.type === "Identifier" ? bodyRef.name : "";
+      } else if (definitionId === "control_while" && args[2]) {
+        unresolvedAt(args[2], `${id}: control.while 只能使用一个 step 脚本，或依次传入 Condition/Body 两个子流程`);
+      } else if (definitionId === "control_if") {
         if (args[1]) pendingIf.push({ id, slot: "next1", call: args[1] });
         if (args[2]) pendingIf.push({ id, slot: "next2", call: args[2] });
       } else if (args[1]) {
@@ -396,7 +529,7 @@ export function parseFlowSource(source, opts = {}) {
           }
         }
         if (body !== null) {
-          if (definitionId === "tool_nodejs") nodes[id].script = body;
+          if (definitionId === "tool_nodejs" || definitionId === "control_while") nodes[id].script = body;
           else nodes[id].body = body;
         }
       }
@@ -460,5 +593,36 @@ export function parseFlowSource(source, opts = {}) {
     node.extraOut = [...new Set(node.extraOut)];
   }
 
-  return { nodes, edges: [...new Set(edges)].sort(), unresolved };
+  // 子流程成员 = 显式控制链 + 输出来源 + 它们的数据依赖。边仍保存在统一 IR 中，
+  // 但成员清单让运行时能为每次 flow.call 建立隔离的调用帧。
+  const upstream = new Map();
+  for (const edge of edges) {
+    const [src, fromSlot, dst, toSlot] = edge.split("|");
+    if (toSlot === "prev") continue;
+    if (!upstream.has(dst)) upstream.set(dst, []);
+    upstream.get(dst).push(src);
+  }
+  for (const subflow of Object.values(subflows)) {
+    const members = new Set([
+      ...Object.values(subflow.inputs).map((binding) => binding.nodeId),
+      ...Object.values(subflow.outputs).map((binding) => binding.nodeId),
+    ]);
+    const queue = [...subflow.roots, ...members];
+    const visited = new Set();
+    while (queue.length) {
+      const current = queue.shift();
+      if (!current || visited.has(current)) continue;
+      visited.add(current);
+      members.add(current);
+      for (const dep of upstream.get(current) || []) queue.push(dep);
+      for (const edge of edges) {
+        const [src, fromSlot, dst, toSlot] = edge.split("|");
+        if (src === current && toSlot === "prev") queue.push(dst);
+      }
+    }
+    subflow.nodeIds = [...members].filter((nodeId) => nodes[nodeId]).sort();
+    for (const nodeId of subflow.nodeIds) nodes[nodeId].attrs.subflowId = subflow.id;
+  }
+
+  return { nodes, edges: [...new Set(edges)].sort(), subflows, unresolved };
 }

package/bin/lib/locales/en.json

@@ -351,6 +351,10 @@
       "displayName": "Markdown Display",
       "description": "Render Markdown content on the Workspace canvas and pass the text downstream"
     },
+    "display_code": {
+      "displayName": "Code Display",
+      "description": "Render highlighted source code with line numbers, copy, wrap, and download controls, then pass the code downstream"
+    },
     "display_mermaid": {
       "displayName": "Mermaid Display",
       "description": "Render Mermaid diagram source on the Workspace canvas and pass the source downstream"

package/bin/lib/locales/zh.json

@@ -351,6 +351,10 @@
       "displayName": "Markdown 展示",
       "description": "在 Workspace 画布中渲染 Markdown 内容，并将文本继续传给下游"
     },
+    "display_code": {
+      "displayName": "代码展示",
+      "description": "在 Workspace 画布中高亮展示代码，支持行号、复制、换行和下载，并将代码继续传给下游"
+    },
     "display_mermaid": {
       "displayName": "Mermaid 展示",
       "description": "在 Workspace 画布中渲染 Mermaid 图，并将源码继续传给下游"

package/bin/lib/marketplace.mjs

@@ -11,6 +11,7 @@ import {
   isFlowDir,
 } from "./paths.mjs";
 import { NODE_PACKAGE_ENTRY, isNodePackageDir, readNodePackageManifest } from "./node-package-manifest.mjs";
+import { normalizeNodeUiForSlots } from "./node-ui-kit.mjs";
 import {
   NODE_PACKAGE_METADATA_FILENAME,
   createNodePackageArchive,
@@ -118,6 +119,9 @@ function normalizeManifest(raw, packageDir, source = "workspace") {
         : runtime.type != null && String(runtime.type).trim() !== ""
           ? String(runtime.type).trim()
           : "";
+  const input = normalizeSlotList(raw.input || raw.inputs);
+  const output = normalizeSlotList(raw.output || raw.outputs);
+  const ui = normalizeNodeUiForSlots(raw.ui, input, output);
   return {
     ...raw,
     id,
@@ -127,9 +131,10 @@ function normalizeManifest(raw, packageDir, source = "workspace") {
     baseDefinitionId,
     displayName: raw.displayName != null ? String(raw.displayName) : raw.name != null ? String(raw.name) : id,
     description: raw.description != null ? String(raw.description) : "",
-    input: normalizeSlotList(raw.input || raw.inputs),
-    output: normalizeSlotList(raw.output || raw.outputs),
+    input,
+    output,
     runtime,
+    ...(ui ? { ui } : {}),
     source,
   };
 }
@@ -474,6 +479,7 @@ export function listMarketplacePackages(workspaceRoot, opts = {}) {
     description: n.description,
     inputs: n.input,
     outputs: n.output,
+    ui: n.ui,
     packagedFiles: Array.isArray(n.packagedFiles) ? n.packagedFiles : [],
     fileList: Array.isArray(n.fileList) ? n.fileList : [],
     fileCount: Number(n.fileCount) || 0,
@@ -943,6 +949,7 @@ export function publishNodeFromInstance(workspaceRoot, payload = {}, options = {
   const implementationMode = String(payload.implementationMode || "").trim();
   const body = String(payload.body || "").trim();
   const description = String(payload.description || body || `Published from node ${label}`).trim();
+  const ui = normalizeNodeUiForSlots(payload.ui, inputs, outputs);
   const dest = path.join(workspacePackageRoot(workspaceRoot), "nodes", id, version);
   const existingManifest = readYamlObject(path.join(dest, NODE_MANIFEST));
   if (existingManifest) {
@@ -984,6 +991,7 @@ export function publishNodeFromInstance(workspaceRoot, payload = {}, options = {
     runtime,
     inputs,
     outputs,
+    ...(ui ? { ui } : {}),
     ownerUserId,
     createdBy: ownerUserId,
     createdAt: existingManifest?.createdAt || now,

package/bin/lib/mcp-server.mjs

@@ -70,6 +70,7 @@ function query(params = {}) {
 function displayKind(definitionId) {
   const id = String(definitionId || "");
   if (id === "display_markdown") return "markdown";
+  if (id === "display_code") return "code";
   if (id === "display_mermaid") return "mermaid";
   if (id === "display_ascii") return "ascii";
   if (id === "display_html") return "html";

package/bin/lib/node-package-manifest.mjs

@@ -24,6 +24,7 @@
 import fs from "fs";
 import path from "path";
 import { parse as acornParse } from "acorn";
+import { normalizeNodeUiForSlots } from "./node-ui-kit.mjs";
 
 export const NODE_PACKAGE_ENTRY = "index.mjs";
 
@@ -135,15 +136,19 @@ export function nodePackageDeclarationToManifest(decl, packageDir) {
   const id = decl.id != null ? String(decl.id).trim() : path.basename(packageDir);
   const version = decl.version != null ? String(decl.version).trim() : "";
   if (!id || !version) return null;
+  const input = slotMapToList(decl.inputs, "input");
+  const output = slotMapToList(decl.outputs, "output");
+  const ui = normalizeNodeUiForSlots(decl.ui, input, output);
   return {
     id,
     version,
     displayName: decl.name != null ? String(decl.name) : id,
     description: decl.description != null ? String(decl.description) : "",
-    input: slotMapToList(decl.inputs, "input"),
-    output: slotMapToList(decl.outputs, "output"),
+    input,
+    output,
     baseDefinitionId: "tool_nodejs",
     runtime: { type: "tool_nodejs", entry: NODE_PACKAGE_ENTRY, mode: "module" },
+    ...(ui ? { ui } : {}),
     ...(decl.ownerUserId != null ? { ownerUserId: String(decl.ownerUserId) } : {}),
     ...(decl.createdBy != null ? { createdBy: String(decl.createdBy) } : {}),
   };

package/bin/lib/node-ui-kit.mjs

@@ -0,0 +1,156 @@
+/**
+ * Node UI Kit v1.
+ *
+ * 节点包来自 Marketplace，UI 声明必须和节点声明一样是纯数据。这里把可接受的卡片组件收敛成
+ * 白名单，避免节点包把任意 HTML / React / 事件处理器带进 Workspace。
+ */
+
+const CARD_TEMPLATES = new Set(["details", "state-machine"]);
+const TONES = new Set(["neutral", "blue", "purple", "green", "amber", "red"]);
+const SECTION_TYPES = new Set(["binding", "code", "decision", "metrics", "summary", "history", "subflow", "loop"]);
+const CODE_FIELDS = new Set(["script", "scriptRef", "body", "implementationRef"]);
+
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+
+function shortText(value, max = 160) {
+  return String(value ?? "").trim().slice(0, max);
+}
+
+function token(value, max = 80) {
+  const text = shortText(value, max);
+  return /^[A-Za-z_][A-Za-z0-9_.:-]*$/.test(text) ? text : "";
+}
+
+function tone(value, fallback = "neutral") {
+  const valueText = shortText(value, 20).toLowerCase();
+  return TONES.has(valueText) ? valueText : fallback;
+}
+
+function normalizeDecisionOptions(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, 8).map((raw) => {
+    const item = object(raw);
+    const optionValue = token(item?.value, 40);
+    if (!item || !optionValue) return null;
+    return {
+      value: optionValue,
+      label: shortText(item.label || optionValue, 60),
+      tone: tone(item.tone),
+      ...(item.description != null ? { description: shortText(item.description, 180) } : {}),
+    };
+  }).filter(Boolean);
+}
+
+function normalizeMetricItems(value) {
+  if (!Array.isArray(value)) return [];
+  return value.slice(0, 6).map((raw) => {
+    const item = object(raw);
+    if (!item) return null;
+    const input = token(item.input);
+    const output = token(item.output);
+    if (!input && !output) return null;
+    const maxInput = token(item.maxInput);
+    return {
+      label: shortText(item.label || output || input, 60),
+      ...(input ? { input } : {}),
+      ...(output ? { output } : {}),
+      ...(maxInput ? { maxInput } : {}),
+      ...(item.suffix != null ? { suffix: shortText(item.suffix, 24) } : {}),
+    };
+  }).filter(Boolean);
+}
+
+function normalizeSection(raw) {
+  const item = object(raw);
+  const type = shortText(item?.type, 30).toLowerCase();
+  if (!item || !SECTION_TYPES.has(type)) return null;
+  const label = shortText(item.label || type, 60);
+  if (type === "subflow") return { type, label };
+  if (type === "loop") {
+    const field = shortText(item.field || "script", 40);
+    return CODE_FIELDS.has(field) ? { type, label, field } : null;
+  }
+  if (type === "binding") {
+    const input = token(item.input);
+    return input ? { type, label, input } : null;
+  }
+  if (type === "code") {
+    const field = shortText(item.field, 40);
+    return CODE_FIELDS.has(field) ? { type, label, field } : null;
+  }
+  if (type === "decision") {
+    const output = token(item.output);
+    if (!output) return null;
+    return {
+      type,
+      label,
+      output,
+      ...(item.source != null ? { source: shortText(item.source, 120) } : {}),
+      options: normalizeDecisionOptions(item.options),
+    };
+  }
+  if (type === "metrics") {
+    const items = normalizeMetricItems(item.items);
+    return items.length ? { type, label, items } : null;
+  }
+  if (type === "summary" || type === "history") {
+    const output = token(item.output);
+    if (!output) return null;
+    return {
+      type,
+      label,
+      output,
+      ...(type === "history" ? { limit: Math.min(8, Math.max(1, Number(item.limit) || 3)) } : {}),
+    };
+  }
+  return null;
+}
+
+export function normalizeNodeUi(value) {
+  const root = object(value);
+  const rawCard = object(root?.card);
+  if (!root || !rawCard) return undefined;
+  const templateText = shortText(rawCard.template, 40).toLowerCase();
+  const template = CARD_TEMPLATES.has(templateText) ? templateText : "details";
+  const icon = token(rawCard.icon, 48);
+  const sections = (Array.isArray(rawCard.sections) ? rawCard.sections : [])
+    .slice(0, 12)
+    .map(normalizeSection)
+    .filter(Boolean);
+  if (!icon && sections.length === 0) return undefined;
+  return {
+    version: 1,
+    card: {
+      template,
+      tone: tone(rawCard.tone),
+      ...(icon ? { icon } : {}),
+      sections,
+    },
+  };
+}
+
+export function normalizeNodeUiForSlots(value, inputs = [], outputs = []) {
+  const ui = normalizeNodeUi(value);
+  if (!ui) return undefined;
+  const inputNames = new Set((Array.isArray(inputs) ? inputs : []).map((slot) => String(slot?.name || "")));
+  const outputNames = new Set((Array.isArray(outputs) ? outputs : []).map((slot) => String(slot?.name || "")));
+  const sections = ui.card.sections.map((section) => {
+    if (section.type === "binding") return inputNames.has(section.input) ? section : null;
+    if (section.type === "decision" || section.type === "summary" || section.type === "history") {
+      return outputNames.has(section.output) ? section : null;
+    }
+    if (section.type === "metrics") {
+      const items = section.items.filter((item) => (
+        (!item.input || inputNames.has(item.input))
+        && (!item.output || outputNames.has(item.output))
+        && (!item.maxInput || inputNames.has(item.maxInput))
+      ));
+      return items.length ? { ...section, items } : null;
+    }
+    return section;
+  }).filter(Boolean);
+  if (!ui.card.icon && sections.length === 0) return undefined;
+  return { ...ui, card: { ...ui.card, sections } };
+}