@qwen-code/qwen-code 0.21.14 → 0.21.15

package/chunks/{workflow-SR7SEAU7.js → workflow-HF6G5XNX.js}

@@ -14,58 +14,58 @@ import {
   toModelVisibleSubagentResult,
   writeWorkflowSnapshot,
   writeWorktreeSessionMarker
-} from "./chunk-OFTPCOGR.js";
+} from "./chunk-L7RG5PVT.js";
 import "./chunk-GOFAQQZA.js";
 import "./chunk-5M6IDOMF.js";
 import "./chunk-TWPJO254.js";
 import "./chunk-CQ35AJ4Z.js";
-import "./chunk-FS5NGKWC.js";
-import "./chunk-SLILKYV2.js";
-import "./chunk-NVRMCWTP.js";
-import "./chunk-AKBOLMUF.js";
+import "./chunk-F5JZDC4O.js";
+import "./chunk-T2LUUKRI.js";
+import "./chunk-A7NBZBGQ.js";
+import "./chunk-7S22SX2L.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
-import "./chunk-544KT7X4.js";
+import "./chunk-BBMVUTXO.js";
 import "./chunk-IRH27ZC2.js";
 import "./chunk-QHWCP53L.js";
-import "./chunk-OBJYN4MX.js";
-import "./chunk-2C6HJMG3.js";
+import "./chunk-G64PEZZ5.js";
+import "./chunk-O75QDGQF.js";
 import "./chunk-O6GEWCJA.js";
 import "./chunk-T26EAKDL.js";
 import "./chunk-ZPJWUGCS.js";
 import "./chunk-CPBF7KYF.js";
 import {
   SUBAGENT_PLAN_LIFECYCLE_TOOLS
-} from "./chunk-RWDNJBWN.js";
-import "./chunk-WPVUOVYX.js";
-import "./chunk-MIPFDQAF.js";
+} from "./chunk-ZUISK67X.js";
+import "./chunk-3EQHT3IC.js";
+import "./chunk-4W4BROUS.js";
 import "./chunk-MLXTMF7H.js";
-import "./chunk-KV27IEHM.js";
-import "./chunk-E3DYKPYZ.js";
-import "./chunk-4ZMS3JCR.js";
-import "./chunk-DGJ7O55J.js";
-import "./chunk-OO4FKHLO.js";
+import "./chunk-L5JHSPET.js";
+import "./chunk-X7EQHW5L.js";
+import "./chunk-JBSW7JA6.js";
+import "./chunk-O327G3QW.js";
+import "./chunk-2GM44E7D.js";
 import "./chunk-SAH4BD2J.js";
-import "./chunk-XLLKYULU.js";
+import "./chunk-ZWWU6KNS.js";
 import {
   runWithAgentContext
-} from "./chunk-PT4I7NBA.js";
+} from "./chunk-VX7TFATF.js";
 import "./chunk-S6LOFUVP.js";
 import "./chunk-2J3OJGTL.js";
-import "./chunk-SG7ZP5PG.js";
+import "./chunk-HHNSO2Y4.js";
 import "./chunk-K623ENWT.js";
 import "./chunk-AQ37AY7B.js";
 import {
   WorkspaceContext
-} from "./chunk-KBXKR5R2.js";
-import "./chunk-I3N2Z25H.js";
+} from "./chunk-M5AIO24H.js";
+import "./chunk-47VTGCYK.js";
 import "./chunk-NAVJD2PQ.js";
-import "./chunk-ROIYNTHJ.js";
-import "./chunk-2B2BF7P7.js";
+import "./chunk-MD7XDTW7.js";
+import "./chunk-FAIJ5UIU.js";
 import "./chunk-P3QQPMQA.js";
-import "./chunk-YZHRN3CF.js";
-import "./chunk-FAAUPSY2.js";
+import "./chunk-SWOKDPS5.js";
+import "./chunk-HEMFCAHG.js";
 import "./chunk-KM73TBQ4.js";
 import "./chunk-AXMWHKXA.js";
 import "./chunk-GLCZKT5V.js";
