minimal-agent 0.10.0 → 0.12.0

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

@@ -1,5 +1,6 @@
 import { isAbsolute, resolve } from 'node:path';
 import { interpolate } from './expressions.js';
+import { effectiveWorkflowCwd } from './toolRuntime.js';
 export function resolveWorkflowMultimodalOptions(step, vars, ctx, onMissing) {
     const imageDetail = step.image_detail;
     const imageMaxLongSidePixel = step.image_max_long_side_pixel;
@@ -33,5 +34,5 @@ function resolveWorkflowImageSource(source, ctx) {
         isAbsolute(clean)) {
         return clean;
     }
-    return resolve(ctx.cwd, clean);
+    return resolve(effectiveWorkflowCwd(ctx), clean);
 }

package/plugins/workflow-runner/src/multimodal.ts

@@ -0,0 +1,64 @@
+import { isAbsolute, resolve } from 'node:path';
+
+import type { ImageDetail, ImageInputSpec } from '../../../src/plugin-sdk.js';
+import { interpolate } from './expressions.js';
+import { effectiveWorkflowCwd } from './toolRuntime.js';
+import type { RunContext, StepDef, VarStack } from './types.js';
+
+export interface WorkflowMultimodalOptions {
+  imageInputs?: ImageInputSpec[];
+  parseInlineImages?: boolean;
+  imageDetail?: ImageDetail;
+  imageMaxLongSidePixel?: number;
+}
+
+export function resolveWorkflowMultimodalOptions(
+  step: StepDef,
+  vars: VarStack,
+  ctx: RunContext,
+  onMissing?: (expr: string) => void,
+): WorkflowMultimodalOptions {
+  const imageDetail = step.image_detail;
+  const imageMaxLongSidePixel = step.image_max_long_side_pixel;
+  const imageInputs = (step.images ?? []).map((item) => {
+    if (typeof item === 'string') {
+      return {
+        source: resolveWorkflowImageSource(
+          interpolate(item, vars, { onMissing }),
+          ctx,
+        ),
+        detail: imageDetail,
+        maxLongSidePixel: imageMaxLongSidePixel,
+      };
+    }
+    return {
+      source: resolveWorkflowImageSource(
+        interpolate(item.source, vars, { onMissing }),
+        ctx,
+      ),
+      detail: item.detail ?? imageDetail,
+      maxLongSidePixel: item.max_long_side_pixel ?? imageMaxLongSidePixel,
+    };
+  });
+
+  return {
+    imageInputs: imageInputs.length > 0 ? imageInputs : undefined,
+    parseInlineImages: step.parse_inline_images,
+    imageDetail,
+    imageMaxLongSidePixel,
+  };
+}
+
+function resolveWorkflowImageSource(source: string, ctx: RunContext): string {
+  const clean = source.trim();
+  if (
+    /^https?:\/\//i.test(clean) ||
+    /^data:image\//i.test(clean) ||
+    clean.startsWith('file://') ||
+    clean.startsWith('~/') ||
+    isAbsolute(clean)
+  ) {
+    return clean;
+  }
+  return resolve(effectiveWorkflowCwd(ctx), clean);
+}

package/plugins/workflow-runner/src/recovery.ts

