@qwen-code/qwen-code 0.18.1 → 0.18.2

package/chunks/{workflow-5LNNLNUR.js → workflow-ZN3DYFMU.js}

@@ -8,9 +8,9 @@ import {
   generateAgentWorktreeSlug,
   rebuildToolRegistryOnOverride,
   writeWorktreeSessionMarker
-} from "./chunk-6T7Y7USE.js";
+} from "./chunk-EQ5NHJBY.js";
 import "./chunk-K5PGHDBN.js";
-import "./chunk-HQUWWSSP.js";
+import "./chunk-VIEIRAK3.js";
 import "./chunk-O4PICXES.js";
 import "./chunk-TW522KN6.js";
 import "./chunk-BJ5HQ23U.js";
@@ -24,7 +24,7 @@ import "./chunk-CPVI5J2L.js";
 import "./chunk-ZMIBJS45.js";
 import "./chunk-77WXWU44.js";
 import "./chunk-B4ZF2KSI.js";
-import "./chunk-RON7LFNH.js";
+import "./chunk-25FFAMED.js";
 import "./chunk-3PJXIDKI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
@@ -32,13 +32,13 @@ import "./chunk-IQHSD7K5.js";
 import "./chunk-LYRSMKLS.js";
 import {
   SyntheticOutputTool
-} from "./chunk-QILTEBWS.js";
+} from "./chunk-RTTAC5VW.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-A2ZIEEGJ.js";
+} from "./chunk-ZNUMXPNK.js";
 import "./chunk-IDYDPBBN.js";
 import "./chunk-FIQECJTQ.js";
 import {
@@ -75,10 +75,10 @@ import * as os from "node:os";
 // packages/core/src/agents/runtime/workflow-sandbox.ts
 init_esbuild_shims();
 import * as vm from "node:vm";
-function stripExportMeta(source) {
+function findMetaBlockBounds(source) {
   const re = /^\s*export\s+const\s+meta\s*=\s*\{/;
   const match = re.exec(source);
-  if (!match) return source;
+  if (!match) return null;
   const exportIdx = match.index;
   const startBrace = source.indexOf("{", exportIdx);
   let depth = 1;
@@ -136,10 +136,114 @@ function stripExportMeta(source) {
       "stripExportMeta: unbalanced braces in export const meta declaration \u2014 the workflow script cannot be safely stripped. Check the meta block syntax."
     );
   }
+  const endBraceIncl = i - 1;
   while (i < source.length && /[\s;]/.test(source[i])) i++;
-  return source.slice(0, exportIdx) + source.slice(i);
+  return { exportIdx, startBrace, endBraceIncl, afterMeta: i };
 }
-__name(stripExportMeta, "stripExportMeta");
+__name(findMetaBlockBounds, "findMetaBlockBounds");
+function extractAndStripMeta(source) {
+  const bounds = findMetaBlockBounds(source);
+  if (!bounds) return { stripped: source, meta: null };
+  const metaSource = source.slice(bounds.startBrace, bounds.endBraceIncl + 1);
+  const stripped = source.slice(0, bounds.exportIdx) + source.slice(bounds.afterMeta);
+  const metaContext = vm.createContext(/* @__PURE__ */ Object.create(null));
+  let raw;
+  try {
+    raw = new vm.Script(`(${metaSource})`).runInContext(metaContext);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(
+      `extractAndStripMeta: failed to evaluate meta object literal: ${msg}`
+    );
+  }
+  rejectThenablesInMeta(raw);
+  const meta = validateMeta(raw);
+  return { stripped, meta };
+}
+__name(extractAndStripMeta, "extractAndStripMeta");
+function rejectThenablesInMeta(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  const maybeThen = value.then;
+  if (typeof maybeThen === "function") {
+    try {
+      value.catch(() => {
+      });
+    } catch {
+    }
+    throw new Error(
+      "extractAndStripMeta: meta values must not be Promises (no async / dynamic import allowed in meta literal)"
+    );
+  }
+  if (Array.isArray(value)) {
+    for (const v of value) rejectThenablesInMeta(v, seen);
+    return;
+  }
+  for (const v of Object.values(value)) {
+    rejectThenablesInMeta(v, seen);
+  }
+}
+__name(rejectThenablesInMeta, "rejectThenablesInMeta");
+function validateMeta(value) {
+  if (value === null || typeof value !== "object") {
+    throw new Error("meta must be an object");
+  }
+  const obj = value;
+  if (typeof obj["name"] !== "string" || obj["name"].length === 0) {
+    throw new Error("meta.name must be a non-empty string");
+  }
+  if (typeof obj["description"] !== "string" || obj["description"].length === 0) {
+    throw new Error("meta.description must be a non-empty string");
+  }
+  if (obj["whenToUse"] !== void 0 && typeof obj["whenToUse"] !== "string") {
+    throw new Error("meta.whenToUse must be a string");
+  }
+  let phases;
+  if (obj["phases"] !== void 0) {
+    if (!Array.isArray(obj["phases"])) {
+      throw new Error("meta.phases must be an array");
+    }
+    phases = [];
+    for (const p of obj["phases"]) {
+      if (p === null || typeof p !== "object") {
+        throw new Error("meta.phases entries must be objects");
+      }
+      const ph = p;
+      if (typeof ph["title"] !== "string" || ph["title"].length === 0) {
+        throw new Error("meta.phases[].title must be a non-empty string");
+      }
+      const phase = {
+        title: ph["title"]
+      };
+      if (ph["detail"] !== void 0) {
+        if (typeof ph["detail"] !== "string") {
+          throw new Error("meta.phases[].detail must be a string");
+        }
+        phase.detail = ph["detail"];
+      }
+      if (ph["model"] !== void 0) {
+        if (typeof ph["model"] !== "string") {
+          throw new Error("meta.phases[].model must be a string");
+        }
+        phase.model = ph["model"];
+      }
+      phases.push(phase);
+    }
+  }
+  const out = {
+    name: obj["name"],
+    description: obj["description"]
+  };
+  if (obj["whenToUse"] !== void 0) {
+    out.whenToUse = obj["whenToUse"];
+  }
+  if (phases !== void 0) {
+    out.phases = phases;
+  }
+  return out;
+}
+__name(validateMeta, "validateMeta");
 function isRegexContext(source, i) {
   let j = i - 1;
   while (j >= 0 && /\s/.test(source[j])) j--;
@@ -202,14 +306,27 @@ function createWorkflowSandbox(opts) {
   const logs = [];
   const safeLog = /* @__PURE__ */ __name((msg) => {
     if (logs.length < MAX_LOG_LINES) {
-      logs.push(String(msg));
+      const line = String(msg);
+      logs.push(line);
+      try {
+        opts.emitter?.logAppended?.(line);
+      } catch (e) {
+        debugLogger.warn("emitter.logAppended threw:", e);
+      }
     } else if (logs.length === MAX_LOG_LINES) {
       logs.push(`[workflow log truncated at ${MAX_LOG_LINES} lines]`);
     }
   }, "safeLog");
   const safePhase = /* @__PURE__ */ __name((title) => {
     if (phases.length < MAX_PHASE_ENTRIES) {
-      phases.push(String(title));
+      const t = String(title);
+      if (phases[phases.length - 1] === t) return;
+      phases.push(t);
+      try {
+        opts.emitter?.phaseStarted?.(t);
+      } catch (e) {
+        debugLogger.warn("emitter.phaseStarted threw:", e);
+      }
     } else if (phases.length === MAX_PHASE_ENTRIES) {
       phases.push(
         `[workflow phases truncated at ${MAX_PHASE_ENTRIES} entries]`
@@ -569,9 +686,11 @@ function createWorkflowSandbox(opts) {
     { filename: "workflow-sandbox-init.js" }
   );
   const maxWallClockMs = resolveMaxWallClockMs(opts);
+  let extractedMeta = null;
   return {
     async run(scriptSource) {
-      const stripped = stripExportMeta(scriptSource);
+      const { stripped, meta } = extractAndStripMeta(scriptSource);
+      extractedMeta = meta;
       const wrapped = `(async () => {
 ${stripped}
 })()`;
@@ -601,7 +720,8 @@ ${stripped}
       }
     },
     getPhases: /* @__PURE__ */ __name(() => [...phases], "getPhases"),
-    getLogs: /* @__PURE__ */ __name(() => [...logs], "getLogs")
+    getLogs: /* @__PURE__ */ __name(() => [...logs], "getLogs"),
+    getMeta: /* @__PURE__ */ __name(() => extractedMeta, "getMeta")
   };
 }
 __name(createWorkflowSandbox, "createWorkflowSandbox");
@@ -718,10 +838,11 @@ var WORKFLOW_SUBAGENT_DISALLOWED_TOOLS = [
   ToolNames.EXIT_PLAN_MODE
 ];
 var WorkflowExecutionError = class extends Error {
-  constructor(message, phases, logs) {
+  constructor(message, phases, logs, meta = null) {
     super(message);
     this.phases = phases;
     this.logs = logs;
+    this.meta = meta;
   }
   static {
     __name(this, "WorkflowExecutionError");
@@ -738,7 +859,7 @@ function sanitizeForErrorMessage(value) {
 __name(sanitizeForErrorMessage, "sanitizeForErrorMessage");
 function createProductionDispatch(config, signal) {
   return async (prompt, opts) => {
-    const { AgentHeadless, ContextState } = await import("./agent-headless-LNRE63ZL.js");
+    const { AgentHeadless, ContextState } = await import("./agent-headless-24356DC7.js");
     const ctx = new ContextState();
     ctx.set("task_prompt", prompt);
     if (opts.agentType === void 0 && opts.model === void 0 && opts.isolation === void 0 && opts.schema === void 0) {
@@ -1134,11 +1255,12 @@ var WorkflowOrchestrator = class {
     __name(this, "WorkflowOrchestrator");
   }
   async run(req) {
-    const runId = generateRunId();
+    const runId = req.runId ?? generateRunId();
     const maxAgents = resolveMaxAgentsPerRun();
     const signal = req.abortOnTimeout?.signal;
     const limiter = createConcurrencyLimiter(resolveConcurrencyLimit(), signal);
     let agentCount = 0;
+    const emitter = req.emitter;
     const countedDispatch = /* @__PURE__ */ __name((prompt, opts) => {
       agentCount += 1;
       if (agentCount > maxAgents) {
@@ -1148,7 +1270,31 @@ var WorkflowOrchestrator = class {
           )
         );
       }
-      return limiter.run(() => this.dispatch(prompt, opts));
+      const label = typeof opts.label === "string" ? opts.label : void 0;
+      try {
+        emitter?.agentDispatched?.(label);
+      } catch (e) {
+        debugLogger.warn("emitter.agentDispatched threw:", e);
+      }
+      return limiter.run(() => this.dispatch(prompt, opts)).then(
+        (result) => {
+          try {
+            emitter?.agentCompleted?.(label);
+          } catch (e) {
+            debugLogger.warn("emitter.agentCompleted threw:", e);
+          }
+          return result;
+        },
+        (err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          try {
+            emitter?.agentCompleted?.(label, msg);
+          } catch (e) {
+            debugLogger.warn("emitter.agentCompleted threw:", e);
+          }
+          throw err;
+        }
+      );
     }, "countedDispatch");
     const parallelImpl = makeParallelImpl(signal);
     const pipelineImpl = makePipelineImpl(signal);
@@ -1157,7 +1303,8 @@ var WorkflowOrchestrator = class {
       dispatch: countedDispatch,
       parallel: parallelImpl,
       pipeline: pipelineImpl,
-      abortOnTimeout: req.abortOnTimeout
+      abortOnTimeout: req.abortOnTimeout,
+      emitter
     });
     try {
       const result = await sandbox.run(req.script);
@@ -1165,13 +1312,15 @@ var WorkflowOrchestrator = class {
         runId,
         result,
         phases: sandbox.getPhases(),
-        logs: sandbox.getLogs()
+        logs: sandbox.getLogs(),
+        meta: sandbox.getMeta()
       };
     } catch (err) {
       throw new WorkflowExecutionError(
         extractErrorMessage(err),
         sandbox.getPhases(),
-        sandbox.getLogs()
+        sandbox.getLogs(),
+        sandbox.getMeta()
       );
     }
   }
@@ -1258,6 +1407,7 @@ function extractErrorMessage(err) {
 __name(extractErrorMessage, "extractErrorMessage");
 
 // packages/core/src/tools/workflow/workflow.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
 var WORKFLOW_PARAM_SCHEMA = {
   type: "object",
   properties: {
@@ -1289,19 +1439,58 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
   getDefaultPermission() {
     return Promise.resolve("ask");
   }
-  async execute(signal, _updateOutput, _shellExecutionConfig) {
+  async execute(signal, updateOutput, _shellExecutionConfig) {
     const dispatchController = createChildAbortController(signal);
     const dispatch = this.toolOptions.dispatch ?? createProductionDispatch(this.config, dispatchController.signal);
     const orchestrator = new WorkflowOrchestrator(dispatch);
+    const runId = `wf_${randomBytes2(8).toString("hex")}`;
+    const registry = this.config.getWorkflowRunRegistry?.();
+    const registryEntry = registry?.register({
+      runId,
+      meta: null,
+      // populated after meta parses; safe default until then
+      status: "running",
+      startTime: Date.now(),
+      outputFile: "",
+      // P4b reserves the field but doesn't materialize
+      abortController: dispatchController
+    });
+    const emitter = {
+      phaseStarted: /* @__PURE__ */ __name((title) => {
+        registry?.onPhaseStarted(runId, title);
+        safeEmitUpdate(updateOutput, registryEntry);
+      }, "phaseStarted"),
+      agentDispatched: /* @__PURE__ */ __name(() => {
+        registry?.onAgentDispatched(runId);
+        safeEmitUpdate(updateOutput, registryEntry);
+      }, "agentDispatched"),
+      agentCompleted: /* @__PURE__ */ __name(() => {
+        registry?.onAgentCompleted(runId);
+        safeEmitUpdate(updateOutput, registryEntry);
+      }, "agentCompleted"),
+      logAppended: /* @__PURE__ */ __name(() => {
+      }, "logAppended")
+    };
     try {
       const outcome = await orchestrator.run({
         script: this.params.script,
         args: this.params.args,
-        abortOnTimeout: dispatchController
+        abortOnTimeout: dispatchController,
+        runId,
+        emitter
       });
+      if (registryEntry) {
+        registryEntry.meta = outcome.meta;
+        if (outcome.meta?.name && registryEntry.description === runId) {
+          registryEntry.description = outcome.meta.name;
+        }
+      }
+      registry?.setRecentLogs(runId, outcome.logs);
+      registry?.complete(runId, outcome.result, Date.now());
       const llmText = safeStringifyResult(outcome.result);
       const displayJson = safeStringifyDisplayPayload({
         runId: outcome.runId,
+        ...outcome.meta ? { meta: outcome.meta } : {},
         phases: outcome.phases,
         logs: outcome.logs,
         result: outcome.result
@@ -1314,9 +1503,20 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
       const message = extractErrorMessage2(err);
       const phases = err instanceof WorkflowExecutionError ? err.phases : void 0;
       const logs = err instanceof WorkflowExecutionError ? err.logs : void 0;
-      const display = phases || logs ? `Workflow failed: ${message}
+      const meta = err instanceof WorkflowExecutionError ? err.meta : void 0;
+      if (registryEntry) {
+        if (meta && !registryEntry.meta) registryEntry.meta = meta;
+      }
+      if (logs) registry?.setRecentLogs(runId, logs);
+      if (signal.aborted) {
+        registry?.cancel(runId, Date.now());
+      } else {
+        registry?.fail(runId, message, Date.now());
+      }
+      const display = phases || logs || meta ? `Workflow failed: ${message}
 
 ${safeStringifyDisplayPayload({
+        ...meta ? { meta } : {},
         phases: phases ?? [],
         logs: logs ?? []
       })}` : `Workflow failed: ${message}`;
@@ -1333,6 +1533,31 @@ ${safeStringifyDisplayPayload({
     }
   }
 };
+function buildLivePhaseTreeDisplay(entry) {
+  const payload = {
+    runId: entry.runId,
+    ...entry.meta ? { meta: entry.meta } : {},
+    status: entry.status,
+    currentPhase: entry.currentPhase,
+    phases: entry.phases,
+    agentsDispatched: entry.agentsDispatched,
+    agentsCompleted: entry.agentsCompleted
+  };
+  try {
+    return "```json\n" + JSON.stringify(payload, null, 2) + "\n```";
+  } catch {
+    return `Workflow ${entry.runId} \u2014 ${entry.status} \u2014 ${entry.phases.length} phase(s)`;
+  }
+}
+__name(buildLivePhaseTreeDisplay, "buildLivePhaseTreeDisplay");
+function safeEmitUpdate(updateOutput, entry) {
+  if (!updateOutput || !entry) return;
+  try {
+    updateOutput(buildLivePhaseTreeDisplay(entry));
+  } catch {
+  }
+}
+__name(safeEmitUpdate, "safeEmitUpdate");
 function safeStringifyResult(result) {
   if (result === void 0) return "(workflow returned no value)";
   if (typeof result === "string") return result;
@@ -1386,7 +1611,7 @@ var WorkflowTool = class extends BaseDeclarativeTool {
       /* isOutputMarkdown */
       true,
       /* canUpdateOutput */
-      false
+      true
     );
     this.config = config;
     this.toolOptions = toolOptions;

package/chunks/{write-file-2I7HP24C.js → write-file-355M4V7Z.js}

@@ -3,7 +3,7 @@
 import {
   StructuredToolError,
   checkPriorRead
-} from "./chunk-7KPZFE5A.js";
+} from "./chunk-C64WAJOC.js";
 import {
   CommitAttributionService,
   DEFAULT_DIFF_OPTIONS,
@@ -12,9 +12,9 @@ import {
   detectLineEnding,
   getDiffStat,
   needsUtf8Bom
-} from "./chunk-6T7Y7USE.js";
+} from "./chunk-EQ5NHJBY.js";
 import "./chunk-K5PGHDBN.js";
-import "./chunk-HQUWWSSP.js";
+import "./chunk-VIEIRAK3.js";
 import "./chunk-O4PICXES.js";
 import "./chunk-TW522KN6.js";
 import "./chunk-BJ5HQ23U.js";
@@ -34,7 +34,7 @@ import {
   getLanguageFromFilePath,
   getSpecificMimeType,
   logFileOperation
-} from "./chunk-RON7LFNH.js";
+} from "./chunk-25FFAMED.js";
 import "./chunk-3PJXIDKI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
@@ -42,13 +42,13 @@ import {
   isAnyAutoMemPath
 } from "./chunk-IQHSD7K5.js";
 import "./chunk-LYRSMKLS.js";
-import "./chunk-QILTEBWS.js";
+import "./chunk-RTTAC5VW.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-A2ZIEEGJ.js";
+} from "./chunk-ZNUMXPNK.js";
 import "./chunk-IDYDPBBN.js";
 import "./chunk-FIQECJTQ.js";
 import "./chunk-64WXLC72.js";