@@ -73,49 +73,49 @@ import {
   createAbortController,
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
-import "./chunk-QFJ5JHQR.js";
+import "./chunk-PXOIRYE5.js";
+import "./chunk-7NLDU6J2.js";
 import {
   WorkflowRunEvent,
   logWorkflowRun,
   read,
   writeLine
-} from "./chunk-KC4WMLZO.js";
+} from "./chunk-EXY6APEA.js";
 import "./chunk-YRLW2MSX.js";
 import "./chunk-VGC4I5JJ.js";
-import "./chunk-3PWCMXIR.js";
-import "./chunk-CHHABXPE.js";
-import "./chunk-MA2HEDVP.js";
+import "./chunk-MGEWDLRO.js";
+import "./chunk-5AAW6E3C.js";
+import "./chunk-4CKU5K2R.js";
 import {
   SyntheticOutputTool
-} from "./chunk-XUJNK7Y6.js";
+} from "./chunk-7WVB4FMG.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-6HY6IF3Z.js";
-import "./chunk-2A6VQJYK.js";
+} from "./chunk-OUYRA764.js";
+import "./chunk-DK4HL3IB.js";
 import "./chunk-F6WFNA7U.js";
 import "./chunk-WZAD4ZNJ.js";
 import "./chunk-FPGTNKCP.js";
 import "./chunk-YHC2EYYG.js";
-import "./chunk-CPHEPGAO.js";
-import "./chunk-DVR7XKO5.js";
-import "./chunk-YECDICIO.js";
+import "./chunk-722JBVVW.js";
+import "./chunk-B5LEKTE7.js";
+import "./chunk-Q6ETBOWF.js";
+import "./chunk-HHJLM3WQ.js";
 import {
   stripAnsiAndControl
-} from "./chunk-XT4RKHVE.js";
-import "./chunk-HHJLM3WQ.js";
-import "./chunk-D34RDOLP.js";
+} from "./chunk-RZ4PE3ER.js";
 import {
   createDebugLogger
-} from "./chunk-BUQDLC2G.js";
+} from "./chunk-XFRYCCVC.js";
 import "./chunk-VOQXFAY5.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
 import "./chunk-AMDSOFFV.js";
-import "./chunk-QUGAUQGJ.js";
+import "./chunk-GX2THELY.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -129,6 +129,7 @@ init_esbuild_shims();
 // packages/core/src/agents/runtime/workflow-orchestrator.ts
 init_esbuild_shims();
 import { randomBytes } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as os from "node:os";
 
 // packages/core/src/agents/runtime/workflow-sandbox.ts
