@ai-setting/roy-agent-core 1.5.5 → 1.5.6

package/dist/shared/@ai-setting/{roy-agent-core-kkp3qmc3.js → roy-agent-core-wrcy0h6z.js}

@@ -1,7 +1,7 @@
 import {
   AgentComponentAdapter,
   init_agent_component_adapter
-} from "./roy-agent-core-pc9g3962.js";
+} from "./roy-agent-core-69jskqjg.js";
 import {
   SkillNode,
   ToolNode,
@@ -9,12 +9,12 @@ import {
   init_skill_node,
   init_tool_node,
   init_workflow_node
-} from "./roy-agent-core-3agad0d9.js";
+} from "./roy-agent-core-jvatggbb.js";
 import {
   createWorkflowEvent,
   init_event,
   init_types
-} from "./roy-agent-core-rzp9kxne.js";
+} from "./roy-agent-core-5x94xmt6.js";
 import {
   AskUserError,
   createNodeInterruptEvent,
@@ -645,7 +645,7 @@ var init_executor = __esm(() => {
         node_id: nodeId,
         input: context.input
       }));
-      await this.writeNodeCall(context.sessionId, nodeId, nodeType, context.input, agentSessionId);
+      await this.writeNodeStart(context.sessionId, nodeId, nodeType, context.input, agentSessionId);
       const abortController = new AbortController;
       this.abortControllers.set(nodeId, abortController);
       const timeout = definition.timeout ?? this.options.globalTimeout ?? undefined;
@@ -673,14 +673,14 @@ var init_executor = __esm(() => {
               stack: errorStack
             }
           }));
