@ai-setting/roy-agent-core 1.5.44 → 1.5.45

package/dist/shared/@ai-setting/{roy-agent-core-38dkek2y.js → roy-agent-core-nn9dmffw.js}

@@ -1,7 +1,13 @@
+import {
+  buildWorkflowNodeMetadata,
+  getWorkflowNodeIdFromMetadata,
+  init_workflow_message_metadata,
+  patchAgentSessionIdOnMessage
+} from "./roy-agent-core-6atd905e.js";
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-69jskqjg.js";
+} from "./roy-agent-core-44g4dhzg.js";
 import {
   SkillNode,
   ToolNode,
@@ -10,6 +16,14 @@ import {
   init_tool_node,
   init_workflow_node
 } from "./roy-agent-core-6vxg2gmr.js";
+import {
+  WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME,
+  init_json_schema_to_zod,
+  init_submit_json_output_tool,
+  jsonSchemaToZod,
+  parseWorkflowJsonOutput,
+  validateJsonOutputSchema
+} from "./roy-agent-core-nhfy3p8q.js";
 import {
   TemplateResolver,
   init_template_resolver
@@ -754,6 +768,7 @@ var init_executor = __esm(() => {
   init_event();
   init_types();
   init_decorator();
+  init_workflow_message_metadata();
   Executor = class Executor {
     nodeRegistry;
     eventBus;
@@ -946,15 +961,33 @@ var init_executor = __esm(() => {
         role: "workflow.node.start",
         content: contentSummary,
         parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.start",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
+        metadata: buildWorkflowNodeMetadata("workflow.node.start", nodeId, nodeType, {
           ...agentSessionId ? { agentSessionId } : {}
-        }
+        })
       });
     }
+    async attachAgentSessionToLastStart(sessionId, nodeId, agentSessionId) {
+      if (!this.sessionComponent?.getMessages || !this.sessionComponent.updateMessage) {
+        return;
+      }
+      const messages = await this.sessionComponent.getMessages(sessionId);
+      for (let i = messages.length - 1;i >= 0; i--) {
+        const msg = messages[i];
+        const meta = msg.metadata;
+        if (meta?.type !== "workflow.node.start") {
+          continue;
+        }
+        if (getWorkflowNodeIdFromMetadata(meta) !== nodeId) {
+          continue;
+        }
+        if (meta.agentSessionId) {
+          return;
+        }
+        const patched = patchAgentSessionIdOnMessage(meta, msg.parts, agentSessionId);
+        await this.sessionComponent.updateMessage(sessionId, msg.id, patched);
+        return;
+      }
+    }
     summarizeCall(nodeType, nodeId, input) {
       if (input === undefined || input === null) {
         return `[${nodeType}] ${nodeId} started`;
@@ -986,14 +1019,11 @@ var init_executor = __esm(() => {
         role: "workflow.node.interrupt",
         content: query,
         parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.interrupt",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
+        metadata: buildWorkflowNodeMetadata("workflow.node.interrupt", nodeId, nodeType, {
           query,
-          agentSessionId
-        }
+          ...agentSessionId ? { agentSessionId } : {},
+          timestamp
+        })
       });
     }
     async writeNodeEnd(sessionId, nodeId, nodeType, output, error, durationMs, agentSessionId) {
@@ -1013,14 +1043,10 @@ var init_executor = __esm(() => {
         role: "workflow.node.end",
         content: contentSummary,
         parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.end",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
+        metadata: buildWorkflowNodeMetadata("workflow.node.end", nodeId, nodeType, {
           success: !error,
           ...agentSessionId ? { agentSessionId } : {}
-        }
+        })
       });
     }
     summarizeResult(nodeId, output, error, durationMs) {
@@ -1042,7 +1068,7 @@ var init_executor = __esm(() => {
       const truncated = strOutput.length > 100 ? strOutput.substring(0, 100) + "..." : strOutput;
       return `✅ ${nodeId}: ${truncated} (${durationMs}ms)`;
     }
-    async writeNodeResume(sessionId, nodeId, response, agentSessionId) {
+    async writeNodeResume(sessionId, nodeId, nodeType, response, agentSessionId) {
       if (!this.sessionComponent)
         return;
       const timestamp = Date.now();
@@ -1057,12 +1083,11 @@ var init_executor = __esm(() => {
         role: "workflow.node.resume",
         content: response,
         parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.resume",
-          workflowNodeId: nodeId,
-          ...agentSessionId ? { agentSessionId } : {}
-        }
+        metadata: buildWorkflowNodeMetadata("workflow.node.resume", nodeId, nodeType, {
+          response,
+          ...agentSessionId ? { agentSessionId } : {},
+          timestamp
+        })
       });
     }
   };
@@ -1072,6 +1097,9 @@ var init_executor = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.executor.writeNodeStart", { recordParams: true, recordResult: true, log: true })
   ], Executor.prototype, "writeNodeStart", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.executor.attachAgentSessionToLastStart", { log: true })
+  ], Executor.prototype, "attachAgentSessionToLastStart", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.executor.writeNodeInterrupt", { recordParams: true, recordResult: true, log: true })
   ], Executor.prototype, "writeNodeInterrupt", null);
