@fieldwangai/agentflow 0.1.25

package/bin/pipeline/validate-for-ui.mjs

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+/**
+ * 产出 PC 用校验结果：edgeTypeMismatch、nodeRoleMissing、nodeModelMissing。
+ * 用法：agentflow apply -ai validate-for-ui <workspaceRoot> <flowName> <flowDir> [uuid]
+ * 或由 agentflow validate <FlowName> [uuid] 调用；传 uuid 时写入 runDir/intermediate/validation.json。
+ * 边 id 约定：source__sourceHandle__target__targetHandle。
+ */
+
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+
+import { getModelListsAbs, getRunDir, getUserAgentsJsonAbs } from "../lib/paths.mjs";
+
+/** 与前端 flowFormat.VALID_ROLES + 内置 id 一致：flow 中 role 可能为展示名或 id */
+const VALID_ROLE_KEYS = ["requirement", "planning", "code", "test", "normal"];
+const ROLE_ZH_TO_KEY = {
+  需求拆解: "requirement",
+  技术规划: "planning",
+  代码执行: "code",
+  测试回归: "test",
+  普通: "normal",
+};
+const VALID_ROLES = new Set([
+  ...VALID_ROLE_KEYS,
+  ...Object.keys(ROLE_ZH_TO_KEY),
+  "前端/UI",
+  "agentflow-node-executor-requirement",
+  "agentflow-node-executor-planning",
+  "agentflow-node-executor-code",
+  "agentflow-node-executor-test",
+  "agentflow-node-executor",
+  "agentflow-node-executor-ui",
+]);
+
+function getSlotsFromInstance(inst) {
+  const result = { inputNames: [], outputNames: [], inputTypes: [], outputTypes: [] };
+  if (!inst || typeof inst !== "object") return result;
+  const inp = Array.isArray(inst.input) ? inst.input : [];
+  const out = Array.isArray(inst.output) ? inst.output : [];
+  for (const slot of inp) {
+    const name = slot && (slot.name != null) ? String(slot.name).trim() : "";
+    const type = slot && (slot.type != null) ? String(slot.type).trim() : "";
+    if (name) {
+      result.inputNames.push(name);
+      result.inputTypes.push(type);
+    }
+  }
+  for (const slot of out) {
+    const name = slot && (slot.name != null) ? String(slot.name).trim() : "";
+    const type = slot && (slot.type != null) ? String(slot.type).trim() : "";
+    if (name) {
+      result.outputNames.push(name);
+      result.outputTypes.push(type);
+    }
+  }
+  return result;
+}
+
+function loadFlowYaml(flowDir) {
+  const filePath = path.join(flowDir, "flow.yaml");
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = yaml.load(raw);
+    if (!data || typeof data !== "object") return null;
+    const instances = data.instances && typeof data.instances === "object" ? data.instances : {};
+    const edgesRaw = Array.isArray(data.edges) ? data.edges : [];
+    const nodeIds = new Set(Object.keys(instances));
+    for (const e of edgesRaw) {
+      if (e?.source) nodeIds.add(e.source);
+      if (e?.target) nodeIds.add(e.target);
+    }
+    const nodes = Array.from(nodeIds).map((id) => {
+      const inst = instances[id] || {};
+      return { id, definitionId: inst.definitionId != null ? String(inst.definitionId) : id };
+    });
+    const edges = edgesRaw
+      .filter((e) => e?.source && e?.target)
+      .map((e) => ({
+        source: String(e.source),
+        target: String(e.target),
+        sourceHandle: e.sourceHandle ?? "output-0",
+        targetHandle: e.targetHandle ?? "input-0",
+      }));
+    return { nodes, edges, instances };
+  } catch {
+    return null;
+  }
+}
+
+function loadModelLists(_workspaceRoot) {
+  const p = getModelListsAbs();
+  if (!fs.existsSync(p)) return { cursor: [], opencode: [] };
+  try {
+    const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+    return {
+      cursor: Array.isArray(data.cursor) ? data.cursor : [],
+      opencode: Array.isArray(data.opencode) ? data.opencode : [],
+    };
+  } catch {
+    return { cursor: [], opencode: [] };
+  }
+}
+
+/** ~/agentflow/agents.json 仅存用户角色，无 source 字段，取所有条目的 id */
+function loadCustomRoleIds(_workspaceRoot) {
+  const agentsPath = getUserAgentsJsonAbs();
+  if (!fs.existsSync(agentsPath)) return new Set();
+  try {
+    const data = JSON.parse(fs.readFileSync(agentsPath, "utf-8"));
+    const list = Array.isArray(data) ? data : (data.agents || []);
+    return new Set(list.filter((a) => a && typeof a.id === "string" && a.id.trim()).map((a) => a.id.trim()));
+  } catch {
+    return new Set();
+  }
+}
+
+function toEdgeId(e) {
+  return `${e.source}__${e.sourceHandle || "output-0"}__${e.target}__${e.targetHandle || "input-0"}`;
+}
+
+function computeValidation(flowDir, workspaceRoot) {
+  const loaded = loadFlowYaml(flowDir);
+  const edgeTypeMismatch = [];
+  const nodeRoleMissing = [];
+  const nodeModelMissing = [];
+
+  if (!loaded || loaded.nodes.length === 0) {
+    return { validation: { edgeTypeMismatch, nodeRoleMissing, nodeModelMissing }, ok: false };
+  }
+
+  const { nodes, edges, instances } = loaded;
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const nodeIdToSlots = {};
+  for (const n of nodes) {
+    nodeIdToSlots[n.id] = getSlotsFromInstance(instances[n.id]);
+  }
+
+  for (const e of edges) {
+    if (!nodeIds.has(e.source) || !nodeIds.has(e.target)) continue;
+    const outMatch = (e.sourceHandle || "output-0").match(/^output-(\d+)$/);
+    const inMatch = (e.targetHandle || "input-0").match(/^input-(\d+)$/);
+    if (!outMatch || !inMatch) continue;
+    const outIdx = parseInt(outMatch[1], 10);
+    const inIdx = parseInt(inMatch[1], 10);
+    const srcSlots = nodeIdToSlots[e.source];
+    const tgtSlots = nodeIdToSlots[e.target];
+    const srcType = (srcSlots?.outputTypes?.[outIdx] ?? "").trim();
+    const tgtType = (tgtSlots?.inputTypes?.[inIdx] ?? "").trim();
+    if (srcType && tgtType && srcType !== tgtType) {
+      edgeTypeMismatch.push(toEdgeId(e));
+    }
+  }
+
+  const validRoles = new Set(VALID_ROLES);
+  if (workspaceRoot) {
+    for (const id of loadCustomRoleIds(workspaceRoot)) validRoles.add(id);
+  }
+  for (const n of nodes) {
+    const role = (instances[n.id] && instances[n.id].role != null) ? String(instances[n.id].role).trim() : "";
+    if (role && !validRoles.has(role)) nodeRoleMissing.push(n.id);
+  }
+
+  const root = workspaceRoot ? path.resolve(workspaceRoot) : flowDir;
+  const { cursor: cursorList, opencode: opencodeList } = loadModelLists(root);
+  const opencodeSet = new Set((opencodeList || []).map((s) => String(s).trim()));
+  const cursorSet = new Set(
+    (cursorList || []).map((s) => {
+      const t = String(s).trim();
+      const first = t.split(/\s+-/)[0].trim();
+      return first || t;
+    })
+  );
+  for (const n of nodes) {
+    const model = (instances[n.id] && instances[n.id].model != null) ? String(instances[n.id].model).trim() : "";
+    if (!model) continue;
+    let valid = false;
+    if (model.startsWith("opencode:")) {
+      valid = opencodeSet.has(model.slice(9).trim());
+    } else {
+      const cursorId = model.startsWith("cursor:") ? model.slice(7).trim() : model;
+      valid = cursorSet.has(cursorId) || (cursorList || []).some((c) => String(c).trim() === model || String(c).trim().startsWith(cursorId + " "));
+    }
+    if (!valid) nodeModelMissing.push(n.id);
+  }
+
+  const ok = edgeTypeMismatch.length === 0 && nodeRoleMissing.length === 0 && nodeModelMissing.length === 0;
+  return { validation: { edgeTypeMismatch, nodeRoleMissing, nodeModelMissing }, ok };
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length < 3) {
+    console.error(JSON.stringify({ ok: false, error: "Usage: validate-for-ui.mjs <workspaceRoot> <flowName> <flowDir> [uuid]" }));
+    process.exit(1);
+  }
+  const workspaceRoot = path.resolve(argv[0]);
+  const flowName = argv[1];
+  const flowDir = path.resolve(argv[2]);
+  const uuid = argv.length >= 4 && /^\d{14}$/.test(String(argv[3]).trim()) ? String(argv[3]).trim() : null;
+
+  if (!fs.existsSync(path.join(flowDir, "flow.yaml"))) {
+    console.error(JSON.stringify({ ok: false, error: "flow.yaml not found in " + flowDir }));
+    process.exit(1);
+  }
+
+  const { validation, ok } = computeValidation(flowDir, workspaceRoot);
+
+  if (uuid && flowName) {
+    const runDir = getRunDir(workspaceRoot, flowName, uuid);
+    const intermediateDir = path.join(runDir, "intermediate");
+    try {
+      fs.mkdirSync(intermediateDir, { recursive: true });
+      fs.writeFileSync(path.join(intermediateDir, "validation.json"), JSON.stringify({ validation }, null, 2), "utf-8");
+    } catch (err) {
+      console.error(JSON.stringify({ ok: false, error: err.message }));
+      process.exit(1);
+    }
+  }
+
+  console.log(JSON.stringify({ ok, validation }));
+  process.exit(ok ? 0 : 1);
+}
+
+main();