-          await this.writeNodeResult(context.sessionId, nodeId, nodeType, result.output, errorMessage, result.durationMs ?? 0);
+          await this.writeNodeEnd(context.sessionId, nodeId, nodeType, result.output, errorMessage, result.durationMs ?? 0, agentSessionId);
         } else {
           await this.eventBus.publish(createWorkflowEvent("node.completed", context.runId, {
             node_id: nodeId,
             output: result.output,
             duration_ms: result.durationMs ?? 0
           }));
-          await this.writeNodeResult(context.sessionId, nodeId, nodeType, result.output, undefined, result.durationMs ?? 0);
+          await this.writeNodeEnd(context.sessionId, nodeId, nodeType, result.output, undefined, result.durationMs ?? 0, agentSessionId);
         }
         return result;
       } finally {
@@ -800,12 +800,12 @@ var init_executor = __esm(() => {
     sleep(ms) {
       return new Promise((resolve) => setTimeout(resolve, ms));
     }
-    async writeNodeCall(sessionId, nodeId, nodeType, input, agentSessionId) {
+    async writeNodeStart(sessionId, nodeId, nodeType, input, agentSessionId) {
       if (!this.sessionComponent)
         return;
       const startTime = Date.now();
       const part = {
-        type: "workflow-node-call",
+        type: "workflow-node-start",
         nodeId,
         nodeType,
         input,
@@ -814,12 +814,12 @@ var init_executor = __esm(() => {
       };
       const contentSummary = this.summarizeCall(nodeType, nodeId, input);
       await this.sessionComponent.addMessage(sessionId, {
-        role: "workflow.node.call",
+        role: "workflow.node.start",
         content: contentSummary,
         parts: [part],
         metadata: {
           _workflowNodeMetadata: true,
-          type: "workflow.node.call",
+          type: "workflow.node.start",
           workflowNodeId: nodeId,
           workflowNodeType: nodeType,
           ...agentSessionId ? { agentSessionId } : {}
@@ -831,11 +831,12 @@ var init_executor = __esm(() => {
         return `[${nodeType}] ${nodeId} started`;
       }
       if (typeof input === "object") {
-        const keys = Object.keys(input);
+        const inputObj = input;
+        const keys = Object.keys(inputObj);
         if (keys.length === 0) {
           return `[${nodeType}] ${nodeId} started`;
         }
-        const summary = keys.slice(0, 3).map((k) => `${k}: ${JSON.stringify(input[k])}`).join(", ");
+        const summary = keys.slice(0, 3).map((k) => `${k}: ${JSON.stringify(inputObj[k])}`).join(", ");
         return `[${nodeType}] ${nodeId}: ${summary}`;
       }
       return `[${nodeType}] ${nodeId}: ${String(input)}`;
@@ -866,28 +867,30 @@ var init_executor = __esm(() => {
         }
       });
     }
-    async writeNodeResult(sessionId, nodeId, nodeType, output, error, durationMs) {
+    async writeNodeEnd(sessionId, nodeId, nodeType, output, error, durationMs, agentSessionId) {
       if (!this.sessionComponent)
         return;
       const part = {
-        type: "workflow-node-result",
+        type: "workflow-node-end",
         nodeId,
         nodeType,
         output,
         error,
-        durationMs
+        durationMs,
+        ...agentSessionId ? { agentSessionId } : {}
       };
       const contentSummary = this.summarizeResult(nodeId, output, error, durationMs);
       await this.sessionComponent.addMessage(sessionId, {
-        role: "workflow.node.result",
+        role: "workflow.node.end",
         content: contentSummary,
         parts: [part],
         metadata: {
           _workflowNodeMetadata: true,
-          type: "workflow.node.result",
+          type: "workflow.node.end",
           workflowNodeId: nodeId,
           workflowNodeType: nodeType,
-          success: !error
+          success: !error,
+          ...agentSessionId ? { agentSessionId } : {}
         }
       });
     }
@@ -910,21 +913,26 @@ var init_executor = __esm(() => {
       const truncated = strOutput.length > 100 ? strOutput.substring(0, 100) + "..." : strOutput;
       return `✅ ${nodeId}: ${truncated} (${durationMs}ms)`;
     }
-    async writeNodeResume(sessionId, response) {
+    async writeNodeResume(sessionId, nodeId, response, agentSessionId) {
       if (!this.sessionComponent)
         return;
       const timestamp = Date.now();
       const part = {
         type: "workflow-node-resume",
+        nodeId,
         response,
-        timestamp
+        timestamp,
+        ...agentSessionId ? { agentSessionId } : {}
       };
       await this.sessionComponent.addMessage(sessionId, {
         role: "workflow.node.resume",
         content: response,
         parts: [part],
         metadata: {
-          _workflowNodeMetadata: true
+          _workflowNodeMetadata: true,
+          type: "workflow.node.resume",
+          workflowNodeId: nodeId,
+          ...agentSessionId ? { agentSessionId } : {}
         }
       });
     }
@@ -933,14 +941,14 @@ var init_executor = __esm(() => {
     TracedAs("workflow.executor.executeNode", { recordParams: true, recordResult: true, log: true })
   ], Executor.prototype, "executeNode", null);
   __legacyDecorateClassTS([
-    TracedAs("workflow.executor.writeNodeCall", { recordParams: true, recordResult: true, log: true })
-  ], Executor.prototype, "writeNodeCall", null);
+    TracedAs("workflow.executor.writeNodeStart", { recordParams: true, recordResult: true, log: true })
+  ], Executor.prototype, "writeNodeStart", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.executor.writeNodeInterrupt", { recordParams: true, recordResult: true, log: true })
   ], Executor.prototype, "writeNodeInterrupt", null);
   __legacyDecorateClassTS([
-    TracedAs("workflow.executor.writeNodeResult", { recordParams: true, recordResult: true, log: true })
-  ], Executor.prototype, "writeNodeResult", null);
+    TracedAs("workflow.executor.writeNodeEnd", { recordParams: true, recordResult: true, log: true })
+  ], Executor.prototype, "writeNodeEnd", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.executor.writeNodeResume", { recordParams: true, recordResult: true, log: true })
   ], Executor.prototype, "writeNodeResume", null);
@@ -978,9 +986,9 @@ var init_agent_node = __esm(() => {
             });
           }
         }
-        const userResponse = context.userResponse;
+        const userQuery = context.input?.userQuery;
         let agentSessionId = context.agentSessionId;
-        if (!userResponse && context.sessionComponent && !agentSessionId) {
+        if (!agentSessionId && context.sessionComponent) {
           agentSessionId = await this.createAgentSubSession(context);
           context.agentSessionId = agentSessionId;
         }
@@ -996,7 +1004,10 @@ var init_agent_node = __esm(() => {
           nodeId: this.definition.id,
           agentSessionId
         };
-        const resumeOptions = userResponse ? { userResponse, agentSessionId } : undefined;
+        const resumeOptions = {
+          userQuery,
+          agentSessionId
+        };
         const result = await this.agentRunner.run(agentConfig, resumeOptions);
         const duration = Date.now() - startTime;
         return {
@@ -1030,14 +1041,15 @@ var init_agent_node = __esm(() => {
       if (!sessionComponent) {
         return "";
       }
-      const agentSessionId = `agent_${this.definition.id}_${Date.now()}`;
+      const nodeId = this.definition.id || "unknown";
+      const agentSessionId = `agent_${nodeId}_${Date.now()}`;
       await sessionComponent.create({
         id: agentSessionId,
-        title: `Agent: ${this.definition.id}`,
+        title: `Agent: ${nodeId}`,
         metadata: {
           type: "agent",
           parentSessionId: context.sessionId,
-          nodeId: this.definition.id,
+          nodeId,
           workflowName: context.workflowName
         }
       });
@@ -1076,7 +1088,17 @@ var init_agent_node = __esm(() => {
       }
       let resolved = template;
       resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
-        const value = this.getNestedValue(context.input, path);
+        let value = this.getNestedValue(context.input, path);
+        if (value === undefined && context.workflowInput) {
+          value = this.getNestedValue(context.workflowInput, path);
+        }
+        return this.stringifyValue(value, match);
+      });
+      resolved = resolved.replace(/\{\{inputs\.([^}]+)\}\}/g, (match, path) => {
+        let value = this.getNestedValue(context.input, path);
+        if (value === undefined && context.workflowInput) {
+          value = this.getNestedValue(context.workflowInput, path);
+        }
         return this.stringifyValue(value, match);
       });
       resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
@@ -1430,7 +1452,9 @@ var init_engine = __esm(() => {
             workflowId,
             workflowName,
             workflowVersion: workflowDef.version,
-            status: "running"
+            status: "running",
+            input: options?.input,
+            agentSessions: []
           };
           await this.sessionComponent.create({
             id: sessionId,
@@ -1450,8 +1474,23 @@ var init_engine = __esm(() => {
       if (metadata.status === "failed") {
         return { runId: this.getRunIdFromSessionId(sessionId), status: "failed" };
       }
+      if (options?.input && this.sessionComponent) {
+        const hasNewInput = typeof options.input === "string" ? options.input !== undefined && options.input !== "" : Object.keys(options.input).length > 0;
+        if (hasNewInput) {
+          const existingInput = metadata.input || {};
+          const newInput = typeof options.input === "string" ? { userQuery: options.input } : options.input;
+          await this.sessionComponent.update(sessionId, {
+            metadata: {
+              ...metadata,
+              input: { ...existingInput, ...newInput }
+            }
+          });
+          metadata.input = { ...existingInput, ...newInput };
+          logger.info(`[WorkflowEngine] Updated session ${sessionId} input with resume user input`);
+        }
+      }
       const messages = this.sessionComponent ? await this.sessionComponent.getMessages(sessionId) : [];
-      const { inferNextNode } = await import("./roy-agent-core-qw0ebh1d.js");
+      const { inferNextNode } = await import("./roy-agent-core-gq20wsgv.js");
       const entry = workflowDef.entry;
       const entryNode = Array.isArray(entry) ? entry[0] : entry;
       const resumePoint = inferNextNode(messages, {
@@ -1535,12 +1574,16 @@ var init_engine = __esm(() => {
           agentSessionId = resumePoint.agentSessionId;
           break;
       }
-      const userResponse = typeof options?.input === "string" ? options.input : undefined;
+      let inputForExecution;
+      if (typeof options?.input === "string") {
+        inputForExecution = { userQuery: options.input };
+      } else if (options?.input && typeof options.input === "object") {
+        inputForExecution = options.input;
+      }
       this.scheduleAndExecute(sessionState, {
-        input: options?.input,
+        input: inputForExecution,
         pendingNodeId,
-        agentSessionId,
-        userResponse
+        agentSessionId
       }).catch((error) => {
         logger.error(`Workflow ${sessionId} scheduling error:`, error);
         this.failWorkflow(sessionState, error);
@@ -1579,117 +1622,6 @@ var init_engine = __esm(() => {
       await sessionState.eventBus.publish(createWorkflowEvent("workflow.paused", this.getRunIdFromSessionId(sessionId), {}));
       logger.info(`[WorkflowEngine] Workflow paused: ${sessionId}`);
     }
-    async resume(sessionId, options) {
-      const sessionState = this.activeSessions.get(sessionId);
-      if (!sessionState) {
-        logger.info(`[WorkflowEngine] Session not in memory, attempting to restore from DB: ${sessionId}`);
-        return this.resumeFromDatabase(sessionId, options);
-      }
-      if (options?.response) {
-        await this.writeNodeResume(sessionId, options.response);
-      }
-      if (sessionState.status === "running") {
-        return { runId: this.getRunIdFromSessionId(sessionId), status: "running" };
-      }
-      if (sessionState.status !== "paused") {
-        throw new Error(`Session ${sessionId} is not paused (current: ${sessionState.status})`);
-      }
-      sessionState.status = "running";
-      sessionState.abortController = new AbortController;
-      if (this.sessionComponent) {
-        const metadata = await this.getSessionMetadata(sessionId);
-        await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "running" }
-        });
-      }
-      await sessionState.eventBus.publish(createWorkflowEvent("workflow.resumed", this.getRunIdFromSessionId(sessionId), {
-        userResponse: options?.response
-      }));
-      const runtimeState = await this.restoreRuntimeState(sessionId);
-      this.scheduleAndExecute(sessionState, {
-        pendingNodeId: runtimeState.pendingNodeId || undefined,
-        agentSessionId: runtimeState.agentSessionId,
-        userResponse: options?.response,
-        restoredOutputs: runtimeState.nodeOutputs
-      });
-      return {
-        runId: this.getRunIdFromSessionId(sessionId),
-        status: "running"
-      };
-    }
-    async resumeFromDatabase(sessionId, options) {
-      const session = await this.sessionComponent?.get(sessionId);
-      if (!session) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const metadata = session.metadata;
-      if (metadata.type !== "workflow") {
-        throw new Error(`Session is not a workflow session: ${sessionId}`);
-      }
-      if (metadata.status !== "paused") {
-        throw new Error(`Workflow is not paused: ${sessionId}, status: ${metadata.status}`);
-      }
-      const runtimeState = await this.restoreRuntimeState(sessionId);
-      if (!runtimeState.pendingNodeId) {
-        throw new Error(`No pending node found in session: ${sessionId}`);
-      }
-      if (options?.response) {
-        await this.writeNodeResume(sessionId, options.response);
-      }
-      if (this.sessionComponent) {
-        await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "running" }
-        });
-      }
-      logger.info(`[WorkflowEngine] Resumed from database: ${sessionId}, pendingNode: ${runtimeState.pendingNodeId}`);
-      throw new Error(`Cannot resume from database without workflow definition. Session ${sessionId} is paused at node "${runtimeState.pendingNodeId}". Please ensure the workflow is registered before resuming.`);
-    }
-    async restoreRuntimeState(sessionId) {
-      const messages = this.sessionComponent ? await this.sessionComponent.getMessages(sessionId) : [];
-      const nodeOutputs = new Map;
-      let lastCallNodeId = null;
-      let lastInterruptMessage = null;
-      let agentSessionId;
-      for (const msg of messages) {
-        const msgMetadata = msg.metadata;
-        if (msgMetadata?.type === "workflow.node.call") {
-          lastCallNodeId = msgMetadata.workflowNodeId;
-        } else if (msgMetadata?.type === "workflow.node.result") {
-          if (lastCallNodeId) {
-            try {
-              nodeOutputs.set(lastCallNodeId, JSON.parse(msg.content));
-            } catch {
-              nodeOutputs.set(lastCallNodeId, msg.content);
-            }
-          }
-          lastCallNodeId = null;
-        } else if (msgMetadata?.type === "workflow.node.interrupt") {
-          lastInterruptMessage = msg;
-          lastCallNodeId = msgMetadata.workflowNodeId;
-          agentSessionId = msgMetadata.agentSessionId;
-        }
-      }
-      return {
-        nodeOutputs,
-        pendingNodeId: lastCallNodeId,
-        waitingForUser: !!lastInterruptMessage,
-        agentSessionId,
-        lastInterruptMessage
-      };
-    }
-    async writeNodeResume(sessionId, response) {
-      if (this.sessionComponent) {
-        await this.sessionComponent.addMessage(sessionId, {
-          role: "workflow.node.resume",
-          content: response,
-          metadata: {
-            type: "workflow.node.resume",
-            response,
-            timestamp: Date.now()
-          }
-        });
-      }
-    }
     async stop(sessionId, reason) {
       const sessionState = this.activeSessions.get(sessionId);
       if (!sessionState) {
@@ -1787,7 +1719,7 @@ var init_engine = __esm(() => {
     }
     async scheduleAndExecute(sessionState, options) {
       const { scheduler, executor, eventBus, abortController, nodeOutputs } = sessionState;
-      const { input: globalInput, pendingNodeId, agentSessionId, userResponse, restoredOutputs } = options || {};
+      const { input: globalInput, pendingNodeId, agentSessionId, restoredOutputs } = options || {};
       if (restoredOutputs) {
         for (const [nodeId, output] of restoredOutputs) {
           nodeOutputs.set(nodeId, output);
@@ -1815,7 +1747,7 @@ var init_engine = __esm(() => {
       if (pendingNodeId) {
         await this.resumeNode(sessionState, pendingNodeId, {
           agentSessionId,
-          userResponse
+          userQuery: globalInput?.userQuery
         });
       } else {
         await scheduleAvailableNodes();
@@ -1877,7 +1809,7 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
         return;
       }
-      await this.writeNodeCall(sessionId, nodeId, nodeDef.type, input);
+      await this.writeNodeStart(sessionId, nodeId, nodeDef.type, input);
       const context = this.createExecutionContext(sessionState, nodeId, input);
       executor.executeNode(nodeDef, context).catch(async (error) => {
         if (error instanceof AskUserError) {
@@ -1887,13 +1819,13 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
       });
     }
-    async writeNodeCall(sessionId, nodeId, nodeType, input) {
+    async writeNodeStart(sessionId, nodeId, nodeType, input) {
       if (this.sessionComponent) {
         await this.sessionComponent.addMessage(sessionId, {
-          role: "workflow.node.call",
+          role: "workflow.node.start",
           content: JSON.stringify({ input }),
           metadata: {
-            type: "workflow.node.call",
+            type: "workflow.node.start",
             workflowNodeId: nodeId,
             workflowNodeType: nodeType,
             timestamp: Date.now()
@@ -1901,25 +1833,55 @@ 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,
-        userResponse: options?.userResponse
+        userQuery: options?.userQuery
       }));
       const nodeDef = dagManager.getNode(nodeId);
       if (!nodeDef) {
         scheduler.markFailed(nodeId);
         return;
       }
-      const context = this.createExecutionContext(sessionState, nodeId, undefined);
-      if (options?.agentSessionId || options?.userResponse) {
+      const context = this.createExecutionContext(sessionState, nodeId, { userQuery: options?.userQuery }, true);
+      if (options?.agentSessionId) {
         context.agentSessionId = options.agentSessionId;
-        context.userResponse = options.userResponse;
+      }
+      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);
+          }
+        }
       }
       executor.executeNode(nodeDef, context).catch((error) => {
         if (error instanceof AskUserError) {
@@ -1930,7 +1892,7 @@ var init_engine = __esm(() => {
         scheduler.markFailed(nodeId);
       });
     }
-    createExecutionContext(sessionState, nodeId, globalInput) {
+    createExecutionContext(sessionState, nodeId, globalInput, forceGlobalInput) {
       const nodeDef = sessionState.dagManager.getNode(nodeId);
       const runId = this.getRunIdFromSessionId(sessionState.sessionId);
       const deps = nodeDef.depends_on || [];
@@ -1942,7 +1904,8 @@ var init_engine = __esm(() => {
         }
       }
       const analysis = sessionState.dagManager.analyze();
-      if (analysis.entryNodes.includes(nodeId) && globalInput) {
+      const isEntryNode = analysis.entryNodes.includes(nodeId);
+      if ((isEntryNode || forceGlobalInput) && globalInput) {
         Object.assign(input, globalInput);
       }
       const askUser = (query) => {
@@ -2069,48 +2032,37 @@ var init_engine = __esm(() => {
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.run", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "run", null);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.engine.runWithResume", { recordParams: true, recordResult: true, log: true })
+  ], WorkflowEngine.prototype, "runWithResume", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.runWorkflow", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "runWorkflow", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.pause", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "pause", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.resume", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "resume", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.resumeFromDatabase", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "resumeFromDatabase", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.restoreRuntimeState", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "restoreRuntimeState", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.writeNodeResume", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "writeNodeResume", null);
   __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 }),
     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 }),
     TracedAs("workflow.engine.scheduleAndExecute", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "scheduleAndExecute", null);
   __legacyDecorateClassTS([
     TracedAs("workflow.engine.waitForNextNodeEvent", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "waitForNextNodeEvent", null);
   __legacyDecorateClassTS([
-    TracedAs("workflow.engine.startNode", { recordParams: true, recordResult: true, log: true }),
     TracedAs("workflow.engine.startNode", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "startNode", null);
   __legacyDecorateClassTS([
-    TracedAs("workflow.engine.writeNodeCall", { recordParams: true, recordResult: true, log: true }),
-    TracedAs("workflow.engine.writeNodeCall", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "writeNodeCall", null);
+    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 }),
     TracedAs("workflow.engine.resumeNode", { recordParams: true, recordResult: true, log: true })
   ], WorkflowEngine.prototype, "resumeNode", null);
   __legacyDecorateClassTS([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.5",
+  "version": "1.5.6",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",
@@ -9,7 +9,9 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./*": {
       "import": "./dist/*/index.js",
@@ -25,12 +27,6 @@
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "build": "bunup",
-    "build:main": "bunup -- --entry src/index.ts",
-    "clean": "rm -rf dist",
-    "typecheck": "npx tsc --noEmit --skipLibCheck --project tsconfig.json"
-  },
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.0",
     "@ai-sdk/google": "^3.0.0",
@@ -77,5 +73,11 @@
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/ai-setting/roy-agent/issues"
+  },
+  "scripts": {
+    "build": "bunup",
+    "build:main": "bunup -- --entry src/index.ts",
+    "clean": "rm -rf dist",
+    "typecheck": "npx tsc --noEmit --skipLibCheck --project tsconfig.json"
   }
-}
+}