@@ -1083,11 +1111,139 @@ var init_executor = __esm(() => {
   ], Executor.prototype, "writeNodeResume", null);
 });
 
+// src/env/workflow/utils/parse-agent-output-config.ts
+function parseAgentOutputConfig(config) {
+  const output = config.output;
+  if (!output) {
+    return { mode: "string" };
+  }
+  const mode = output.mode === "json" ? "json" : "string";
+  if (mode === "json") {
+    if (output.schema === undefined) {
+      throw new Error("AgentNode output.mode=json requires output.schema");
+    }
+    const schema = validateJsonOutputSchema(output.schema);
+    return { mode, schema };
+  }
+  return { mode: "string" };
+}
+var init_parse_agent_output_config = __esm(() => {
+  init_json_schema_to_zod();
+});
+
+// src/env/workflow/utils/extract-agent-json-output.ts
+function extractAgentJsonOutput(agentResult, schema) {
+  const candidates = [
+    agentResult.structuredOutput,
+    asRecord(agentResult.output),
+    extractFromToolCalls(agentResult),
+    extractFromMessages(agentResult.messages)
+  ];
+  for (const candidate of candidates) {
+    const validated = validateAgainstSchema(candidate, schema);
+    if (validated) {
+      return validated;
+    }
+  }
+  return;
+}
+function asRecord(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return;
+}
+function extractFromToolCalls(agentResult) {
+  const toolCalls = agentResult.metadata?.toolCallsDetail;
+  if (!toolCalls?.length) {
+    return;
+  }
+  for (let i = toolCalls.length - 1;i >= 0; i--) {
+    const tc = toolCalls[i];
+    if (tc.name === WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME && tc.arguments) {
+      return tc.arguments;
+    }
+  }
+  return;
+}
+function extractFromMessages(messages) {
+  if (!messages?.length) {
+    return;
+  }
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.toolName !== WORKFLOW_SUBMIT_OUTPUT_TOOL_NAME || !msg.content) {
+      continue;
+    }
+    const fromMarker = parseWorkflowJsonOutput(msg.content);
+    if (fromMarker) {
+      return fromMarker;
+    }
+    try {
+      const parsed = JSON.parse(msg.content);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {}
+  }
+  return;
+}
+function validateAgainstSchema(data, schema) {
+  if (!data) {
+    return;
+  }
+  if (!schema) {
+    return data;
+  }
+  try {
+    return jsonSchemaToZod(schema).parse(data);
+  } catch {
+    return;
+  }
+}
+var init_extract_agent_json_output = __esm(() => {
+  init_submit_json_output_tool();
+  init_json_schema_to_zod();
+});
+
+// src/env/workflow/utils/build-agent-node-output.ts
+function buildAgentNodeOutput(agentResult, outputConfig) {
+  const base = {
+    metadata: agentResult.metadata,
+    workflowHistory: agentResult.messages
+  };
+  if (outputConfig.mode === "json") {
+    const schema = outputConfig.schema;
+    const jsonData = extractAgentJsonOutput(agentResult, schema);
+    if (!jsonData) {
+      throw new Error("AgentNode json output mode requires structured JSON from workflow_submit_output");
+    }
+    return {
+      result: jsonData,
+      ...jsonData,
+      metadata: {
+        ...agentResult.metadata,
+        outputMode: "json"
+      },
+      workflowHistory: agentResult.messages
+    };
+  }
+  return {
+    result: agentResult.output,
+    ...base
+  };
+}
+var init_build_agent_node_output = __esm(() => {
+  init_extract_agent_json_output();
+});
+
 // src/env/workflow/nodes/agent-node.ts
 var AgentNode;
 var init_agent_node = __esm(() => {
   init_workflow_hil();
   init_decorator();
+  init_parse_agent_output_config();
+  init_build_agent_node_output();
   AgentNode = class AgentNode {
     definition;
     agentRunner;
@@ -1104,6 +1260,7 @@ var init_agent_node = __esm(() => {
         const config = context.resolvedConfig ?? this.definition.config ?? {};
         const agentType = config.agent_type || "general";
         const options = config.options || {};
+        const outputConfig = parseAgentOutputConfig(config);
         let resolvedPrompt;
         if (context.resolvedConfig && context.templateResolver) {
           resolvedPrompt = config.prompt || "";
@@ -1120,19 +1277,30 @@ var init_agent_node = __esm(() => {
             });
           }
         }
-        const userQuery = context.input?.userQuery;
+        const userQuery = context.input?.userQuery ?? context.workflowInput?.userQuery;
         let agentSessionId = context.agentSessionId;
+        if (!agentSessionId && context.sessionComponent) {
+          agentSessionId = await this.resolveAgentSessionIdFromWorkflow(context);
+          if (agentSessionId) {
+            context.agentSessionId = agentSessionId;
+          }
+        }
         if (!agentSessionId && context.sessionComponent) {
           agentSessionId = await this.createAgentSubSession(context);
           context.agentSessionId = agentSessionId;
+          if (context.attachAgentSessionToLastStart) {
+            await context.attachAgentSessionToLastStart(this.definition.id, agentSessionId);
+          }
         }
+        const allowedTools = ["ask_user"];
         const agentConfig = {
           type: agentType,
           prompt: resolvedPrompt,
           options: {
             timeout: options.timeout,
             model: options.model,
-            allowedTools: ["ask_user"]
+            allowedTools,
+            outputSchema: outputConfig.schema
           },
           workflowHistory: context.workflowHistory,
           nodeId: this.definition.id,
@@ -1145,11 +1313,7 @@ var init_agent_node = __esm(() => {
         const result = await this.agentRunner.run(agentConfig, resumeOptions);
         const duration = Date.now() - startTime;
         return {
-          output: {
-            result: result.output,
-            metadata: result.metadata,
-            workflowHistory: result.messages
-          },
+          output: buildAgentNodeOutput(result, outputConfig),
           error: undefined,
           duration
         };
@@ -1170,6 +1334,18 @@ var init_agent_node = __esm(() => {
         };
       }
     }
+    async resolveAgentSessionIdFromWorkflow(context) {
+      const sessionComponent = context.sessionComponent;
+      if (!sessionComponent) {
+        return;
+      }
+      const workflowSession = await sessionComponent.get(context.sessionId);
+      const agentSessions = workflowSession?.metadata?.agentSessions;
+      if (!agentSessions?.length) {
+        return;
+      }
+      return agentSessions.find((ref) => ref.nodeId === this.definition.id)?.sessionId;
+    }
     async createAgentSubSession(context) {
       const sessionComponent = context.sessionComponent;
       if (!sessionComponent) {
@@ -1266,7 +1442,8 @@ class NodeRegistry {
       agentComponent,
       agentRunner,
       workflowRunner,
-      sessionComponent
+      sessionComponent,
+      llmComponent
     } = options ?? {};
     this.toolRegistry = toolRegistry;
     this.skillRegistry = skillRegistry;
@@ -1277,8 +1454,11 @@ class NodeRegistry {
       if (agentRunner.setSessionComponent && sessionComponent) {
         agentRunner.setSessionComponent(sessionComponent);
       }
+      if (llmComponent && "setLLMComponent" in agentRunner && typeof agentRunner.setLLMComponent === "function") {
+        agentRunner.setLLMComponent(llmComponent);
+      }
     } else if (agentComponent) {
-      this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent);
+      this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent, llmComponent);
       this.agentRunner = this.agentComponentAdapter;
     }
     this.registerBuiltInTypes();
@@ -1348,6 +1528,21 @@ var init_node_registry = __esm(() => {
   init_ask_user_node();
 });
 
+// src/env/workflow/utils/agent-session-metadata.ts
+function updateAgentSessionStatus(agentSessions, nodeId, status) {
+  if (!agentSessions?.length) {
+    return agentSessions ?? [];
+  }
+  return agentSessions.map((ref) => ref.nodeId === nodeId ? { ...ref, status } : ref);
+}
+function markAllAgentSessionsCompleted(agentSessions) {
+  if (!agentSessions?.length) {
+    return agentSessions ?? [];
+  }
+  return agentSessions.map((ref) => ref.status === "active" || ref.status === "paused" ? { ...ref, status: "completed" } : ref);
+}
+var init_agent_session_metadata = () => {};
+
 // src/env/workflow/engine/engine.ts
 import { EventEmitter } from "events";
 var logger2, WorkflowEngine;
@@ -1359,6 +1554,7 @@ var init_engine = __esm(() => {
   init_scheduler();
   init_executor();
   init_node_registry();
+  init_agent_session_metadata();
   init_logger();
   init_decorator();
   init_template_resolver();
@@ -1379,10 +1575,12 @@ var init_engine = __esm(() => {
     static async create(options) {
       const agentComponent = options.env?.getComponent("agent");
       const sessionComponent = options.sessionComponent;
+      const llmComponent = options.env?.getComponent("llm");
       const nodeRegistry = new NodeRegistry({
         toolRegistry: options.toolRegistry,
         skillRegistry: options.skillRegistry,
         agentComponent,
+        llmComponent,
         workflowRunner: options.workflowRunner,
         sessionComponent
       });
@@ -1410,6 +1608,8 @@ var init_engine = __esm(() => {
         workflowName,
         workflowVersion: definition.version,
         status: "running",
+        runId,
+        startedAt: Date.now(),
         input: options?.input,
         agentSessions: []
       };
@@ -1494,14 +1694,20 @@ var init_engine = __esm(() => {
         }
       }
       const messages = this.sessionComponent ? await this.sessionComponent.getMessages(sessionId) : [];
-      const { inferNextNode, extractResumeInfo } = await import("./roy-agent-core-23gw9c4s.js");
+      const {
+        inferNextNode,
+        extractResumeInfo,
+        enrichResumeInfoWithAgentSessions,
+        enrichResumePointWithAgentSessions
+      } = await import("./roy-agent-core-2vhsccvz.js");
       const entry = workflowDef.entry;
       const entryNode = Array.isArray(entry) ? entry[0] : entry;
-      const resumeInfo = extractResumeInfo(messages);
-      const resumePoint = inferNextNode(messages, {
+      const agentSessions = metadata.agentSessions ?? [];
+      const resumeInfo = enrichResumeInfoWithAgentSessions(extractResumeInfo(messages), agentSessions);
+      const resumePoint = enrichResumePointWithAgentSessions(inferNextNode(messages, {
         entryNode: entryNode !== "__default_entry__" ? entryNode : undefined,
         edges: undefined
-      });
+      }), agentSessions);
       const sessionState = await this.initializeSessionState(sessionId, workflowDef, workflowId, workflowName, options);
       this.activeSessions.set(sessionId, sessionState);
       return this.runWithResume(sessionId, resumePoint, resumeInfo, options);
@@ -1522,7 +1728,20 @@ var init_engine = __esm(() => {
         debug: options?.debug ?? definition.config?.debug ?? false
       };
       const executor = new Executor(this.nodeRegistry, eventBus, executorOptions, this.sessionComponent);
-      const workflowInput = options?.workflowInput ?? options?.input;
+      const rawRuntimeInput = options?.workflowInput ?? options?.input;
+      let persistedInput = {};
+      if (this.sessionComponent) {
+        const existingSession = await this.sessionComponent.get(sessionId);
+        const metaInput = existingSession?.metadata?.input;
+        if (metaInput) {
+          const { userQuery: _omit, ...rest } = metaInput;
+          persistedInput = rest;
+        }
+      }
+      const { stripEphemeralResumeInput } = await import("./roy-agent-core-2vhsccvz.js");
+      const { workflowInput: runtimeInput } = stripEphemeralResumeInput(rawRuntimeInput);
+      const mergedWorkflowInput = { ...persistedInput, ...runtimeInput };
+      const workflowInput = Object.keys(mergedWorkflowInput).length > 0 ? mergedWorkflowInput : undefined;
       const config = {
         parallelLimit,
         timeout: options?.timeout ?? definition.config?.timeout ?? null,
@@ -1698,15 +1917,22 @@ var init_engine = __esm(() => {
         sessionState.abortController.abort();
         if (this.sessionComponent) {
           const metadata = await this.getSessionMetadata(sessionId);
+          const agentSessions = updateAgentSessionStatus(metadata.agentSessions, event.node_id, "paused");
           await this.sessionComponent.update(sessionId, {
-            metadata: { ...metadata, status: "paused" }
+            metadata: {
+              ...metadata,
+              status: "paused",
+              pendingNodeId: event.node_id,
+              pauseReason: "ask_user",
+              agentSessions
+            }
           });
         }
         await eventBus.publish(createWorkflowEvent("workflow.paused", runId, {
           pendingNodeId: event.node_id,
           query: event.query
         }));
-        await this.writeNodeInterrupt(sessionId, event.node_id, event.node_type, event.query, event.agent_session_id);
+        await sessionState.executor.writeNodeInterrupt(sessionId, event.node_id, event.node_type, event.query, event.agent_session_id);
         sessionState.resolveCompleted({
           runId,
           status: "paused",
@@ -1716,29 +1942,15 @@ var init_engine = __esm(() => {
         });
       });
     }
-    async writeNodeInterrupt(sessionId, nodeId, nodeType, query, agentSessionId) {
-      if (this.sessionComponent) {
-        await this.sessionComponent.addMessage(sessionId, {
-          role: "workflow.node.interrupt",
-          content: query,
-          metadata: {
-            type: "workflow.node.interrupt",
-            workflowNodeId: nodeId,
-            workflowNodeType: nodeType,
-            query,
-            agentSessionId,
-            timestamp: Date.now()
-          }
-        });
-      }
-    }
     async scheduleAndExecute(sessionState, options) {
       const { scheduler, executor, eventBus, abortController, nodeOutputs } = sessionState;
       const { input: globalInput, pendingNodeId, agentSessionId, restoredOutputs } = options || {};
-      if (globalInput) {
+      const { stripEphemeralResumeInput } = await import("./roy-agent-core-2vhsccvz.js");
+      const { workflowInput: inputToPersist, userQuery: resumeUserQuery } = stripEphemeralResumeInput(globalInput);
+      if (inputToPersist) {
         sessionState.config.workflowInput = {
           ...sessionState.config.workflowInput || {},
-          ...globalInput
+          ...inputToPersist
         };
       }
       sessionState.loopIterationCount = 0;
@@ -1770,7 +1982,7 @@ var init_engine = __esm(() => {
       if (pendingNodeId) {
         await this.resumeNode(sessionState, pendingNodeId, {
           agentSessionId,
-          userQuery: globalInput?.userQuery
+          userQuery: resumeUserQuery
         });
       } else {
         await scheduleAvailableNodes();
@@ -1855,58 +2067,35 @@ var init_engine = __esm(() => {
         });
       }
     }
-    async writeNodeResume(sessionId, nodeId, userResponse) {
-      if (this.sessionComponent && userResponse) {
-        await this.sessionComponent.addMessage(sessionId, {
-          role: "workflow.node.resume",
-          content: JSON.stringify({ userResponse }),
-          metadata: {
-            type: "workflow.node.resume",
-            workflowNodeId: nodeId,
-            timestamp: Date.now()
-          }
-        });
-      }
-    }
     async resumeNode(sessionState, nodeId, options) {
       const { scheduler, executor, eventBus, dagManager } = sessionState;
       const sessionId = sessionState.sessionId;
       const runId = this.getRunIdFromSessionId(sessionId);
       scheduler.markStarted(nodeId);
-      await this.writeNodeResume(sessionId, nodeId, options?.userQuery);
-      await eventBus.publish(createWorkflowEvent("node.started", runId, {
-        node_id: nodeId,
-        agentSessionId: options?.agentSessionId,
-        userQuery: options?.userQuery
-      }));
       const nodeDef = dagManager.getNode(nodeId);
       if (!nodeDef) {
         scheduler.markFailed(nodeId);
         return;
       }
-      const context = this.buildNodeContext(sessionState, nodeId, {
-        ...sessionState.config.workflowInput || {},
-        ...options?.userQuery ? { userQuery: options.userQuery } : {}
-      });
-      if (options?.agentSessionId) {
-        context.agentSessionId = options.agentSessionId;
-      }
-      if (nodeDef.type === "agent" && options?.agentSessionId) {
-        const agentAdapter = this.nodeRegistry.getAgentAdapter?.();
-        if (agentAdapter?.resumeAgent) {
-          const agentConfig = {
-            type: nodeDef.config?.agent_type || "general",
-            prompt: nodeDef.config?.prompt || "",
-            nodeId,
-            runId,
-            workflowSessionId: sessionId
-          };
-          try {
-            await agentAdapter.resumeAgent(options.agentSessionId, options.userQuery || "", agentConfig);
-          } catch (error) {
-            console.error(`Failed to resume agent node ${nodeId}:`, error);
-          }
-        }
+      let agentSessionId = options?.agentSessionId;
+      if (!agentSessionId && this.sessionComponent) {
+        const session = await this.sessionComponent.get(sessionId);
+        const agentSessions = session?.metadata?.agentSessions;
+        const { resolveAgentSessionId } = await import("./roy-agent-core-2vhsccvz.js");
+        agentSessionId = resolveAgentSessionId(nodeId, undefined, agentSessions);
+      }
+      await sessionState.executor.writeNodeResume(sessionId, nodeId, nodeDef.type, options?.userQuery ?? "", agentSessionId);
+      await eventBus.publish(createWorkflowEvent("node.started", runId, {
+        node_id: nodeId,
+        agentSessionId,
+        userQuery: options?.userQuery
+      }));
+      const context = this.buildNodeContext(sessionState, nodeId, sessionState.config.workflowInput);
+      if (options?.userQuery !== undefined) {
+        context.input.userQuery = options.userQuery;
+      }
+      if (agentSessionId) {
+        context.agentSessionId = agentSessionId;
       }
       await this.validateAndExecute(nodeDef, context, sessionState);
     }
@@ -1990,7 +2179,17 @@ var init_engine = __esm(() => {
         }));
       }
       if (edgeResult.reEntries.length > 0) {
-        sessionState.loopIterationCount += edgeResult.reEntries.length;
+        if (sessionState.config.loopEnabled) {
+          const nextCount = sessionState.loopIterationCount + edgeResult.reEntries.length;
+          if (nextCount > sessionState.config.maxIterations) {
+            logger2.error(`[WorkflowEngine] Max loop iterations ${sessionState.config.maxIterations} exceeded (next=${nextCount})`);
+            await this.failWorkflow(sessionState, new WorkflowError(`Workflow exceeded maximum loop iterations: ${sessionState.config.maxIterations}`));
+            return;
+          }
+          sessionState.loopIterationCount = nextCount;
+        } else {
+          sessionState.loopIterationCount += edgeResult.reEntries.length;
+        }
         logger2.debug(`[WorkflowEngine] Loop iteration #${sessionState.loopIterationCount}: re-entering ${edgeResult.reEntries.join(", ")}`);
       }
       const workflowInput = sessionState.config.workflowInput || {};
@@ -2015,7 +2214,8 @@ var init_engine = __esm(() => {
           input[depId] = depOutput;
         }
       }
-      const workflowInput = globalInput ?? sessionState.config.workflowInput ?? {};
+      const rawWorkflowInput = globalInput ?? sessionState.config.workflowInput ?? {};
+      const { userQuery: _ephemeral, ...workflowInput } = rawWorkflowInput;
       const templateResolver = new TemplateResolver({
         input: workflowInput,
         previousOutputs: new Map(sessionState.nodeOutputs)
@@ -2037,6 +2237,9 @@ var init_engine = __esm(() => {
         workflowHistory: sessionState.workflowHistory,
         sessionComponent: this.sessionComponent,
         askUser,
+        attachAgentSessionToLastStart: async (targetNodeId, agentSessionId) => {
+          await sessionState.executor.attachAgentSessionToLastStart(sessionState.sessionId, targetNodeId, agentSessionId);
+        },
         workflowInput,
         templateResolver,
         resolvedConfig: templateResolver.resolveValue(nodeDef.config ?? {})
@@ -2068,7 +2271,16 @@ var init_engine = __esm(() => {
       if (this.sessionComponent) {
         const metadata = await this.getSessionMetadata(sessionId);
         await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "completed" }
+          metadata: {
+            ...metadata,
+            status: "completed",
+            completedAt: Date.now(),
+            durationMs,
+            output,
+            pendingNodeId: undefined,
+            pauseReason: undefined,
+            agentSessions: markAllAgentSessionsCompleted(metadata.agentSessions)
+          }
         });
       }
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.completed", runId, {
@@ -2095,7 +2307,12 @@ var init_engine = __esm(() => {
       if (this.sessionComponent) {
         const metadata = await this.getSessionMetadata(sessionId);
         await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "failed" }
+          metadata: {
+            ...metadata,
+            status: "failed",
+            failedAt: Date.now(),
+            durationMs
+          }
         });
       }
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.failed", runId, {
@@ -2168,9 +2385,6 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.stop", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "stop", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.writeNodeInterrupt", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "writeNodeInterrupt", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.scheduleAndExecute", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "scheduleAndExecute", null);
@@ -2183,9 +2397,6 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.writeNodeStart", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "writeNodeStart", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.writeNodeResume", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "writeNodeResume", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.resumeNode", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "resumeNode", null);