package/bin/pipeline/validate-script-output.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/**
+ * 解析 tool_nodejs 脚本 stdout 为结构化 payload。
+ *
+ * 两种模式：
+ * 1. JSON 模式：stdout 含 { "err_code": number, "message": { "result": "..." } }
+ *    → 直接使用，err_code 可覆盖 exit code 语义（向后兼容）。
+ * 2. 纯文本模式：stdout 不含合法 JSON
+ *    → 自动包装为 { err_code: -1, message: { result: <stdout> }, _synthetic: true }
+ *    → 调用方应以进程 exit code 决定成败。
+ *
+ * 用法：
+ *   node validate-script-output.mjs              # 从 stdin 读取
+ *   node validate-script-output.mjs <file>       # 从文件读取
+ *
+ * 输出（stdout JSON）：{ "ok": boolean, "errors": string[], "payload": object | null }
+ * 退出码：0 解析成功，1 失败
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+/**
+ * 从文本中提取第一个完整 JSON 对象并解析。
+ * 支持：单行 JSON、多行（pretty-print）JSON、stdout 前有日志的情况。
+ */
+function parsePayload(text) {
+  if (!text || typeof text !== "string") return null;
+  const raw = text.trimStart().replace(/^\uFEFF/, "");
+  const start = raw.indexOf("{");
+  if (start < 0) return null;
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  let end = -1;
+  for (let i = start; i < raw.length; i++) {
+    const c = raw[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (inString) {
+      if (c === "\\") escape = true;
+      else if (c === '"') inString = false;
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      continue;
+    }
+    if (c === "{") depth++;
+    else if (c === "}") {
+      depth--;
+      if (depth === 0) {
+        end = i + 1;
+        break;
+      }
+    }
+  }
+  const slice = end > 0 ? raw.slice(start, end) : raw.slice(start).split("\n")[0];
+  try {
+    return JSON.parse(slice);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 解析脚本 stdout 为结构化 payload。
+ *
+ * @param {string} stdoutText
+ * @returns {{ ok: boolean, errors: string[], payload: { err_code: number, message: object, _synthetic?: boolean } | null }}
+ *   - JSON 模式：payload 含脚本输出的 err_code + message
+ *   - 纯文本模式：payload._synthetic = true，err_code = -1（由调用方按 exit code 判断）
+ *   - stdout 为空：ok = false
+ */
+export function validateAndParse(stdoutText) {
+  const errors = [];
+  const jsonPayload = parsePayload(stdoutText);
+
+  if (jsonPayload) {
+    if (typeof jsonPayload.err_code !== "number") {
+      errors.push("JSON 缺少 err_code（数字）");
+    }
+    if (!jsonPayload.message || typeof jsonPayload.message !== "object" || Array.isArray(jsonPayload.message)) {
+      errors.push("JSON 缺少 message（对象）");
+    }
+    if (errors.length > 0) {
+      return { ok: false, errors, payload: null };
+    }
+    return { ok: true, errors: [], payload: jsonPayload };
+  }
+
+  if (stdoutText && stdoutText.trim()) {
+    return {
+      ok: true,
+      errors: [],
+      payload: { err_code: -1, message: { result: stdoutText.trim() }, _synthetic: true },
+    };
+  }
+
+  errors.push("stdout 为空");
+  return { ok: false, errors, payload: null };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  let input = "";
+  if (args.length > 0 && !args[0].startsWith("--")) {
+    try {
+      input = fs.readFileSync(args[0], "utf-8");
+    } catch (e) {
+      console.log(JSON.stringify({ ok: false, errors: [e.message], payload: null }));
+      process.exit(1);
+    }
+  } else {
+    input = fs.readFileSync(0, "utf-8");
+  }
+
+  const { ok, errors, payload } = validateAndParse(input);
+  console.log(JSON.stringify({ ok, errors, payload }));
+  process.exit(ok ? 0 : 1);
+}
+
+const _url = fileURLToPath(import.meta.url);
+const _dir = path.dirname(_url);
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(_dir, "validate-script-output.mjs");
+if (isMain) main();

package/bin/pipeline/write-result.mjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+/**
+ * 统一写入/更新 intermediate/<instanceId>.result.md，保证 frontmatter 格式一致。
+ * 供前处理（写入 running）、执行后规范化、后处理（覆写 status/branch 等）共同使用。
+ *
+ * 用法（CLI）：
+ *   node write-result.mjs <workspaceRoot> <flowName> <uuid> <instanceId> --json '<JSON>'
+ * JSON 字段：status（必）, message（必）, finishedAt?, outputPath?, branch?, elapsedMs?, body?（cacheMd5/cacheInputInfo 仅存 .cache.json，不写入 result）
+ * 若传入 body 则使用；否则若文件已存在且未传 body，则保留原正文（preserveBody）。
+ *
+ * 用法（模块）：
+ *   import { writeResult } from "./write-result.mjs";
+ *   writeResult(workspaceRoot, flowName, uuid, instanceId, fields, options?)
+ * fields: { status, message, finishedAt?, outputPath?, branch?, cacheNotMetReason?, elapsedMs? }
+ * options: { preserveBody?: boolean, body?: string, execId?: number }
+ */
+
+import fs from "fs";
+import path from "path";
+
+import { getRunDir } from "../lib/paths.mjs";
+import { loadExecId } from "./get-exec-id.mjs";
+import { intermediateResultBasename, intermediateDirForNode } from "./get-exec-id.mjs";
+import { logToRunTag } from "./run-log.mjs";
+
+/**
+ * 转义 YAML frontmatter 中的字符串值（可含冒号、换行时用双引号并转义）
+ */
+function escapeYamlValue(val) {
+  if (val == null) return '""';
+  const s = String(val);
+  if (/[\n"\\:]/.test(s)) {
+    return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n") + '"';
+  }
+  return '"' + s + '"';
+}
+
+/**
+ * 从已有 result 文件中截取正文（frontmatter 之后的部分）
+ */
+function getExistingBody(resultPath) {
+  if (!fs.existsSync(resultPath)) return "";
+  const raw = fs.readFileSync(resultPath, "utf-8");
+  const match = raw.match(/---\s*\r?\n[\s\S]*?\r?\n---\s*\r?\n([\s\S]*)$/);
+  return match ? match[1] : "";
+}
+
+/**
+ * 统一写入 result 文件。
+ * cacheMd5/cacheInputInfo 仅保存在 <instanceId>.cache.json，不写入 result。
+ * @param {string} workspaceRoot - 工作区根目录
+ * @param {string} flowName - 流程名
+ * @param {string} uuid - 本次 run 的 uuid
+ * @param {string} instanceId - 节点 instance id
+ * @param {{ status: string, message: string, finishedAt?: string, outputPath?: string, branch?: string, cacheNotMetReason?: string, elapsedMs?: number }} fields - 必填 status、message；可选其余（elapsedMs 为节点执行耗时毫秒，供 UI 展示）
+ * @param {{ preserveBody?: boolean, body?: string, execId?: number }} [options] - preserveBody：保留已有正文；body：指定正文内容；execId：本轮 execId，缺省则从 memory 读取
+ */
+export function writeResult(workspaceRoot, flowName, uuid, instanceId, fields, options = {}) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const execId = options.execId ?? loadExecId(workspaceRoot, flowName, uuid, instanceId);
+  const resultBasename = intermediateResultBasename(instanceId, execId);
+  const resultPath = path.join(runDir, intermediateDirForNode(instanceId), resultBasename);
+
+  /** 调度只认 success；Agent 可能传 completed/done，在此统一写成 success */
+  let status = fields.status ?? "success";
+  if (typeof status === "string" && (status.toLowerCase() === "completed" || status.toLowerCase() === "done")) {
+    status = "success";
+  }
+  const message = fields.message ?? "";
+  const finishedAt = fields.finishedAt ?? new Date().toISOString();
+  const outputPath = fields.outputPath;
+  const branch = fields.branch;
+  const cacheNotMetReason = fields.cacheNotMetReason;
+  const elapsedMs =
+    fields.elapsedMs != null && Number.isFinite(fields.elapsedMs) && fields.elapsedMs >= 0 ? Math.round(fields.elapsedMs) : undefined;
+
+  let body = options.body;
+  if (body === undefined && options.preserveBody !== false) {
+    body = getExistingBody(resultPath);
+  }
+  if (body === undefined) body = "";
+  // 备份由 snapshotPriorRoundIfNeeded 在 pre-process 入口统一处理，此处只覆盖写。
+
+  const lines = [
+    "---",
+    `status: ${escapeYamlValue(status)}`,
+    `execId: ${escapeYamlValue(execId)}`,
+  ];
+  if (branch !== undefined && branch !== null) {
+    lines.push(`branch: ${escapeYamlValue(branch)}`);
+  }
+  lines.push(
+    `message: ${escapeYamlValue(message)}`,
+    `finishedAt: ${escapeYamlValue(finishedAt)}`
+  );
+  if (outputPath !== undefined && outputPath !== null && outputPath !== "") {
+    lines.push(`outputPath: ${escapeYamlValue(outputPath)}`);
+  }
+  if (cacheNotMetReason !== undefined && cacheNotMetReason !== null && cacheNotMetReason !== "") {
+    lines.push(`cacheNotMetReason: ${escapeYamlValue(cacheNotMetReason)}`);
+  }
+  if (elapsedMs !== undefined) {
+    lines.push(`elapsedMs: ${elapsedMs}`);
+  }
+  lines.push("---");
+  const content = lines.join("\n") + "\n" + (body ? "\n" + body : "");
+
+  fs.mkdirSync(path.dirname(resultPath), { recursive: true });
+  fs.writeFileSync(resultPath, content, "utf-8");
+  logToRunTag(workspaceRoot, flowName, uuid, "result", {
+    instanceId,
+    status,
+    message: message || undefined,
+    branch: branch ?? undefined,
+    cacheNotMetReason: cacheNotMetReason ?? undefined,
+    resultPathRel: path.relative(runDir, resultPath),
+  });
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const jsonIdx = args.indexOf("--json");
+  if (args.length < 5 || jsonIdx === -1 || !args[jsonIdx + 1]) {
+    console.error(
+      JSON.stringify({
+        ok: false,
+        error:
+          "Usage: node write-result.mjs <workspaceRoot> <flowName> <uuid> <instanceId> --json '<JSON>'",
+      })
+    );
+    process.exit(1);
+  }
+
+  const [root, flowName, uuid, instanceId] = args.slice(0, jsonIdx);
+  const jsonStr = args[jsonIdx + 1];
+  const workspaceRoot = path.resolve(root);
+
+  let payload;
+  try {
+    payload = JSON.parse(jsonStr);
+  } catch (e) {
+    console.error(JSON.stringify({ ok: false, error: "Invalid JSON: " + e.message }));
+    process.exit(1);
+  }
+
+  if (!payload.status || !payload.message) {
+    console.error(
+      JSON.stringify({ ok: false, error: "JSON must include status and message" })
+    );
+    process.exit(1);
+  }
+
+  const fields = {
+    status: payload.status,
+    message: payload.message,
+    finishedAt: payload.finishedAt,
+    outputPath: payload.outputPath,
+    branch: payload.branch,
+    cacheNotMetReason: payload.cacheNotMetReason,
+    elapsedMs: payload.elapsedMs,
+  };
+  const options = {};
+  if (payload.body !== undefined) options.body = payload.body;
+  else options.preserveBody = true;
+  if (payload.execId !== undefined) options.execId = Number(payload.execId) || 1;
+
+  try {
+    writeResult(workspaceRoot, flowName, uuid, instanceId, fields, options);
+    console.log(JSON.stringify({ ok: true }));
+  } catch (err) {
+    console.error(JSON.stringify({ ok: false, error: err.message }));
+    process.exit(1);
+  }
+}
+
+const isMain =
+  typeof process !== "undefined" &&
+  process.argv[1] &&
+  (process.argv[1].endsWith("write-result.mjs") || process.argv[1].endsWith("write-result.js"));
+if (isMain) {
+  main();
+}

package/builtin/nodes/agent_subAgent.md

@@ -0,0 +1,14 @@
+---
+# 内置节点：SubAgent
+description: 利用SubAgent执行任务
+displayName: SubAgent
+input:
+  - type: node
+    name: prev
+    default: ""
+output:
+  - type: node
+    name: next
+    default: ""
+---
+${USER_PROMPT}

package/builtin/nodes/control_agent_toBool.md

@@ -0,0 +1,20 @@
+---
+# 内置节点：AI 转布尔（agent 执行）
+description: "AI-powered boolean judgment: an agent evaluates the input value and writes true/false to prediction. Use for non-deterministic scenarios requiring semantic understanding."
+displayName: Agent ToBool
+input:
+  - type: node
+    name: prev
+    default: ""
+  - type: text
+    name: value
+    default: ""
+output:
+  - type: node
+    name: next
+    default: ""
+  - type: bool
+    name: prediction
+    default: ""
+---
+${USER_PROMPT}

package/builtin/nodes/control_anyOne.md

@@ -0,0 +1,17 @@
+---
+# 内置节点：任一满足
+description: Continues to next when any upstream input is ready
+displayName: AnyOne
+input:
+  - type: node
+    name: prev1
+    default: ""
+  - type: node
+    name: prev2
+    default: ""
+output:
+  - type: node
+    name: next
+    default: ""
+---
+${USER_PROMPT}

package/builtin/nodes/control_end.md

@@ -0,0 +1,11 @@
+---
+# 内置节点：结束
+description: End point of AgentFlow, flow terminates after this node
+displayName: End
+input:
+  - type: node
+    name: prev
+    default: ""
+output: []
+---
+${USER_PROMPT}

package/builtin/nodes/control_if.md

@@ -0,0 +1,20 @@
+---
+# 内置节点：If 分支
+description: Has exactly one bool type input. Continues to next1 if true, next2 if false
+displayName: If
+input:
+  - type: node
+    name: prev
+    default: ""
+  - type: bool
+    name: prediction
+    default: ""
+output:
+  - type: node
+    name: next1
+    default: ""
+  - type: node
+    name: next2
+    default: ""
+---
+${USER_PROMPT}

package/builtin/nodes/control_start.md

@@ -0,0 +1,11 @@
+---
+# 内置节点：开始
+description: Entry point of AgentFlow, all flows should start from this node
+displayName: Start
+input: []
+output:
+  - type: node
+    name: next
+    default: ""
+---
+${USER_PROMPT}

package/builtin/nodes/control_toBool.md

@@ -0,0 +1,21 @@
+---
+# 内置节点：转布尔（本地脚本执行，★ 可扩展输入）
+description: "Script-based boolean conversion: executes script to produce true/false prediction. Like tool_nodejs but enforces bool output. Must have script field."
+displayName: ToBool
+input:
+  - type: node
+    name: prev
+    default: ""
+  - type: text
+    name: value
+    default: ""
+output:
+  - type: node
+    name: next
+    default: ""
+  - type: bool
+    name: prediction
+    default: ""
+extensible: true
+---
+${USER_PROMPT}

package/builtin/nodes/provide_file.md

@@ -0,0 +1,11 @@
+---
+# 内置节点：直接提供文件
+description: Provide file path or content directly, value will be passed to downstream as-is
+displayName: File
+input: []
+output:
+  - type: file
+    name: value
+    default: ""
+---
+${USER_PROMPT}

package/builtin/nodes/provide_str.md

@@ -0,0 +1,11 @@
+---
+# 内置节点：直接提供文本
+description: Provide a text value directly, value will be passed to downstream as-is
+displayName: String
+input: []
+output:
+  - type: text
+    name: value
+    default: ""
+---
+${USER_PROMPT}