@@ -407,22 +408,27 @@ __name(validateArgs, "validateArgs");
 function createWorkflowSandbox(opts) {
   const phases = [];
   const logs = [];
-  const safeLog = /* @__PURE__ */ __name((msg) => {
+  const emitLog = /* @__PURE__ */ __name((line) => {
+    try {
+      opts.emitter?.logAppended?.(line);
+    } catch (e) {
+      debugLogger.warn("emitter.logAppended threw:", e);
+    }
+  }, "emitLog");
+  const safeLog = /* @__PURE__ */ __name((msg, notify = true) => {
     if (logs.length < MAX_LOG_LINES) {
       const line = String(msg);
       logs.push(line);
-      try {
-        opts.emitter?.logAppended?.(line);
-      } catch (e) {
-        debugLogger.warn("emitter.logAppended threw:", e);
-      }
+      if (notify) emitLog(line);
     } else if (logs.length === MAX_LOG_LINES) {
-      logs.push(`[workflow log truncated at ${MAX_LOG_LINES} lines]`);
+      const line = `[workflow log truncated at ${MAX_LOG_LINES} lines]`;
+      logs.push(line);
+      if (notify) emitLog(line);
     }
   }, "safeLog");
   const safePhase = /* @__PURE__ */ __name((title) => {
     if (phases.length < MAX_PHASE_ENTRIES) {
-      const t = String(title);
+      const t = stripAnsiAndControl(String(title)).slice(0, 200) || "phase";
       if (phases[phases.length - 1] === t) return;
       phases.push(t);
       try {
@@ -1327,7 +1333,7 @@ ${stripped}
     },
     getPhases: /* @__PURE__ */ __name(() => [...phases], "getPhases"),
     getLogs: /* @__PURE__ */ __name(() => [...logs], "getLogs"),
-    appendLog: /* @__PURE__ */ __name((line) => safeLog(line), "appendLog"),
+    appendLog: /* @__PURE__ */ __name((line) => safeLog(line, false), "appendLog"),
     getMeta: /* @__PURE__ */ __name(() => extractedMeta, "getMeta")
   };
 }
@@ -1634,6 +1640,7 @@ var WorkflowJournal = class {
   static {
     __name(this, "WorkflowJournal");
   }
+  pending = Promise.resolve();
   /** Load + parse all entries into replay maps. Empty maps if no file. */
   async load() {
     try {
@@ -1646,7 +1653,13 @@ var WorkflowJournal = class {
   }
   /** Append one entry. Rejects only on I/O error (callers `.catch`). */
   append(entry) {
-    return writeLine(this.path, entry);
+    const operation = this.pending.then(() => writeLine(this.path, entry));
+    this.pending = operation.catch(() => void 0);
+    return operation;
+  }
+  /** Wait until every append issued so far has settled. */
+  drain() {
+    return this.pending;
   }
 };
 
@@ -1896,7 +1909,7 @@ function sanitizeForErrorMessage(value) {
 }
 __name(sanitizeForErrorMessage, "sanitizeForErrorMessage");
 function createProductionDispatch(config, signal, onTokens, bridgeApprovalEvents) {
-  return async (prompt, opts) => {
+  return async (prompt, opts, dispatchId) => {
     if (typeof prompt !== "string" || prompt.length === 0) {
       throw new Error("agent() requires a non-empty string prompt.");
     }
@@ -1909,7 +1922,10 @@ function createProductionDispatch(config, signal, onTokens, bridgeApprovalEvents
     return runStallResilient(
       async (attemptSignal, emitter) => {
         attempt += 1;
-        const cleanupApprovalBridge = bridgeApprovalEvents?.(emitter);
+        const cleanupApprovalBridge = bridgeApprovalEvents?.(
+          emitter,
+          dispatchId
+        );
         const cleanupTranscript = attachDispatchTranscript(
           config,
           workflowAgentId,
@@ -1984,7 +2000,7 @@ function attachDispatchTranscript(config, agentId, prompt, agentName, emitter, a
 }
 __name(attachDispatchTranscript, "attachDispatchTranscript");
 async function runSingleDispatch(config, prompt, opts, attemptSignal, emitter, workflowAgentId, agentIdentity, onTokens) {
-  const { AgentHeadless, ContextState } = await import("./agent-headless-UT2ZF76T.js");
+  const { AgentHeadless, ContextState } = await import("./agent-headless-4BF7W4TJ.js");
   const ctx = new ContextState();
   ctx.set("task_prompt", prompt);
   debugLogger.debug(`[workflow] Dispatch ${workflowAgentId}`);
@@ -2457,8 +2473,29 @@ var WorkflowOrchestrator = class {
       }
     ), "rejectThroughPauseGate");
     let agentCount = 0;
+    let dispatchTraceCount = 0;
     const emitter = req.emitter;
     const budget = req.budget;
+    const dependencyContext = new AsyncLocalStorage();
+    const issueDispatchTrace = /* @__PURE__ */ __name((prompt, opts, cached = false) => {
+      const id = `dispatch-${dispatchTraceCount += 1}`;
+      const store = dependencyContext.getStore();
+      const dependsOn = Array.from(new Set(store?.tails ?? []));
+      if (store) store.tails = [id];
+      try {
+        emitter?.dispatchQueued?.({
+          id,
+          ...typeof opts.label === "string" ? { label: opts.label } : {},
+          prompt,
+          dependsOn,
+          queuedAt: Date.now(),
+          ...cached ? { cached: true } : {}
+        });
+      } catch (e) {
+        debugLogger.warn("emitter.dispatchQueued threw:", e);
+      }
+      return id;
+    }, "issueDispatchTrace");
     const journal = req.journal;
     const replay = req.resumeReplay;
     let prefixHash = deriveArgsSeed(req.args);
@@ -2485,6 +2522,7 @@ var WorkflowOrchestrator = class {
               );
             }
             const label2 = typeof opts.label === "string" ? opts.label : void 0;
+            const dispatchId2 = issueDispatchTrace(prompt, opts, true);
             try {
               emitter?.agentDispatched?.(label2);
             } catch (e) {
@@ -2495,6 +2533,11 @@ var WorkflowOrchestrator = class {
             } catch (e) {
               debugLogger.warn("emitter.agentCompleted threw:", e);
             }
+            try {
+              emitter?.dispatchSettled?.(dispatchId2, void 0, Date.now());
+            } catch (e) {
+              debugLogger.warn("emitter.dispatchSettled threw:", e);
+            }
             return scheduler.waitUntilRunning().then(
               () => cached.result,
               () => cached.result
@@ -2524,6 +2567,7 @@ var WorkflowOrchestrator = class {
         );
       }
       const label = typeof opts.label === "string" ? opts.label : void 0;
+      const dispatchId = issueDispatchTrace(prompt, opts);
       try {
         emitter?.agentDispatched?.(label);
       } catch (e) {
@@ -2539,9 +2583,19 @@ var WorkflowOrchestrator = class {
         } catch (e) {
           debugLogger.warn("emitter.agentCompleted threw:", e);
         }
+        try {
+          emitter?.dispatchSettled?.(dispatchId, message, Date.now());
+        } catch (e) {
+          debugLogger.warn("emitter.dispatchSettled threw:", e);
+        }
       }, "emitCompletion");
       return scheduler.run(async () => {
         try {
+          try {
+            emitter?.dispatchStarted?.(dispatchId, Date.now());
+          } catch (e) {
+            debugLogger.warn("emitter.dispatchStarted threw:", e);
+          }
           if (budget && budget.total !== null && budget.remaining() <= 0) {
             debugLogger.warn(
               `[Workflow] budget gate refused dispatch at slot-acquire: runId=${runId} spent=${budget.spent()} total=${budget.total}`
@@ -2552,7 +2606,7 @@ var WorkflowOrchestrator = class {
               budget.spent()
             );
           }
-          const result = await this.dispatch(prompt, opts);
+          const result = await this.dispatch(prompt, opts, dispatchId);
           emitCompletion();
           if (journal && journalKey !== void 0) {
             journal.append({
@@ -2606,8 +2660,8 @@ var WorkflowOrchestrator = class {
         }
       );
     }, "countedDispatch");
-    const parallelImpl = makeParallelImpl(signal);
-    const pipelineImpl = makePipelineImpl(signal);
+    const parallelImpl = makeParallelImpl(signal, dependencyContext);
+    const pipelineImpl = makePipelineImpl(signal, dependencyContext);
     const resolveSavedWorkflow = req.resolveSavedWorkflow;
     const parentSandboxRef = {
       current: void 0
@@ -2648,7 +2702,10 @@ var WorkflowOrchestrator = class {
     });
     parentSandboxRef.current = sandbox;
     try {
-      const result = await sandbox.run(req.script);
+      const result = await dependencyContext.run(
+        { tails: [] },
+        () => sandbox.run(req.script)
+      );
       return {
         runId,
         result,
@@ -2693,7 +2750,7 @@ async function settleToNullArray(thunks, signal, kind = "parallel") {
   return result;
 }
 __name(settleToNullArray, "settleToNullArray");
-function makeParallelImpl(signal) {
+function makeParallelImpl(signal, dependencyContext) {
   return (thunks) => {
     if (!Array.isArray(thunks)) {
       return Promise.reject(
@@ -2711,11 +2768,32 @@ function makeParallelImpl(signal) {
         );
       }
     }
-    return settleToNullArray(thunks, signal);
+    const parent = dependencyContext.getStore();
+    const inheritedTails = parent?.tails ?? [];
+    const branches = thunks.map((thunk) => {
+      const store = { tails: [...inheritedTails] };
+      return {
+        store,
+        thunk: /* @__PURE__ */ __name(() => dependencyContext.run(store, thunk), "thunk")
+      };
+    });
+    return settleToNullArray(
+      branches.map(({ thunk }) => thunk),
+      signal
+    ).then((result) => {
+      if (parent && branches.length > 0) {
+        parent.tails = mergeFanoutTails(
+          parent.tails,
+          inheritedTails,
+          branches.flatMap(({ store }) => store.tails)
+        );
+      }
+      return result;
+    });
   };
 }
 __name(makeParallelImpl, "makeParallelImpl");
-function makePipelineImpl(signal) {
+function makePipelineImpl(signal, dependencyContext) {
   return (items, ...stages) => {
     if (!Array.isArray(items)) {
       return Promise.reject(
@@ -2733,13 +2811,45 @@ function makePipelineImpl(signal) {
         );
       }
     }
-    const chains = items.map(
-      (item, idx) => () => runPipelineChain(item, idx, stages)
-    );
-    return settleToNullArray(chains, signal, "pipeline");
+    const parent = dependencyContext.getStore();
+    const inheritedTails = parent?.tails ?? [];
+    const branches = items.map((item, idx) => {
+      const store = { tails: [...inheritedTails] };
+      return {
+        store,
+        thunk: /* @__PURE__ */ __name(() => dependencyContext.run(
+          store,
+          () => runPipelineChain(item, idx, stages)
+        ), "thunk")
+      };
+    });
+    return settleToNullArray(
+      branches.map(({ thunk }) => thunk),
+      signal,
+      "pipeline"
+    ).then((result) => {
+      if (parent && branches.length > 0) {
+        parent.tails = mergeFanoutTails(
+          parent.tails,
+          inheritedTails,
+          branches.flatMap(({ store }) => store.tails)
+        );
+      }
+      return result;
+    });
   };
 }
 __name(makePipelineImpl, "makePipelineImpl");
+function mergeFanoutTails(currentParentTails, inheritedTails, branchTails) {
+  const inherited = new Set(inheritedTails);
+  const newBranchTails = branchTails.filter((tail) => !inherited.has(tail));
+  const merged = newBranchTails.length > 0 ? [
+    ...newBranchTails,
+    ...currentParentTails.filter((tail) => !inherited.has(tail))
+  ] : currentParentTails;
+  return Array.from(new Set(merged));
+}
+__name(mergeFanoutTails, "mergeFanoutTails");
 async function runPipelineChain(item, idx, stages) {
   let prev = item;
   for (const stage of stages) {
@@ -2807,19 +2917,26 @@ var WorkflowRunner = class {
       throw new Error("Background workflow start was cancelled.");
     }
     const callerWasAbortedBeforeStart = options.signal.aborted;
-    const controller = runInBackground ? createAbortController() : createChildAbortController(options.signal);
     const registry = config.getWorkflowRunRegistry?.();
+    let entry;
+    const isCurrentEntry = /* @__PURE__ */ __name(() => registry === void 0 || entry !== void 0 && registry.get(runId) === entry, "isCurrentEntry");
+    const controller = runInBackground ? createAbortController() : createChildAbortController(options.signal);
     const dispatch = options.dispatch ?? createProductionDispatch(
       config,
       controller.signal,
       (outputTokens) => budget.recordSpent(outputTokens),
-      registry ? (emitter2) => registry.bridgeApprovalEvents(runId, emitter2) : void 0
+      registry ? (emitter2, dispatchId) => isCurrentEntry() ? registry.bridgeApprovalEvents(
+        runId,
+        emitter2,
+        dispatchId,
+        entry
+      ) : () => void 0 : void 0
     );
     const orchestrator = new WorkflowOrchestrator(dispatch);
-    let entry;
     try {
       entry = registry?.register({
         runId,
+        toolUseId: options.toolUseId,
         meta: null,
         status: "running",
         startTime: Date.now(),
@@ -2828,6 +2945,11 @@ var WorkflowRunner = class {
         tokenBudgetTotal: budget.total,
         script,
         scriptPath,
+        args: options.args,
+        ...options.resumeFromRunId ? {
+          sourceRunId: options.resumeFromRunId,
+          startMode: "retry"
+        } : {},
         isBackgrounded: runInBackground
       });
     } catch (error) {
@@ -2835,7 +2957,7 @@ var WorkflowRunner = class {
       throw error;
     }
     const emitUpdate = /* @__PURE__ */ __name(() => {
-      if (!entry || !options.onUpdate) return;
+      if (!entry || !options.onUpdate || !isCurrentEntry()) return;
       try {
         options.onUpdate(entry);
       } catch {
@@ -2843,21 +2965,48 @@ var WorkflowRunner = class {
     }, "emitUpdate");
     const emitter = {
       phaseStarted: /* @__PURE__ */ __name((title) => {
+        if (!isCurrentEntry()) return;
         registry?.onPhaseStarted(runId, title);
         emitUpdate();
       }, "phaseStarted"),
       agentDispatched: /* @__PURE__ */ __name(() => {
+        if (!isCurrentEntry()) return;
         registry?.onAgentDispatched(runId);
         emitUpdate();
       }, "agentDispatched"),
       agentCompleted: /* @__PURE__ */ __name(() => {
+        if (!isCurrentEntry()) return;
         registry?.onAgentCompleted(runId);
       }, "agentCompleted"),
-      // Deliberate no-op: logs are snapshotted at terminal via
-      // setRecentLogs; per-line emit would cause up to 10k TUI redraws.
-      logAppended: /* @__PURE__ */ __name(() => {
+      dispatchQueued: /* @__PURE__ */ __name((event) => {
+        if (!isCurrentEntry()) return;
+        registry?.onDispatchQueued(runId, event);
+        emitUpdate();
+      }, "dispatchQueued"),
+      dispatchStarted: /* @__PURE__ */ __name((dispatchId, startedAt) => {
+        if (!isCurrentEntry()) return;
+        registry?.onDispatchStarted(runId, dispatchId, startedAt);
+        emitUpdate();
+      }, "dispatchStarted"),
+      dispatchSettled: /* @__PURE__ */ __name((dispatchId, error, endedAt) => {
+        if (!isCurrentEntry()) return;
+        registry?.onDispatchSettled(
+          runId,
+          dispatchId,
+          error,
+          endedAt,
+          !runInBackground && options.signal.aborted
+        );
+        emitUpdate();
+      }, "dispatchSettled"),
+      // The registry records this without firing a status update, avoiding a
+      // TUI redraw per line while retaining the real replay timestamp.
+      logAppended: /* @__PURE__ */ __name((line) => {
+        if (!isCurrentEntry()) return;
+        registry?.onLogAppended(runId, line);
       }, "logAppended"),
       budgetUpdated: /* @__PURE__ */ __name((spent, total) => {
+        if (!isCurrentEntry()) return;
         registry?.onBudgetUpdated(runId, spent, total);
         emitUpdate();
       }, "budgetUpdated")
@@ -2865,7 +3014,10 @@ var WorkflowRunner = class {
     const scheduler = new WorkflowDispatchScheduler(
       resolveConcurrencyLimit(),
       controller.signal,
-      ({ state }) => registry?.onDispatchStateChange(runId, state)
+      ({ state }) => {
+        if (!isCurrentEntry()) return;
+        registry?.onDispatchStateChange(runId, state);
+      }
     );
     const handle = new WorkflowRunHandle(
       runId,
@@ -2925,6 +3077,7 @@ var WorkflowRunner = class {
               duration_ms: (entry.endTime ?? entry.startTime) - entry.startTime
             });
             await writeWorkflowSnapshot(config, entry);
+            await journal?.drain();
             try {
               logWorkflowRun(config, telemetryEvent);
             } catch {
@@ -2988,6 +3141,10 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
   static {
     __name(this, "WorkflowToolInvocation");
   }
+  callId;
+  setCallId(callId) {
+    this.callId = callId;
+  }
   getDescription() {
     if (this.params.scriptPath && this.params.script === void 0) {
       return `Run saved workflow (${path.basename(this.params.scriptPath)})`;
@@ -3010,6 +3167,7 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
       handle = await WorkflowRunner.start({
         config: this.config,
         signal,
+        toolUseId: this.callId,
         script: this.params.script,
         scriptPath: this.params.scriptPath,
         args: this.params.args,
@@ -3032,6 +3190,7 @@ var WorkflowToolInvocation = class extends BaseToolInvocation {
         handle.budget.total
       );
       return {
+        workflowRunId: handle.runId,
         llmContent: [
           {
             text: `Workflow started in background.