minimal-agent 0.8.2 → 0.10.0

package/plugins/workflow-runner/src/expressions.js

@@ -22,7 +22,8 @@
  *    interp  := '${' EXPR '}'                     // 取 EXPR 的"值"（任意类型，不字符串化）
  *    string  := "…" | '…'                         // 内嵌 ${EXPR} 走 template-literal 插值
  *
- *  白名单函数：fileExists / length / lower / upper
+ *  白名单函数：fileExists / readJson / parseJson / asArray / length / lower / upper / includes /
+ *              startsWith / endsWith / match / split / extract / join / json
  *
  *  ★ P2 根治：表达式上下文（when/condition/over/assert/vote.input）直接 evalExpr，
  *    不再"先 interpolate 再 eval"（旧双求值的 footgun 源头）。四种写法都 OK：
@@ -36,11 +37,11 @@
  *  把 EXPR 求值后 toString 替换；对象/数组用 JSON.stringify。interpolateDeep 递归处理对象/数组/字符串。
  * ============================================================
  */
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { join, isAbsolute } from 'node:path';
 import { getWorkingDir } from '../../../src/plugin-sdk.js';
 const PUNCT2 = new Set(['==', '!=', '>=', '<=', '&&', '||']);
-const PUNCT1 = new Set(['(', ')', '[', ']', ',', '.', '!', '>', '<', '+']);
+const PUNCT1 = new Set(['(', ')', '[', ']', ',', '.', '!', '>', '<', '+', '?', ':']);
 function tokenize(src) {
     const out = [];
     let i = 0;
@@ -158,12 +159,140 @@ const BUILTINS = {
             return Object.keys(v).length;
         return 0;
     },
+    // 把可选 JSON 数组标准化为 for-each loop 可消费的数组。用于
+    // over: "${asArray(readJson('manifest.json', 'images'))}" 这类场景：
+    // 缺文件/缺字段/null 表示 0 轮；但对象/字符串等结构错误要响亮失败，
+    // 避免把坏 manifest 静默吞掉。
+    asArray(args) {
+        const v = args[0];
+        if (Array.isArray(v))
+            return v;
+        if (v === null || v === undefined)
+            return [];
+        throw new Error(`asArray 期望数组/null/undefined，得到 ${Array.isArray(v) ? 'array' : typeof v}`);
+    },
     lower(args) {
         return String(args[0] ?? '').toLowerCase();
     },
     upper(args) {
         return String(args[0] ?? '').toUpperCase();
     },
+    includes(args) {
+        const haystack = String(args[0] ?? '');
+        const needle = String(args[1] ?? '');
+        return haystack.includes(needle);
+    },
+    startsWith(args) {
+        const s = String(args[0] ?? '');
+        const prefix = String(args[1] ?? '');
+        return s.startsWith(prefix);
+    },
+    endsWith(args) {
+        const s = String(args[0] ?? '');
+        const suffix = String(args[1] ?? '');
+        return s.endsWith(suffix);
+    },
+    match(args) {
+        const s = String(args[0] ?? '');
+        const pattern = String(args[1] ?? '');
+        try {
+            const re = new RegExp(pattern);
+            return re.test(s);
+        }
+        catch {
+            return false; // 非法正则 → 不匹配
+        }
+    },
+    split(args) {
+        const s = String(args[0] ?? '');
+        const delim = args[1] !== undefined ? String(args[1]) : ',';
+        return s.split(delim);
+    },
+    // 全局正则提取：返回匹配数组。有捕获组取 group 1（典型：提取 <tag>(.*?)</tag> 内容），
+    // 否则取全匹配。flags 固定 gs（跨行 . 匹配）；非法正则返回 []（与 match 同哲学：不抛）。
+    // 动机：从 agent/llm 输出里确定性抽取协议标签（如 <learning>…</learning>），
+    // 替代「再开一个 LLM 步去提取」的幻觉/改写风险。
+    extract(args) {
+        const s = String(args[0] ?? '');
+        const pattern = String(args[1] ?? '');
+        if (!pattern)
+            return [];
+        try {
+            const re = new RegExp(pattern, 'gs');
+            const out = [];
+            for (const m of s.matchAll(re)) {
+                out.push(m[1] !== undefined ? m[1] : m[0]);
+            }
+            return out;
+        }
+        catch {
+            return [];
+        }
+    },
+    // 数组拼接成字符串；非数组按 stringify 兜底。与 extract 配对使用。
+    join(args) {
+        const v = args[0];
+        const sep = args[1] !== undefined ? String(args[1]) : ',';
+        if (Array.isArray(v))
+            return v.map((x) => stringify(x)).join(sep);
+        return stringify(v);
+    },
+    // JSON.stringify 安全嵌入：值含引号/换行时拼 JSON 文件不产坏文档
+    // （模板里写 "k": ${json(v)}，外层引号由 json() 自己生成）。
+    json(args) {
+        try {
+            return JSON.stringify(args[0] ?? null);
+        }
+        catch {
+            return 'null';
+        }
+    },
+    // 读磁盘 JSON 文件并取值：path 相对 getWorkingDir()（绝对路径原样）；给了 key
+    // 则返回顶层 obj[key]，否则返回整值。缺文件 / 坏 JSON / 键不存在 → null
+    //（与 match/extract 同「不抛」哲学）。动机：让确定性脚本产出的 manifest
+    //（如 source_assets.json）直接驱动工作流 for-each / branch —— 填补「磁盘
+    // 结构化数据 → 控制流」的空白（与 fileExists 平级的基础能力）。
+    readJson(args) {
+        const p = String(args[0] ?? '');
+        if (!p)
+            return null;
+        const abs = isAbsolute(p) ? p : join(getWorkingDir(), p);
+        try {
+            // 剥前导 BOM：某些工具/重定向写出的 JSON 带 BOM，JSON.parse 会因此抛错。
+            let raw = readFileSync(abs, 'utf8');
+            if (raw.charCodeAt(0) === 0xfeff)
+                raw = raw.slice(1);
+            const val = JSON.parse(raw);
+            if (args.length >= 2) {
+                const key = String(args[1] ?? '');
+                return val != null && typeof val === 'object' ? (val[key] ?? null) : null;
+            }
+            return val;
+        }
+        catch {
+            return null;
+        }
+    },
+    // 解析 JSON 字符串成值（与 readJson 平级，但源是**字符串**而非文件）：剥前导 BOM、
+    // trim、JSON.parse；非字符串 / 空 / 坏 JSON → null（同 match/extract/readJson「不抛」哲学）。
+    // 动机：把 WebBrowser eval / agent / 工具 capture 到的 JSON 文本变成数组/对象，
+    // 直接驱动 loop over / branch —— 填补「字符串结构化数据 → 控制流」的空白
+    //（配 asArray 用：over: "${asArray(parseJson(urls_json))}"）。
+    parseJson(args) {
+        const v = args[0];
+        if (typeof v !== 'string')
+            return null;
+        let raw = v.charCodeAt(0) === 0xfeff ? v.slice(1) : v;
+        raw = raw.trim();
+        if (!raw)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    },
 };
 function parseOr(c, vars) {
     let left = parseAnd(c, vars);
@@ -174,6 +303,21 @@ function parseOr(c, vars) {
     }
     return left;
 }