@@ -0,0 +1,149 @@
+/**
+ * ============================================================
+ *  plugins/workflow-runner/src/recovery.ts —— 节点失败的自适应恢复
+ * ------------------------------------------------------------
+ *  「确定性工作流 × 随机应变 agent」的结合点（onError:'recover'）。
+ *
+ *  传统 DAG 的脆点：某节点抛错 → 整条 halt（或 onError:'continue' 盲跳，下游
+ *  capture 拿 undefined 静默级联错）。当节点声明 onError:'recover' 时，runner
+ *  不立刻 halt，而是调本模块起一个**有界恢复 agent**（委托 runQuery/TAOR），
+ *  喂给它「工作流总目标 + 失败节点的意图 + 错误信息 + 当前已知变量 + 下游 capture 契约」，
+ *  让它**随机应变去达成该节点本来要的结果**（换路径 / 换命令 / 先读后写…）。
+ *
+ *  v0.9 重构：不再使用独立 miniReAct 子循环，而是委托主 TAOR 引擎（runQuery）
+ *  在共享 ctx.history 上执行。恢复过程也写入共享上下文——后续对话能看到"某步失败后
+ *  如何被自动修复"，增强可解释性。
+ *
+ *  —— 共享大脑 ——
+ *  恢复 agent 与正常 agent/llm/skill 步本质同构：都通过 runQuery(TAOR) 执行。
+ *  本模块只构造「救火」角色提示词，跑完后交给 interpretMiniReActResult 判定
+ *  「真救回 / 放弃」。返回 AgentOutcome：
+ *    - { ok:true, value }  —— runner 用同一个 step.capture 绑定后继续 happy path
+ *    - { ok:false, reason } —— runner 带原因 honest halt
+ * ============================================================
+ */
+
+import type { LoopEvent } from '../../../src/plugin-sdk.js';
+import {
+  type AgentOutcome,
+  describeCaptureContract,
+  effectiveGoalAnchor,
+  interpretMiniReActResult,
+  runStepQuery,
+  truncate,
+} from './agentCommon.js';
+import { interpolate, interpolateDeep } from './expressions.js';
+import type { RunContext, StepDef, VarStack } from './types.js';
+
+// RECOVER_OPENING 作为用户消息的一部分（系统提示词已在 history[0] 中）
+const RECOVER_OPENING = `你是一名资深的自动化工程师 / SRE，被一个确定性工作流临时调来「救火」。
+工作流里一个原本写死的步骤刚刚执行失败了，现在交给你随机应变——先看错误信息诊断根因，再想办法真正达成这个步骤**本来要的结果**（关注它要的结果，别拘泥它原先怎么写）。`;
+
+/** 描述失败节点「本来要干什么」，喂给恢复 agent 作为意图说明。 */
+function describeStepIntent(step: StepDef, vars: VarStack): string {
+  if (step.tool) {
+    const args = interpolateDeep(step.args ?? {}, vars);
+    return `调用工具 ${step.tool}，参数：${JSON.stringify(args)}`;
+  }
+  if (step.agent) {
+    return `自主完成这个开放任务：${interpolate(step.agent, vars)}`;
+  }
+  if (step.llm) {
+    return `用 LLM 生成内容，提示词：${interpolate(step.llm, vars)}`;
+  }
+  if (step.skill) {
+    const input = step.input ? interpolate(step.input, vars) : '(无显式输入)';
+    return `执行 skill「${interpolate(step.skill, vars)}」，输入：${input}`;
+  }
+  if (step.type === 'assert') {
+    return `让这个断言成立：${step.condition}`;
+  }
+  return `完成步骤 ${step.id}`;
+}
+
+/**
+ * 尝试自适应恢复一个失败的动作 step。
+ *   - 救回 → { ok:true, value }（value.raw 已 normalize，可被原 step.capture 绑定）
+ *   - 放弃 / 不可信 / 子循环抛错（含用户中断）→ { ok:false, reason }
+ */
+export async function* runRecovery(
+  step: StepDef,
+  vars: VarStack,
+  ctx: RunContext,
+  errorMsg: string,
+): AsyncGenerator<LoopEvent, AgentOutcome, void> {
+  const intent = describeStepIntent(step, vars);
+  const knownVars = truncate(JSON.stringify(vars.snapshot()), 1500);
+  const goalLine = ctx.goal ? `工作流总目标：${ctx.goal}\n\n` : '';
+  const captureLine = describeCaptureContract(step);
+  const hintLine = step.recover_hint
+    ? `\n\n作者给恢复的提示：${interpolate(step.recover_hint, vars)}`
+    : '';
+
+  // 构造恢复 prompt（作为 user message push 进共享 history）
+  const recoverPrompt =
+    `${RECOVER_OPENING}\n\n` +
+    `${goalLine}` +
+    `失败的步骤（id=${step.id}）本来要做的事：\n${intent}\n\n` +
+    `它失败时的错误：\n${truncate(errorMsg, 800)}\n\n` +
+    `当前已知的变量（JSON）：\n${knownVars}` +
+    `${captureLine}${hintLine}\n\n` +
+    `请随机应变，把这一步要的结果做出来；做不成就按约定输出放弃标记。`;
+
+  // output_schema 约束嵌入 prompt
+  const schemaHint = step.output_schema
+    ? `\n\n【结构化输出约束】请严格按照以下 JSON Schema 输出结果：\n${JSON.stringify(step.output_schema, null, 2)}`
+    : '';
+
+  // 通用目标锚定（同 agent/llm/skill 步）：恢复 agent 也要看到用户原始目标
+  // 与补充要求，不能只有 def.description 的"工作流总目标"（E10）。
+  const anchor = effectiveGoalAnchor(ctx);
+  const fullPrompt = anchor
+    ? `${anchor}\n\n${recoverPrompt}${schemaHint}`
+    : recoverPrompt + schemaHint;
+
+  try {
+    // 委托 TAOR 引擎执行（共享消费层 runStepQuery）——事件透传给 UI（显示恢复进度）。
+    // 注意剥掉 step 的 allowed_tools 白名单：原步收敛工具是为弱模型聚焦，
+    // 恢复 agent 的职责正是「随机应变换路径」，要全工具箱（保持 v0.9 行为）。
+    const { rawText, sawLlmError, sawMaxTurns, llmErrorDetail } =
+      yield* runStepQuery(
+        fullPrompt,
+        { ...step, allowed_tools: undefined },
+        ctx,
+        { maxTurns: step.maxTurns ?? 25 },
+      );
+
+    // 恢复是兜底路径：无论 provider 失败还是模型空答，都按「没救回」返回
+    // ok:false（不抛重试——retry 在进入 recover 前已用尽）；只是归因更诚实。
+    if (!rawText.trim() && sawLlmError) {
+      return {
+        ok: false,
+        reason: `LLM 调用失败且无产出${llmErrorDetail ? `—— ${truncate(llmErrorDetail, 300)}` : ''}`,
+      };
+    }
+    // 恢复 agent 也撞 maxTurns 截断 → 截断产出不可信，诚实「未救回」
+    if (sawMaxTurns) {
+      return {
+        ok: false,
+        reason: `恢复 agent 达到最大轮数 ${step.maxTurns ?? 25} 被截断，产出不可信（未救回）`,
+      };
+    }
+
+    const stepResult: import('./types.js').StepResult = {
+      raw: { text: rawText, result: rawText },
+      preview: rawText.length > 200 ? `${rawText.slice(0, 200)}...` : rawText,
+    };
+    const outcome = interpretMiniReActResult(stepResult, !!step.output_schema);
+    if (!outcome.ok) return outcome;
+
+    // 救回：preview 加 recovered: 前缀（runner 的 step_end output 用），raw 原样。
+    return {
+      ok: true,
+      value: { raw: outcome.value.raw, preview: `recovered: ${outcome.value.preview}` },
+    };
+  } catch (e) {
+    // runStepQuery 抛错（编程性异常 / 中断竞态）→ 恢复失败。
+    return { ok: false, reason: (e as Error).message ?? String(e) };
+  }
+}