+// 三元表达式：cond ? true_expr : false_expr
+// 优先级低于 ||（即先算完 || 再判断 ? :）
+// 右结合：a ? b ? c : d : e 等价于 a ? (b ? c : d) : e
+function parseTernary(c, vars) {
+    const cond = parseOr(c, vars);
+    if (!isPunct(c, '?'))
+        return cond;
+    eat(c); // 吃掉 '?'
+    const consequent = parseTernary(c, vars); // 右结合：true 分支可以是嵌套三元
+    if (!isPunct(c, ':'))
+        throw new Error("三元表达式缺少 ':'");
+    eat(c); // 吃掉 ':'
+    const alternate = parseTernary(c, vars); // 右结合：false 分支也可以是嵌套三元
+    return truthy(cond) ? consequent : alternate;
+}
 function parseAnd(c, vars) {
     let left = parseNot(c, vars);
     while (isPunct(c, '&&')) {
@@ -238,7 +382,8 @@ function parsePrimary(c, vars) {
         throw new Error('表达式意外结束');
     if (t.kind === 'punct' && t.value === '(') {
         eat(c);
-        const v = parseOr(c, vars);
+        // 括号内是完整表达式（含三元）——曾只递归 parseOr，(a ? b : c) 报「缺少 ')'」
+        const v = parseTernary(c, vars);
         if (!isPunct(c, ')'))
             throw new Error("缺少 ')'");
         eat(c);
@@ -248,10 +393,10 @@ function parsePrimary(c, vars) {
         eat(c);
         const arr = [];
         if (!isPunct(c, ']')) {
-            arr.push(parseOr(c, vars));
+            arr.push(parseTernary(c, vars));
             while (isPunct(c, ',')) {
                 eat(c);
-                arr.push(parseOr(c, vars));
+                arr.push(parseTernary(c, vars));
             }
         }
         if (!isPunct(c, ']'))
@@ -282,10 +427,10 @@ function parsePrimary(c, vars) {
             eat(c);
             const argv = [];
             if (!isPunct(c, ')')) {
-                argv.push(parseOr(c, vars));
+                argv.push(parseTernary(c, vars));
                 while (isPunct(c, ',')) {
                     eat(c);
-                    argv.push(parseOr(c, vars));
+                    argv.push(parseTernary(c, vars));
                 }
             }
             if (!isPunct(c, ')'))
@@ -349,7 +494,7 @@ export function evalExpr(expr, vars) {
     if (toks.length === 0)
         return undefined;
     const cursor = { toks, pos: 0 };
-    const v = parseOr(cursor, vars);
+    const v = parseTernary(cursor, vars);
     if (cursor.pos !== toks.length) {
         throw new Error(`表达式多余 token: "${expr}"`);
     }
@@ -362,7 +507,7 @@ export function evalExpr(expr, vars) {
  *
  * 转义：`\$` → 字面 $，跳过插值。
  */
-export function interpolate(template, vars) {
+export function interpolate(template, vars, opts) {
     let out = '';
     let i = 0;
     while (i < template.length) {
@@ -391,6 +536,8 @@ export function interpolate(template, vars) {
             }
             const expr = template.slice(i + 2, j);
             const v = evalExpr(expr, vars);
+            if (v === undefined)
+                opts?.onMissing?.(expr);
             out += stringify(v);
             i = j + 1;
             continue;
@@ -400,6 +547,42 @@ export function interpolate(template, vars) {
     }
     return out;
 }
+/**
+ * 类型保留插值：模板整串恰好是单一 "${EXPR}" 时直接返回 EXPR 的值
+ * （布尔/数字/数组原样，不字符串化）；多片段模板退回普通 interpolate。
+ * 非字符串值原样透传（与 interpolateDeep 对非字符串的行为一致）。
+ *
+ * 动机：set 步写 `flag: "${qualified}"` 曾被字符串化成 "true"，逼出下游
+ * 满篇 `== true || == 'true'` 防御——单表达式赋值就该保住类型。
+ */
+export function interpolateTyped(value, vars, opts) {
+    if (typeof value !== 'string')
+        return value;
+    const expr = singleExprOf(value);
+    if (expr === null)
+        return interpolate(value, vars, opts);
+    const v = evalExpr(expr, vars);
+    if (v === undefined)
+        opts?.onMissing?.(expr);
+    return v;
+}
+/** 整串恰好是一个 "${EXPR}"（括号配对到串尾）时返回内层 EXPR，否则 null。 */
+function singleExprOf(template) {
+    if (!template.startsWith('${') || !template.endsWith('}'))
+        return null;
+    let depth = 1;
+    for (let j = 2; j < template.length; j++) {
+        if (template[j] === '{')
+            depth++;
+        else if (template[j] === '}') {
+            depth--;
+            // 提前归零 = 中途闭合（如 "${a}-${b}"），不是单一表达式
+            if (depth === 0)
+                return j === template.length - 1 ? template.slice(2, j) : null;
+        }
+    }
+    return null;
+}
 function stringify(v) {
     if (v === null || v === undefined)
         return '';
@@ -415,19 +598,19 @@ function stringify(v) {
     }
 }
 /** 递归对对象/数组/字符串做插值；其它原样返回。 */
-export function interpolateDeep(value, vars) {
+export function interpolateDeep(value, vars, opts) {
     if (typeof value === 'string') {
-        return interpolate(value, vars);
+        return interpolate(value, vars, opts);
     }
     if (Array.isArray(value)) {
-        return value.map((v) => interpolateDeep(v, vars));
+        return value.map((v) => interpolateDeep(v, vars, opts));
     }
     if (value && typeof value === 'object') {
         const out = {};
         for (const [k, v] of Object.entries(value)) {
             // 注意：key 也插值（loop 里 `hook_${idx}` 这种），但只对字符串 key 有意义
-            const newKey = interpolate(k, vars);
-            out[newKey] = interpolateDeep(v, vars);
+            const newKey = interpolate(k, vars, opts);
+            out[newKey] = interpolateDeep(v, vars, opts);
         }
         return out;
     }

package/plugins/workflow-runner/src/index.js

@@ -12,6 +12,7 @@
  */
 import { findWorkflowByName, listWorkflows } from './loader.js';
 import { runWorkflow } from './runner.js';
+import { buildFullSystemPrompt, } from '../../../src/plugin-sdk.js';
 /**
  * 把 "/workflow <name> [pos1 pos2 ...] [--input k=v ...]" 拆成 name + 显式 inputs + 位置参数。
  * 简单解析器（不依赖第三方）：
@@ -124,6 +125,18 @@ function coerceInputs(raw, defs) {
     }
     return out;
 }
+async function refreshWorkflowSystemPrompt(history, cwd, tools) {
+    const content = await buildFullSystemPrompt(cwd, tools);
+    const systemIndex = history.findIndex((m) => m.role === 'system' && !m._ephemeral);
+    const fresh = { role: 'system', content };
+    if (systemIndex === 0) {
+        history[0] = fresh;
+        return;
+    }
+    if (systemIndex > 0)
+        history.splice(systemIndex, 1);
+    history.unshift(fresh);
+}
 /** /workflow <name> [pos...] [--input k=v] —— 主入口，由 pluginRunner 调用。 */
 export async function* runWorkflowFromCommand(rawArgs, opts) {
     const { name, inputs: rawInputs, positional } = parseWorkflowArgs(rawArgs);
@@ -142,11 +155,29 @@ export async function* runWorkflowFromCommand(rawArgs, opts) {
         };
         return;
     }
-    // 位置参数严格按"第 i 个位置参数 ↔ def.inputs[i]"对应。
-    // --input k=v 显式优先：已显式的 input 不被位置参数覆盖（对应的位置参数被丢弃，会 warn）。
-    // 多余的位置参数（超过 def.inputs 数量）也被丢弃（会 warn）。
+    const cwd = opts.cwd ?? process.cwd();
+    const tools = opts.tools ?? [];
+    await refreshWorkflowSystemPrompt(opts.history, cwd, tools);
+    // 位置参数映射，两种模式：
+    //   - 贪婪首参（def.inputs[0].greedy===true）：把【全部】位置参数用空格 join 成整句写进
+    //     首个 input（自然语言 brief 不被空格拆碎、也不会撞上后面的 number/enum 输入），
+    //     其余 input 只走 --input。用户「打一句话」即可（见 webppt.yaml::topic）。
+    //   - 默认：严格按"第 i 个位置参数 ↔ def.inputs[i]"对应。
+    // --input k=v 显式优先：已显式的 input 不被位置参数覆盖（对应位置参数被丢弃，会 warn）。
     const overriddenByKV = [];
-    if (positional.length > 0 && def.inputs) {
+    const greedyFirst = def.inputs?.[0]?.greedy === true;
+    if (greedyFirst && def.inputs && positional.length > 0) {
+        const greedyName = def.inputs[0].name;
+        if (greedyName in rawInputs) {
+            // 首参已被 --input 占位 → 整串位置参数被忽略
+            overriddenByKV.push(`${greedyName}=${JSON.stringify(rawInputs[greedyName])} (位置参数 ${JSON.stringify(positional.join(' '))} 被忽略)`);
+        }
+        else {
+            // 贪婪吸收：整句进首参（空格 join 还原用户原话，不逐位拆映射）
+            rawInputs[greedyName] = positional.join(' ');
+        }
+    }
+    else if (positional.length > 0 && def.inputs) {
         const max = Math.min(positional.length, def.inputs.length);
         for (let i = 0; i < max; i++) {
             const inputDef = def.inputs[i];
@@ -161,8 +192,8 @@ export async function* runWorkflowFromCommand(rawArgs, opts) {
             }
         }
     }
-    // warn：超量位置参数（用户写多了，提示一下）
-    if (def.inputs && positional.length > def.inputs.length) {
+    // warn：超量位置参数（仅非 greedy 模式；greedy 全部吸收进首参，不算多余）
+    if (!greedyFirst && def.inputs && positional.length > def.inputs.length) {
         const dropped = positional.slice(def.inputs.length);
         yield {
             type: 'warning',
@@ -188,8 +219,9 @@ export async function* runWorkflowFromCommand(rawArgs, opts) {
         provider: opts.provider,
         signal: opts.signal,
         history: opts.history,
-        cwd: opts.cwd ?? process.cwd(),
-        tools: opts.tools ?? [],
+        sessionState: opts.sessionState,
+        cwd,
+        tools,
     };
     // 透传 runWorkflow 的事件，并观察是否出现终结事件（error / interrupted = 失败或中断，
     // 与 gateway broker 的 TERMINAL 判定同一套逻辑）。成功（没见到终结事件）则在末尾补一条

package/plugins/workflow-runner/src/jsonPayload.js

@@ -10,7 +10,7 @@
  *    破坏主循环。剥离必须发生在「契约要求纯 JSON」的边界，也就是 workflow 的
  *    output_schema 解析处。本模块就是那个边界的唯一实现，被两个解析点共享：
  *      - stepExecutors/llm.ts（llm + output_schema 单轮）
- *      - miniReAct.ts（agent 节点 / llm+context_files / onError:recover 三处子循环）
+ *      - stepExecutors/llm.ts（output_schema 解析处）
  *    放一处、两边 import，杜绝"只修一个解析点、另一个继续炸"的漂移。
  *
  *  处理顺序（保守、纯函数、可单测）：