@ai-setting/roy-agent-core 1.5.14-test → 1.5.15-test

package/dist/shared/@ai-setting/roy-agent-core-wrcy0h6z.js

@@ -1,2098 +0,0 @@
-import {
-  AgentComponentAdapter,
-  init_agent_component_adapter
-} from "./roy-agent-core-69jskqjg.js";
-import {
-  SkillNode,
-  ToolNode,
-  WorkflowNode,
-  init_skill_node,
-  init_tool_node,
-  init_workflow_node
-} from "./roy-agent-core-jvatggbb.js";
-import {
-  createWorkflowEvent,
-  init_event,
-  init_types
-} from "./roy-agent-core-5x94xmt6.js";
-import {
-  AskUserError,
-  createNodeInterruptEvent,
-  init_workflow_hil
-} from "./roy-agent-core-e25xkv53.js";
-import {
-  TracedAs,
-  init_decorator
-} from "./roy-agent-core-zgypchmt.js";
-import {
-  createLogger,
-  init_logger
-} from "./roy-agent-core-44hnfb02.js";
-import {
-  __esm,
-  __export,
-  __legacyDecorateClassTS,
-  __require
-} from "./roy-agent-core-fs0mn2jk.js";
-
-// src/env/workflow/engine/event-bus.ts
-class EventBus {
-  handlers = new Map;
-  wildcardHandlers = new Set;
-  constructor() {}
-  on(eventType, handler) {
-    let handlers = this.handlers.get(eventType);
-    if (!handlers) {
-      handlers = new Set;
-      this.handlers.set(eventType, handlers);
-    }
-    handlers.add(handler);
-    return () => this.off(eventType, handler);
-  }
-  once(eventType, handler) {
-    let executed = false;
-    const wrappedHandler = async (event) => {
-      if (executed) {
-        return;
-      }
-      executed = true;
-      try {
-        await handler(event);
-      } catch (error) {
-        console.error("Event handler error:", error);
-      }
-      this.off(eventType, wrappedHandler);
-    };
-    return this.on(eventType, wrappedHandler);
-  }
-  off(eventType, handler) {
-    const handlers = this.handlers.get(eventType);
-    if (handlers) {
-      handlers.delete(handler);
-      if (handlers.size === 0) {
-        this.handlers.delete(eventType);
-      }
-    }
-  }
-  onAny(handler) {
-    this.wildcardHandlers.add(handler);
-    return () => {
-      this.wildcardHandlers.delete(handler);
-    };
-  }
-  async publish(event, waitForHandlers = false) {
-    const handlers = this.handlers.get(event.type);
-    const handlerPromises = [];
-    if (handlers) {
-      for (const handler of handlers) {
-        const promise = this.executeHandler(handler, event);
-        handlerPromises.push(promise);
-      }
-    }
-    for (const handler of this.wildcardHandlers) {
-      const promise = this.executeHandler(handler, event);
-      handlerPromises.push(promise);
-    }
-    if (waitForHandlers && handlerPromises.length > 0) {
-      await Promise.allSettled(handlerPromises);
-    }
-  }
-  async executeHandler(handler, event) {
-    try {
-      await handler(event);
-    } catch (error) {
-      console.error("Event handler error:", error);
-    }
-  }
-  clear() {
-    this.handlers.clear();
-    this.wildcardHandlers.clear();
-  }
-  getStats() {
-    let totalHandlers = 0;
-    for (const handlers of this.handlers.values()) {
-      totalHandlers += handlers.size;
-    }
-    totalHandlers += this.wildcardHandlers.size;
-    return {
-      eventTypes: this.handlers.size,
-      wildcardHandlers: this.wildcardHandlers.size,
-      totalHandlers
-    };
-  }
-}
-var init_event_bus = () => {};
-
-// src/env/workflow/engine/dag-manager.ts
-class DAGManager {
-  workflow;
-  nodeMap;
-  extendedDefinition = null;
-  cachedAnalysis = null;
-  constructor(workflow) {
-    if (!workflow.nodes || workflow.nodes.length === 0) {
-      throw new Error("At least one node is required");
-    }
-    this.workflow = workflow;
-    this.nodeMap = new Map;
-    for (const node of workflow.nodes) {
-      if (node.id === "") {
-        throw new Error("Node ID cannot be empty");
-      }
-      if (this.nodeMap.has(node.id)) {
-        throw new Error(`Duplicate node ID: ${node.id}`);
-      }
-      this.nodeMap.set(node.id, node);
-    }
-  }
-  getExtendedDefinition() {
-    if (this.extendedDefinition) {
-      return this.extendedDefinition;
-    }
-    const analysis = this.analyze();
-    this.extendedDefinition = {
-      ...this.workflow,
-      computedEntry: analysis.entryNodes,
-      nodeMap: this.nodeMap,
-      topologicalOrder: this.getTopologicalOrder()
-    };
-    return this.extendedDefinition;
-  }
-  analyze() {
-    if (this.cachedAnalysis) {
-      return this.cachedAnalysis;
-    }
-    const dependencies = this.buildDependenciesMap();
-    const dependents = this.buildDependentsMap(dependencies);
-    const entryNodes = this.findEntryNodes(dependencies);
-    const exitNodes = this.findExitNodes(dependents);
-    const levels = this.computeLevels(dependencies);
-    const criticalPath = this.findCriticalPath(levels, dependencies);
-    this.cachedAnalysis = {
-      entryNodes,
-      exitNodes,
-      levels,
-      dependencies,
-      dependents,
-      criticalPath
-    };
-    return this.cachedAnalysis;
-  }
-  buildDependenciesMap() {
-    const dependencies = new Map;
-    for (const node of this.workflow.nodes) {
-      const deps = node.depends_on || [];
-      dependencies.set(node.id, [...deps]);
-    }
-    return dependencies;
-  }
-  buildDependentsMap(dependencies) {
-    const dependentsMap = new Map;
-    for (const nodeId of dependencies.keys()) {
-      dependentsMap.set(nodeId, []);
-    }
-    for (const [nodeId, deps] of dependencies.entries()) {
-      for (const dep of deps) {
-        const nodeDependents = dependentsMap.get(dep) || [];
-        nodeDependents.push(nodeId);
-        dependentsMap.set(dep, nodeDependents);
-      }
-    }
-    return dependentsMap;
-  }
-  findEntryNodes(dependencies) {
-    const entryNodes = [];
-    for (const [nodeId, deps] of dependencies.entries()) {
-      if (deps.length === 0) {
-        entryNodes.push(nodeId);
-      }
-    }
-    return entryNodes;
-  }
-  findExitNodes(dependents) {
-    const exitNodes = [];
-    for (const [nodeId, deps] of dependents.entries()) {
-      if (deps.length === 0) {
-        exitNodes.push(nodeId);
-      }
-    }
-    return exitNodes;
-  }
-  computeLevels(dependencies) {
-    const levels = [];
-    const assigned = new Set;
-    const nodeLevels = new Map;
-    const dependentsMap = this.buildDependentsMap(dependencies);
-    const entryNodes = this.findEntryNodes(dependencies);
-    const queue = [];
-    for (const entry of entryNodes) {
-      queue.push({ nodeId: entry, level: 0 });
-      nodeLevels.set(entry, 0);
-    }
-    while (queue.length > 0) {
-      const { nodeId, level } = queue.shift();
-      if (assigned.has(nodeId)) {
-        const currentLevel = nodeLevels.get(nodeId) || 0;
-        if (level > currentLevel) {
-          nodeLevels.set(nodeId, level);
-        }
-        continue;
-      }
-      assigned.add(nodeId);
-      nodeLevels.set(nodeId, level);
-      const dependentsOfNode = dependentsMap.get(nodeId) || [];
-      for (const dependent of dependentsOfNode) {
-        if (!assigned.has(dependent)) {
-          queue.push({ nodeId: dependent, level: level + 1 });
-        }
-      }
-    }
-    for (const nodeId of dependencies.keys()) {
-      if (!nodeLevels.has(nodeId)) {
-        nodeLevels.set(nodeId, 0);
-      }
-    }
-    const maxLevel = Math.max(...nodeLevels.values(), 0);
-    for (let i = 0;i <= maxLevel; i++) {
-      levels.push([]);
-    }
-    for (const [nodeId, level] of nodeLevels.entries()) {
-      levels[level].push(nodeId);
-    }
-    return levels;
-  }
-  findCriticalPath(levels, dependencies) {
-    if (levels.length === 0) {
-      return [];
-    }
-    const longestPath = new Map;
-    const allNodes = [];
-    for (const level of levels) {
-      allNodes.push(...level);
-    }
-    for (const nodeId of allNodes) {
-      const deps = dependencies.get(nodeId) || [];
-      if (deps.length === 0) {
-        longestPath.set(nodeId, { length: 1, path: [nodeId] });
-      } else {
-        let maxLength2 = 0;
-        let maxPath = [];
-        for (const dep of deps) {
-          const depInfo = longestPath.get(dep);
-          if (depInfo && depInfo.length > maxLength2) {
-            maxLength2 = depInfo.length;
-            maxPath = depInfo.path;
-          }
-        }
-        longestPath.set(nodeId, {
-          length: maxLength2 + 1,
-          path: [...maxPath, nodeId]
-        });
-      }
-    }
-    let maxLength = 0;
-    let criticalPath = [];
-    for (const [, info] of longestPath.entries()) {
-      if (info.length > maxLength) {
-        maxLength = info.length;
-        criticalPath = info.path;
-      }
-    }
-    return criticalPath;
-  }
-  getTopologicalOrder() {
-    const dependencies = this.buildDependenciesMap();
-    const dependents = this.buildDependentsMap(dependencies);
-    const inDegree = new Map;
-    for (const nodeId of dependencies.keys()) {
-      inDegree.set(nodeId, dependencies.get(nodeId)?.length || 0);
-    }
-    const queue = [];
-    for (const [nodeId, degree] of inDegree.entries()) {
-      if (degree === 0) {
-        queue.push(nodeId);
-      }
-    }
-    const result = [];
-    while (queue.length > 0) {
-      const nodeId = queue.shift();
-      result.push(nodeId);
-      const nodeDependents = dependents.get(nodeId) || [];
-      for (const dependent of nodeDependents) {
-        const currentDegree = inDegree.get(dependent) || 0;
-        inDegree.set(dependent, currentDegree - 1);
-        if (currentDegree - 1 === 0) {
-          queue.push(dependent);
-        }
-      }
-    }
-    return result;
-  }
-  getReadyNodes(completedNodes) {
-    const dependencies = this.buildDependenciesMap();
-    const ready = [];
-    for (const nodeId of dependencies.keys()) {
-      if (completedNodes.has(nodeId)) {
-        continue;
-      }
-      if (this.areDependenciesMet(nodeId, completedNodes)) {
-        ready.push(nodeId);
-      }
-    }
-    return ready;
-  }
-  areDependenciesMet(nodeId, completedNodes) {
-    const node = this.nodeMap.get(nodeId);
-    if (!node) {
-      return false;
-    }
-    const dependencies = node.depends_on || [];
-    for (const dep of dependencies) {
-      if (!completedNodes.has(dep)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  isCyclic() {
-    const dependencies = this.buildDependenciesMap();
-    const order = this.getTopologicalOrderInternal(dependencies);
-    return order.length !== this.workflow.nodes.length;
-  }
-  getTopologicalOrderInternal(dependencies) {
-    const dependents = this.buildDependentsMap(dependencies);
-    const inDegree = new Map;
-    for (const nodeId of dependencies.keys()) {
-      inDegree.set(nodeId, dependencies.get(nodeId)?.length || 0);
-    }
-    const queue = [];
-    for (const [nodeId, degree] of inDegree.entries()) {
-      if (degree === 0) {
-        queue.push(nodeId);
-      }
-    }
-    const result = [];
-    while (queue.length > 0) {
-      const nodeId = queue.shift();
-      result.push(nodeId);
-      const nodeDependents = dependents.get(nodeId) || [];
-      for (const dependent of nodeDependents) {
-        const currentDegree = inDegree.get(dependent) || 0;
-        inDegree.set(dependent, currentDegree - 1);
-        if (currentDegree - 1 === 0) {
-          queue.push(dependent);
-        }
-      }
-    }
-    return result;
-  }
-  validate() {
-    const errors = [];
-    const nodeIds = new Set;
-    for (const node of this.workflow.nodes) {
-      if (node.id === "") {
-        errors.push("Node ID cannot be empty");
-        continue;
-      }
-      if (nodeIds.has(node.id)) {
-        errors.push(`Duplicate node ID: ${node.id}`);
-      }
-      nodeIds.add(node.id);
-    }
-    for (const node of this.workflow.nodes) {
-      const deps = node.depends_on || [];
-      for (const dep of deps) {
-        if (!nodeIds.has(dep)) {
-          errors.push(`Node '${node.id}' depends on non-existent node '${dep}'`);
-        }
-      }
-    }
-    if (this.isCyclic()) {
-      errors.push("Workflow contains a cycle");
-    }
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-  addNode(node) {
-    if (!node.id || node.id.trim() === "") {
-      throw new Error("Node ID cannot be empty");
-    }
-    if (this.nodeMap.has(node.id)) {
-      throw new Error(`Node with ID '${node.id}' already exists`);
-    }
-    const deps = node.depends_on || [];
-    for (const dep of deps) {
-      if (!this.nodeMap.has(dep)) {
-        throw new Error(`Cannot add node '${node.id}': depends on non-existent node '${dep}'`);
-      }
-    }
-    const originalNodes = [...this.workflow.nodes];
-    this.workflow.nodes.push(node);
-    if (this.isCyclic()) {
-      this.workflow.nodes = originalNodes;
-      throw new Error(`Cannot add node '${node.id}': would create a cycle in the workflow`);
-    }
-    this.nodeMap.set(node.id, node);
-    this.cachedAnalysis = null;
-    this.extendedDefinition = null;
-  }
-  removeNode(nodeId) {
-    if (!this.nodeMap.has(nodeId)) {
-      throw new Error(`Node '${nodeId}' does not exist`);
-    }
-    const dependents = this.getDependents(nodeId);
-    if (dependents.length > 0) {
-      throw new Error(`Cannot remove node '${nodeId}': other nodes depend on it: ${dependents.join(", ")}`);
-    }
-    this.workflow.nodes = this.workflow.nodes.filter((n) => n.id !== nodeId);
-    this.nodeMap.delete(nodeId);
-    this.cachedAnalysis = null;
-    this.extendedDefinition = null;
-  }
-  getDependents(nodeId) {
-    const analysis = this.analyze();
-    return analysis.dependents.get(nodeId) || [];
-  }
-  getDefinition() {
-    return this.workflow;
-  }
-  getNode(nodeId) {
-    return this.nodeMap.get(nodeId);
-  }
-  getNodeIds() {
-    return Array.from(this.nodeMap.keys());
-  }
-  getNodeCount() {
-    return this.nodeMap.size;
-  }
-}
-var init_dag_manager = () => {};
-
-// src/env/workflow/engine/scheduler.ts
-class Scheduler {
-  dagManager;
-  options;
-  pending = new Set;
-  ready = new Set;
-  running = new Set;
-  completed = new Set;
-  failed = new Set;
-  skipped = new Set;
-  constructor(dagManager, options) {
-    this.dagManager = dagManager;
-    const parallelLimit = options?.parallelLimit;
-    this.options = {
-      parallelLimit: parallelLimit === undefined ? 1 : parallelLimit
-    };
-    const analysis = dagManager.analyze();
-    for (const nodeId of analysis.dependencies.keys()) {
-      this.pending.add(nodeId);
-    }
-    this.updateReadyNodes(new Set);
-  }
-  getReadyNodes(completedNodes) {
-    const allCompleted = new Set(completedNodes);
-    for (const nodeId of this.completed) {
-      allCompleted.add(nodeId);
-    }
-    const readyFromDag = this.dagManager.getReadyNodes(allCompleted);
-    const ready = [];
-    for (const nodeId of readyFromDag) {
-      const isProcessed = this.running.has(nodeId) || this.completed.has(nodeId) || this.failed.has(nodeId) || this.skipped.has(nodeId);
-      if (!isProcessed) {
-        ready.push(nodeId);
-      }
-    }
-    return ready.sort();
-  }
-  getRunningCount() {
-    return this.running.size;
-  }
-  canStartMore() {
-    if (this.options.parallelLimit === null) {
-      return true;
-    }
-    if (this.options.parallelLimit <= 0) {
-      return false;
-    }
-    return this.running.size < this.options.parallelLimit;
-  }
-  markStarted(nodeId) {
-    if (!this.running.has(nodeId)) {
-      this.running.add(nodeId);
-      this.ready.delete(nodeId);
-      this.pending.delete(nodeId);
-    }
-  }
-  isRunning(nodeId) {
-    return this.running.has(nodeId);
-  }
-  isCompleted(nodeId) {
-    return this.completed.has(nodeId);
-  }
-  isFailed(nodeId) {
-    return this.failed.has(nodeId);
-  }
-  isPending(nodeId) {
-    return this.pending.has(nodeId);
-  }
-  isReady(nodeId) {
-    return this.ready.has(nodeId);
-  }
-  markCompleted(nodeId) {
-    this.running.delete(nodeId);
-    this.ready.delete(nodeId);
-    this.pending.delete(nodeId);
-    this.failed.delete(nodeId);
-    this.skipped.delete(nodeId);
-    this.completed.add(nodeId);
-  }
-  markFailed(nodeId) {
-    this.running.delete(nodeId);
-    this.ready.delete(nodeId);
-    this.pending.delete(nodeId);
-    this.completed.delete(nodeId);
-    this.skipped.delete(nodeId);
-    this.failed.add(nodeId);
-  }
-  markSkipped(nodeId) {
-    if (this.running.has(nodeId)) {
-      this.running.delete(nodeId);
-    }
-    if (this.ready.has(nodeId)) {
-      this.ready.delete(nodeId);
-    }
-    if (this.pending.has(nodeId)) {
-      this.pending.delete(nodeId);
-    }
-    this.skipped.add(nodeId);
-  }
-  reset() {
-    this.running.clear();
-    this.completed.clear();
-    this.failed.clear();
-    this.skipped.clear();
-    const analysis = this.dagManager.analyze();
-    this.pending.clear();
-    this.ready.clear();
-    for (const nodeId of analysis.dependencies.keys()) {
-      this.pending.add(nodeId);
-    }
-    this.updateReadyNodes(new Set);
-  }
-  getState() {
-    this.updateReadyNodes(new Set);
-    return {
-      pending: Array.from(this.pending).sort(),
-      ready: Array.from(this.ready).sort(),
-      running: Array.from(this.running).sort(),
-      completed: Array.from(this.completed).sort(),
-      failed: Array.from(this.failed).sort(),
-      skipped: Array.from(this.skipped).sort()
-    };
-  }
-  updateReadyNodes(completedNodes) {
-    const allCompleted = new Set(completedNodes);
-    for (const nodeId of this.completed) {
-      allCompleted.add(nodeId);
-    }
-    const analysis = this.dagManager.analyze();
-    const allNodeIds = Array.from(analysis.dependencies.keys());
-    this.ready.clear();
-    for (const nodeId of allNodeIds) {
-      if (this.running.has(nodeId) || this.completed.has(nodeId) || this.failed.has(nodeId) || this.skipped.has(nodeId)) {
-        continue;
-      }
-      if (this.dagManager.areDependenciesMet(nodeId, allCompleted)) {
-        this.ready.add(nodeId);
-      }
-    }
-  }
-  getParallelLimit() {
-    return this.options.parallelLimit;
-  }
-  setParallelLimit(limit) {
-    this.options.parallelLimit = limit;
-  }
-}
-var init_scheduler = () => {};
-
-// src/env/workflow/engine/executor.ts
-var Executor;
-var init_executor = __esm(() => {
-  init_event();
-  init_types();
-  init_decorator();
-  Executor = class Executor {
-    nodeRegistry;
-    eventBus;
-    options;
-    sessionComponent;
-    abortControllers = new Map;
-    constructor(nodeRegistry, eventBus, options, sessionComponent) {
-      this.nodeRegistry = nodeRegistry;
-      this.eventBus = eventBus;
-      this.options = options;
-      this.sessionComponent = sessionComponent;
-    }
-    async executeNode(definition, context) {
-      const nodeId = definition.id;
-      const nodeType = definition.type;
-      const agentSessionId = context.agentSessionId;
-      await this.eventBus.publish(createWorkflowEvent("node.started", context.runId, {
-        node_id: nodeId,
-        input: context.input
-      }));
-      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;
-      const retryConfig = definition.retry ?? this.options.globalRetry;
-      try {
-        let result;
-        if (retryConfig && retryConfig.max_attempts > 1) {
-          result = await this.executeWithRetry(definition, context, abortController.signal, timeout);
-        } else {
-          result = await this.executeWithTimeout(definition, context, abortController.signal, timeout);
-        }
-        if (result.error instanceof AskUserError) {
-          const interruptEvent = createNodeInterruptEvent(context.runId, nodeId, nodeType, result.error.query, result.error.agentSessionId || agentSessionId);
-          await this.eventBus.publish(interruptEvent);
-          await this.writeNodeInterrupt(context.sessionId, nodeId, nodeType, result.error.query, result.error.agentSessionId || agentSessionId);
-          throw result.error;
-        }
-        if (result.error) {
-          const errorMessage = result.error instanceof Error ? result.error.message : String(result.error);
-          const errorStack = result.error instanceof Error ? result.error.stack : undefined;
-          await this.eventBus.publish(createWorkflowEvent("node.failed", context.runId, {
-            node_id: nodeId,
-            error: {
-              message: errorMessage,
-              stack: errorStack
-            }
-          }));
-          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.writeNodeEnd(context.sessionId, nodeId, nodeType, result.output, undefined, result.durationMs ?? 0, agentSessionId);
-        }
-        return result;
-      } finally {
-        this.abortControllers.delete(nodeId);
-      }
-    }
-    async executeWithTimeout(definition, context, signal, timeout) {
-      const startTime = Date.now();
-      const nodeContext = {
-        runId: context.runId,
-        workflowName: context.workflowName,
-        eventBus: this.eventBus,
-        debug: context.debug
-      };
-      const node = this.nodeRegistry.createNode(definition, nodeContext);
-      if (timeout) {
-        const timeoutPromise = new Promise((_, reject) => {
-          const handle = setTimeout(() => {
-            reject(new Error(`Node execution timeout: ${timeout}ms`));
-          }, timeout);
-          signal.addEventListener("abort", () => clearTimeout(handle));
-        });
-        try {
-          const result = await Promise.race([
-            node.execute(context),
-            timeoutPromise
-          ]);
-          return {
-            output: result.output,
-            error: result.error ?? undefined,
-            durationMs: Date.now() - startTime
-          };
-        } catch (error) {
-          if (error instanceof AskUserError) {
-            throw error;
-          }
-          return {
-            output: undefined,
-            error: error instanceof Error ? error : new Error(String(error)),
-            durationMs: Date.now() - startTime
-          };
-        }
-      } else {
-        try {
-          const result = await node.execute(context);
-          return {
-            output: result.output,
-            durationMs: Date.now() - startTime
-          };
-        } catch (error) {
-          if (error instanceof AskUserError) {
-            throw error;
-          }
-          return {
-            output: undefined,
-            error: error instanceof Error ? error : new Error(String(error)),
-            durationMs: Date.now() - startTime
-          };
-        }
-      }
-    }
-    async executeWithRetry(definition, context, signal, timeout) {
-      const retryConfig = definition.retry;
-      let lastError;
-      let delay = retryConfig.initial_delay;
-      for (let attempt = 1;attempt <= retryConfig.max_attempts; attempt++) {
-        if (signal.aborted) {
-          return {
-            output: undefined,
-            error: new Error("Execution aborted"),
-            durationMs: 0
-          };
-        }
-        const attemptAbort = new AbortController;
-        const combinedSignal = this.combineAbortSignals(signal, attemptAbort.signal);
-        try {
-          const result = await this.executeWithTimeout(definition, context, combinedSignal, timeout);
-          if (!result.error) {
-            return result;
-          }
-          lastError = result.error instanceof Error ? result.error : new Error(String(result.error));
-        } catch (error) {
-          lastError = error instanceof Error ? error : new Error(String(error));
-        }
-        if (attempt < retryConfig.max_attempts) {
-          await this.sleep(delay);
-          if (retryConfig.backoff === "exponential") {
-            delay *= 2;
-          }
-        }
-      }
-      return {
-        output: undefined,
-        error: lastError ?? new Error("Unknown error after retries"),
-        durationMs: 0
-      };
-    }
-    cancelNode(nodeId) {
-      const controller = this.abortControllers.get(nodeId);
-      if (controller) {
-        controller.abort();
-        this.abortControllers.delete(nodeId);
-      }
-    }
-    cancelAll() {
-      for (const controller of this.abortControllers.values()) {
-        controller.abort();
-      }
-      this.abortControllers.clear();
-    }
-    combineAbortSignals(signal1, signal2) {
-      const controller = new AbortController;
-      signal1.addEventListener("abort", () => controller.abort());
-      signal2.addEventListener("abort", () => controller.abort());
-      return controller.signal;
-    }
-    sleep(ms) {
-      return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    async writeNodeStart(sessionId, nodeId, nodeType, input, agentSessionId) {
-      if (!this.sessionComponent)
-        return;
-      const startTime = Date.now();
-      const part = {
-        type: "workflow-node-start",
-        nodeId,
-        nodeType,
-        input,
-        startTime,
-        ...agentSessionId ? { agentSessionId } : {}
-      };
-      const contentSummary = this.summarizeCall(nodeType, nodeId, input);
-      await this.sessionComponent.addMessage(sessionId, {
-        role: "workflow.node.start",
-        content: contentSummary,
-        parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.start",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
-          ...agentSessionId ? { agentSessionId } : {}
-        }
-      });
-    }
-    summarizeCall(nodeType, nodeId, input) {
-      if (input === undefined || input === null) {
-        return `[${nodeType}] ${nodeId} started`;
-      }
-      if (typeof input === "object") {
-        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(inputObj[k])}`).join(", ");
-        return `[${nodeType}] ${nodeId}: ${summary}`;
-      }
-      return `[${nodeType}] ${nodeId}: ${String(input)}`;
-    }
-    async writeNodeInterrupt(sessionId, nodeId, nodeType, query, agentSessionId) {
-      if (!this.sessionComponent)
-        return;
-      const timestamp = Date.now();
-      const part = {
-        type: "workflow-node-interrupt",
-        nodeId,
-        nodeType,
-        query,
-        timestamp,
-        ...agentSessionId ? { agentSessionId } : {}
-      };
-      await this.sessionComponent.addMessage(sessionId, {
-        role: "workflow.node.interrupt",
-        content: query,
-        parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.interrupt",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
-          query,
-          agentSessionId
-        }
-      });
-    }
-    async writeNodeEnd(sessionId, nodeId, nodeType, output, error, durationMs, agentSessionId) {
-      if (!this.sessionComponent)
-        return;
-      const part = {
-        type: "workflow-node-end",
-        nodeId,
-        nodeType,
-        output,
-        error,
-        durationMs,
-        ...agentSessionId ? { agentSessionId } : {}
-      };
-      const contentSummary = this.summarizeResult(nodeId, output, error, durationMs);
-      await this.sessionComponent.addMessage(sessionId, {
-        role: "workflow.node.end",
-        content: contentSummary,
-        parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.end",
-          workflowNodeId: nodeId,
-          workflowNodeType: nodeType,
-          success: !error,
-          ...agentSessionId ? { agentSessionId } : {}
-        }
-      });
-    }
-    summarizeResult(nodeId, output, error, durationMs) {
-      if (error) {
-        return `❌ ${nodeId} failed: ${error}`;
-      }
-      if (output === undefined || output === null) {
-        return `✅ ${nodeId} completed (${durationMs}ms)`;
-      }
-      if (typeof output === "object") {
-        const keys = Object.keys(output);
-        if (keys.length === 0) {
-          return `✅ ${nodeId} completed (${durationMs}ms)`;
-        }
-        const summary = keys.slice(0, 3).join(", ");
-        return `✅ ${nodeId}: ${summary} (${durationMs}ms)`;
-      }
-      const strOutput = String(output);
-      const truncated = strOutput.length > 100 ? strOutput.substring(0, 100) + "..." : strOutput;
-      return `✅ ${nodeId}: ${truncated} (${durationMs}ms)`;
-    }
-    async writeNodeResume(sessionId, nodeId, response, agentSessionId) {
-      if (!this.sessionComponent)
-        return;
-      const timestamp = Date.now();
-      const part = {
-        type: "workflow-node-resume",
-        nodeId,
-        response,
-        timestamp,
-        ...agentSessionId ? { agentSessionId } : {}
-      };
-      await this.sessionComponent.addMessage(sessionId, {
-        role: "workflow.node.resume",
-        content: response,
-        parts: [part],
-        metadata: {
-          _workflowNodeMetadata: true,
-          type: "workflow.node.resume",
-          workflowNodeId: nodeId,
-          ...agentSessionId ? { agentSessionId } : {}
-        }
-      });
-    }
-  };
-  __legacyDecorateClassTS([
-    TracedAs("workflow.executor.executeNode", { recordParams: true, recordResult: true, log: true })
-  ], Executor.prototype, "executeNode", null);
-  __legacyDecorateClassTS([
-    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.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);
-});
-
-// src/env/workflow/nodes/agent-node.ts
-var AgentNode;
-var init_agent_node = __esm(() => {
-  init_workflow_hil();
-  init_decorator();
-  AgentNode = class AgentNode {
-    definition;
-    agentRunner;
-    type = "agent";
-    id;
-    constructor(definition, agentRunner) {
-      this.definition = definition;
-      this.agentRunner = agentRunner;
-      this.id = definition.id;
-    }
-    async execute(context) {
-      const startTime = Date.now();
-      try {
-        const config = this.definition.config || {};
-        const agentType = config.agent_type || "general";
-        const promptTemplate = config.prompt || "";
-        const options = config.options || {};
-        const resolvedPrompt = this.resolveTemplate(promptTemplate, context);
-        if (this.agentRunner.registerAgent && this.agentRunner.hasAgent) {
-          if (!this.agentRunner.hasAgent(agentType)) {
-            this.agentRunner.registerAgent(agentType, {
-              type: agentType,
-              systemPrompt: config.system_prompt || `You are a ${agentType} agent.`,
-              model: options.model
-            });
-          }
-        }
-        const userQuery = context.input?.userQuery;
-        let agentSessionId = context.agentSessionId;
-        if (!agentSessionId && context.sessionComponent) {
-          agentSessionId = await this.createAgentSubSession(context);
-          context.agentSessionId = agentSessionId;
-        }
-        const agentConfig = {
-          type: agentType,
-          prompt: resolvedPrompt,
-          options: {
-            timeout: options.timeout,
-            model: options.model,
-            allowedTools: ["ask_user"]
-          },
-          workflowHistory: context.workflowHistory,
-          nodeId: this.definition.id,
-          agentSessionId
-        };
-        const resumeOptions = {
-          userQuery,
-          agentSessionId
-        };
-        const result = await this.agentRunner.run(agentConfig, resumeOptions);
-        const duration = Date.now() - startTime;
-        return {
-          output: {
-            result: result.output,
-            metadata: result.metadata,
-            workflowHistory: result.messages
-          },
-          error: undefined,
-          duration
-        };
-      } catch (error) {
-        if (error instanceof AskUserError) {
-          const contextAgentSessionId = context.agentSessionId;
-          if (contextAgentSessionId && !error.agentSessionId) {
-            throw new AskUserError(error.runId, error.sessionId, error.nodeId, error.nodeType, error.query, contextAgentSessionId, error.timestamp);
-          }
-          throw error;
-        }
-        const duration = Date.now() - startTime;
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-          output: undefined,
-          error: errorMessage,
-          duration
-        };
-      }
-    }
-    async createAgentSubSession(context) {
-      const sessionComponent = context.sessionComponent;
-      if (!sessionComponent) {
-        return "";
-      }
-      const nodeId = this.definition.id || "unknown";
-      const agentSessionId = `agent_${nodeId}_${Date.now()}`;
-      await sessionComponent.create({
-        id: agentSessionId,
-        title: `Agent: ${nodeId}`,
-        metadata: {
-          type: "agent",
-          parentSessionId: context.sessionId,
-          nodeId,
-          workflowName: context.workflowName
-        }
-      });
-      const workflowSession = await sessionComponent.get(context.sessionId);
-      if (workflowSession) {
-        const metadata = workflowSession.metadata || {};
-        const agentSessions = metadata.agentSessions || [];
-        const existingIndex = agentSessions.findIndex((s) => s.nodeId === this.definition.id);
-        if (existingIndex >= 0) {
-          agentSessions[existingIndex] = {
-            nodeId: this.definition.id,
-            sessionId: agentSessionId,
-            status: "active",
-            createdAt: Date.now()
-          };
-        } else {
-          agentSessions.push({
-            nodeId: this.definition.id,
-            sessionId: agentSessionId,
-            status: "active",
-            createdAt: Date.now()
-          });
-        }
-        await sessionComponent.update(context.sessionId, {
-          metadata: {
-            ...metadata,
-            agentSessions
-          }
-        });
-      }
-      return agentSessionId;
-    }
-    resolveTemplate(template, context) {
-      if (!template) {
-        return "";
-      }
-      let resolved = template;
-      resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/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(/\{\{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) => {
-        const segments = path.split(".");
-        const nodeId = segments[0];
-        let nodeOutput = context.previousOutputs.get(nodeId);
-        if (nodeOutput === undefined) {
-          const normalizedUnderscore = nodeId.replace(/-/g, "_");
-          const normalizedHyphen = nodeId.replace(/_/g, "-");
-          if (normalizedUnderscore !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedUnderscore);
-          }
-          if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedHyphen);
-          }
-        }
-        if (nodeOutput === undefined) {
-          return match;
-        }
-        nodeOutput = this.extractFromWrapper(nodeOutput);
-        if (segments.length === 1) {
-          return this.stringifyValue(nodeOutput, match);
-        }
-        let value = nodeOutput;
-        let startIndex = 1;
-        if (segments.length > 1 && (segments[1] === "output" || segments[1] === "result" || segments[1] === "metadata")) {
-          startIndex = 2;
-        }
-        for (let i = startIndex;i < segments.length; i++) {
-          if (value === null || value === undefined) {
-            return match;
-          }
-          value = value[segments[i]];
-        }
-        return this.stringifyValue(value, match);
-      });
-      resolved = resolved.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
-        if (path.startsWith("input.") || path.startsWith("nodes.")) {
-          return match;
-        }
-        const segments = path.split(".");
-        const nodeId = segments[0];
-        let nodeOutput = context.previousOutputs.get(nodeId);
-        if (nodeOutput === undefined) {
-          const normalizedUnderscore = nodeId.replace(/-/g, "_");
-          const normalizedHyphen = nodeId.replace(/_/g, "-");
-          if (normalizedUnderscore !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedUnderscore);
-          }
-          if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
-            nodeOutput = context.previousOutputs.get(normalizedHyphen);
-          }
-        }
-        if (nodeOutput === undefined) {
-          return match;
-        }
-        nodeOutput = this.extractFromWrapper(nodeOutput);
-        if (segments.length === 1) {
-          return this.stringifyValue(nodeOutput, match);
-        }
-        let value = nodeOutput;
-        let startIndex = 1;
-        if (segments.length > 1 && (segments[1] === "output" || segments[1] === "result" || segments[1] === "metadata")) {
-          startIndex = 2;
-        }
-        for (let i = startIndex;i < segments.length; i++) {
-          if (value === null || value === undefined) {
-            return match;
-          }
-          value = value[segments[i]];
-        }
-        return this.stringifyValue(value, match);
-      });
-      return resolved;
-    }
-    stringifyValue(value, originalTemplate) {
-      if (value === undefined) {
-        return originalTemplate;
-      }
-      if (value === null) {
-        return "null";
-      }
-      if (typeof value === "string") {
-        return value;
-      }
-      return JSON.stringify(value);
-    }
-    extractFromWrapper(value) {
-      if (value === null || value === undefined) {
-        return value;
-      }
-      if (typeof value !== "object") {
-        return value;
-      }
-      if ("result" in value && "metadata" in value) {
-        return value.result;
-      }
-      if ("output" in value) {
-        return value.output;
-      }
-      return value;
-    }
-    getNestedValue(obj, path) {
-      if (!obj) {
-        return;
-      }
-      if ("input" in obj && path in obj["input"]) {
-        return obj["input"][path];
-      }
-      return path.split(".").reduce((current, key) => {
-        if (current && typeof current === "object") {
-          return current[key];
-        }
-        return;
-      }, obj);
-    }
-  };
-  __legacyDecorateClassTS([
-    TracedAs("agent.node.execute", { recordParams: true, recordResult: true, log: true })
-  ], AgentNode.prototype, "execute", null);
-  __legacyDecorateClassTS([
-    TracedAs("agent.node.createAgentSubSession", { recordParams: true, recordResult: true, log: true })
-  ], AgentNode.prototype, "createAgentSubSession", null);
-});
-
-// src/env/workflow/nodes/ask-user-node.ts
-class AskUserNode {
-  type = "ask_user";
-  id;
-  config;
-  constructor(definition) {
-    this.id = definition.id;
-    this.config = definition.config || {};
-  }
-  async execute(context) {
-    const query = this.config.query || "确认继续吗？";
-    const options = this.config.options;
-    const fullQuery = options ? `${query} (选项: ${options.join(", ")})` : query;
-    await context.eventBus.publish(createNodeInterruptEvent(context.runId, this.id, this.type, fullQuery));
-    throw new AskUserError(context.runId, context.sessionId, this.id, this.type, query);
-  }
-  validateConfig(_config) {
-    return true;
-  }
-}
-var init_ask_user_node = __esm(() => {
-  init_workflow_hil();
-});
-
-// src/env/workflow/engine/node-registry.ts
-class NodeRegistry {
-  factories = new Map;
-  toolRegistry;
-  skillRegistry;
-  agentRunner;
-  workflowRunner;
-  agentComponentAdapter;
-  sessionComponent;
-  constructor(options) {
-    const {
-      toolRegistry,
-      skillRegistry,
-      agentComponent,
-      agentRunner,
-      workflowRunner,
-      sessionComponent
-    } = options ?? {};
-    this.toolRegistry = toolRegistry;
-    this.skillRegistry = skillRegistry;
-    this.workflowRunner = workflowRunner;
-    this.sessionComponent = sessionComponent;
-    if (agentRunner) {
-      this.agentRunner = agentRunner;
-      if (agentRunner.setSessionComponent && sessionComponent) {
-        agentRunner.setSessionComponent(sessionComponent);
-      }
-    } else if (agentComponent) {
-      this.agentComponentAdapter = new AgentComponentAdapter(agentComponent, {}, sessionComponent);
-      this.agentRunner = this.agentComponentAdapter;
-    }
-    this.registerBuiltInTypes();
-  }
-  getAgentAdapter() {
-    return this.agentComponentAdapter;
-  }
-  getAgentRunner() {
-    return this.agentRunner;
-  }
-  getSessionComponent() {
-    return this.sessionComponent;
-  }
-  registerBuiltInTypes() {
-    this.factories.set("tool", (definition) => {
-      if (!this.toolRegistry) {
-        throw new Error("ToolRegistry is required for tool nodes");
-      }
-      return new ToolNode(definition, this.toolRegistry);
-    });
-    this.factories.set("skill", (definition) => {
-      if (!this.skillRegistry) {
-        throw new Error("SkillRegistry is required for skill nodes");
-      }
-      return new SkillNode(definition, this.skillRegistry);
-    });
-    this.factories.set("agent", (definition) => {
-      if (!this.agentRunner) {
-        throw new Error("AgentRunner is required for agent nodes");
-      }
-      return new AgentNode(definition, this.agentRunner);
-    });
-    this.factories.set("workflow", (definition) => {
-      if (!this.workflowRunner) {
-        throw new Error("WorkflowRunner is required for workflow nodes");
-      }
-      return new WorkflowNode(definition, this.workflowRunner);
-    });
-    this.factories.set("ask_user", (definition) => {
-      return new AskUserNode(definition);
-    });
-  }
-  register(type, factory) {
-    this.factories.set(type, factory);
-  }
-  has(type) {
-    return this.factories.has(type);
-  }
-  list() {
-    return Array.from(this.factories.keys());
-  }
-  createNode(definition, context) {
-    const factory = this.factories.get(definition.type);
-    if (!factory) {
-      const availableTypes = this.list().join(", ");
-      throw new Error(`Unknown node type: ${definition.type}. Available types: ${availableTypes}`);
-    }
-    return factory(definition, context);
-  }
-}
-var init_node_registry = __esm(() => {
-  init_tool_node();
-  init_skill_node();
-  init_agent_node();
-  init_agent_component_adapter();
-  init_workflow_node();
-  init_ask_user_node();
-});
-
-// src/env/workflow/engine/engine.ts
-import { EventEmitter } from "events";
-var logger, WorkflowEngine;
-var init_engine = __esm(() => {
-  init_event();
-  init_workflow_hil();
-  init_dag_manager();
-  init_event_bus();
-  init_scheduler();
-  init_executor();
-  init_node_registry();
-  init_logger();
-  init_decorator();
-  logger = createLogger("workflow:engine");
-  WorkflowEngine = class WorkflowEngine extends EventEmitter {
-    activeSessions = new Map;
-    sessionIdCounter = 0;
-    sessionComponent;
-    nodeRegistry;
-    workflowRepository;
-    constructor(nodeRegistry, sessionComponent, workflowRepository) {
-      super();
-      this.nodeRegistry = nodeRegistry;
-      this.sessionComponent = sessionComponent;
-      this.workflowRepository = workflowRepository;
-    }
-    static async create(options) {
-      const agentComponent = options.env?.getComponent("agent");
-      const sessionComponent = options.sessionComponent;
-      const nodeRegistry = new NodeRegistry({
-        toolRegistry: options.toolRegistry,
-        skillRegistry: options.skillRegistry,
-        agentComponent,
-        workflowRunner: options.workflowRunner,
-        sessionComponent
-      });
-      return new WorkflowEngine(nodeRegistry, sessionComponent, options.workflowRepository);
-    }
-    generateRunId() {
-      const random = Math.random().toString(36).substring(2, 8);
-      return `run_${Date.now()}_${++this.sessionIdCounter}_${random}`;
-    }
-    getRunIdFromSessionId(sessionId) {
-      return sessionId.replace(/^workflow_/, "");
-    }
-    getSessionId(runId) {
-      return `workflow_${runId}`;
-    }
-    async createSession(workflow, options) {
-      const definition = "definition" in workflow ? workflow.definition : workflow;
-      const workflowId = "id" in workflow ? workflow.id : `inline_${definition.name}`;
-      const workflowName = definition.name;
-      const runId = this.generateRunId();
-      const sessionId = this.getSessionId(runId);
-      const metadata = {
-        type: "workflow",
-        workflowId,
-        workflowName,
-        workflowVersion: definition.version,
-        status: "running",
-        input: options?.input,
-        agentSessions: []
-      };
-      if (this.sessionComponent) {
-        await this.sessionComponent.create({
-          id: sessionId,
-          title: `Workflow: ${workflowName} (${runId})`,
-          metadata
-        });
-      }
-      logger.info(`[WorkflowEngine] Created session: ${sessionId}`);
-      return sessionId;
-    }
-    async run(sessionId, options) {
-      let session = this.sessionComponent ? await this.sessionComponent.get(sessionId) : null;
-      let workflowDef = null;
-      let workflowId = "";
-      let workflowName = "";
-      if (session) {
-        const metadata2 = session.metadata;
-        if (metadata2.type === "workflow" && metadata2.workflowId) {
-          workflowDef = this.findDefinitionForWorkflow(metadata2.workflowId);
-          workflowId = metadata2.workflowId;
-          workflowName = metadata2.workflowName;
-        }
-        if (!workflowDef && metadata2.workflowName) {
-          workflowDef = this.findDefinitionForWorkflow(metadata2.workflowName);
-          workflowId = metadata2.workflowName;
-          workflowName = metadata2.workflowName;
-        }
-      } else {
-        if (!options?.workflowId) {
-          throw new Error("workflowId required for new session");
-        }
-        workflowDef = this.findDefinitionForWorkflow(options.workflowId);
-        if (!workflowDef) {
-          throw new Error(`Workflow not found: ${options.workflowId}`);
-        }
-        workflowId = options.workflowId;
-        workflowName = workflowDef.name;
-        if (this.sessionComponent) {
-          const sessionMetadata = {
-            type: "workflow",
-            workflowId,
-            workflowName,
-            workflowVersion: workflowDef.version,
-            status: "running",
-            input: options?.input,
-            agentSessions: []
-          };
-          await this.sessionComponent.create({
-            id: sessionId,
-            title: `Workflow: ${workflowName}`,
-            metadata: sessionMetadata
-          });
-          session = await this.sessionComponent.get(sessionId);
-        }
-      }
-      if (!session || !workflowDef) {
-        throw new Error(`Cannot start workflow: session or workflow not found`);
-      }
-      const metadata = session.metadata;
-      if (metadata.status === "completed") {
-        return { runId: this.getRunIdFromSessionId(sessionId), status: "completed" };
-      }
-      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-gq20wsgv.js");
-      const entry = workflowDef.entry;
-      const entryNode = Array.isArray(entry) ? entry[0] : entry;
-      const resumePoint = inferNextNode(messages, {
-        entryNode: entryNode !== "__default_entry__" ? entryNode : undefined,
-        edges: undefined
-      });
-      const sessionState = await this.initializeSessionState(sessionId, workflowDef, workflowId, workflowName, options);
-      this.activeSessions.set(sessionId, sessionState);
-      return this.runWithResume(sessionId, resumePoint, options);
-    }
-    async initializeSessionState(sessionId, definition, workflowId, workflowName, options) {
-      const dagManager = new DAGManager(definition);
-      const validation = dagManager.validate();
-      if (!validation.valid) {
-        throw new Error(`Invalid workflow: ${validation.errors.join(", ")}`);
-      }
-      const parallelLimit = options?.parallelLimit ?? definition.config?.parallel_limit ?? null;
-      const scheduler = new Scheduler(dagManager, { parallelLimit });
-      const eventBus = new EventBus;
-      const executorOptions = {
-        globalTimeout: options?.timeout ?? definition.config?.timeout ?? null,
-        globalRetry: definition.config?.retry ?? null,
-        debug: options?.debug ?? definition.config?.debug ?? false
-      };
-      const executor = new Executor(this.nodeRegistry, eventBus, executorOptions, this.sessionComponent);
-      const config = {
-        parallelLimit,
-        timeout: options?.timeout ?? definition.config?.timeout ?? null,
-        debug: options?.debug ?? definition.config?.debug ?? false
-      };
-      const abortController = new AbortController;
-      let resolveCompleted;
-      let rejectCompleted;
-      const completedPromise = new Promise((resolve, reject) => {
-        resolveCompleted = resolve;
-        rejectCompleted = reject;
-      });
-      const sessionState = {
-        sessionId,
-        workflowId,
-        workflowName,
-        status: "running",
-        startedAt: new Date,
-        eventBus,
-        dagManager,
-        scheduler,
-        executor,
-        nodeRegistry: this.nodeRegistry,
-        nodeOutputs: new Map,
-        config,
-        abortController,
-        completedPromise,
-        resolveCompleted,
-        rejectCompleted,
-        workflowHistory: [],
-        agentSessions: new Map
-      };
-      this.setupEventHandlers(sessionState);
-      return sessionState;
-    }
-    async runWithResume(sessionId, resumePoint, options) {
-      const sessionState = this.activeSessions.get(sessionId);
-      if (!sessionState) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const runId = this.getRunIdFromSessionId(sessionId);
-      await sessionState.eventBus.publish(createWorkflowEvent("workflow.started", runId, {
-        workflow_name: sessionState.workflowName,
-        input: options?.input
-      }));
-      let pendingNodeId;
-      let agentSessionId;
-      switch (resumePoint.type) {
-        case "entry_node":
-        case "next_nodes":
-          pendingNodeId = undefined;
-          break;
-        case "resume_node":
-        case "ask_user":
-          pendingNodeId = resumePoint.nodeId;
-          agentSessionId = resumePoint.agentSessionId;
-          break;
-      }
-      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: inputForExecution,
-        pendingNodeId,
-        agentSessionId
-      }).catch((error) => {
-        logger.error(`Workflow ${sessionId} scheduling error:`, error);
-        this.failWorkflow(sessionState, error);
-      });
-      if (options?.sync !== false) {
-        return this.waitForCompletion(sessionId, options?.timeout);
-      }
-      return { runId, status: "running" };
-    }
-    async runWorkflow(workflow, options) {
-      const definition = "definition" in workflow ? workflow.definition : workflow;
-      const workflowId = "id" in workflow ? workflow.id : `inline_${definition.name}`;
-      const workflowName = definition.name;
-      const sessionId = await this.createSession(workflow, options);
-      const sessionState = await this.initializeSessionState(sessionId, definition, workflowId, workflowName, options);
-      this.activeSessions.set(sessionId, sessionState);
-      return this.runWithResume(sessionId, { type: "entry_node" }, options);
-    }
-    async pause(sessionId) {
-      const sessionState = this.activeSessions.get(sessionId);
-      if (!sessionState) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      if (sessionState.status !== "running") {
-        throw new Error(`Session ${sessionId} is not running (current: ${sessionState.status})`);
-      }
-      sessionState.status = "paused";
-      sessionState.abortController.abort();
-      sessionState.executor.cancelAll();
-      if (this.sessionComponent) {
-        const metadata = await this.getSessionMetadata(sessionId);
-        await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "paused" }
-        });
-      }
-      await sessionState.eventBus.publish(createWorkflowEvent("workflow.paused", this.getRunIdFromSessionId(sessionId), {}));
-      logger.info(`[WorkflowEngine] Workflow paused: ${sessionId}`);
-    }
-    async stop(sessionId, reason) {
-      const sessionState = this.activeSessions.get(sessionId);
-      if (!sessionState) {
-        if (this.sessionComponent) {
-          await this.sessionComponent.update(sessionId, {
-            metadata: { status: "stopped" }
-          });
-        }
-        return;
-      }
-      sessionState.status = "stopped";
-      sessionState.abortController.abort();
-      sessionState.executor.cancelAll();
-      if (this.sessionComponent) {
-        const metadata = await this.getSessionMetadata(sessionId);
-        await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "stopped" }
-        });
-      }
-      await sessionState.eventBus.publish(createWorkflowEvent("workflow.stopped", this.getRunIdFromSessionId(sessionId), {
-        reason: reason ?? "User requested stop"
-      }));
-      this.cleanupSession(sessionState);
-    }
-    getSessionStatus(sessionId) {
-      const sessionState = this.activeSessions.get(sessionId);
-      return sessionState?.status ?? null;
-    }
-    isSessionActive(sessionId) {
-      return this.activeSessions.has(sessionId);
-    }
-    setupEventHandlers(sessionState) {
-      const { sessionId, eventBus, scheduler } = sessionState;
-      const runId = this.getRunIdFromSessionId(sessionId);
-      eventBus.on("node.completed", async (event) => {
-        if (event.type !== "node.completed")
-          return;
-        sessionState.nodeOutputs.set(event.node_id, event.output);
-        scheduler.markCompleted(event.node_id);
-        if (event.output && typeof event.output === "object" && "workflowHistory" in event.output) {
-          const messages = event.output.workflowHistory;
-          if (Array.isArray(messages)) {
-            sessionState.workflowHistory.push(...messages);
-          }
-        }
-        this.checkAndFinalize(sessionState);
-      });
-      eventBus.on("node.failed", async (event) => {
-        if (event.type !== "node.failed")
-          return;
-        scheduler.markFailed(event.node_id);
-        await this.failWorkflow(sessionState, new Error(event.error.message));
-      });
-      eventBus.on("node.interrupt", async (event) => {
-        if (event.type !== "node.interrupt")
-          return;
-        logger.info(`Workflow paused at node "${event.node_id}" - ask_user pending`);
-        sessionState.status = "paused";
-        sessionState.abortController.abort();
-        if (this.sessionComponent) {
-          const metadata = await this.getSessionMetadata(sessionId);
-          await this.sessionComponent.update(sessionId, {
-            metadata: { ...metadata, status: "paused" }
-          });
-        }
-        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);
-        sessionState.resolveCompleted({
-          runId,
-          status: "paused",
-          pendingNodeId: event.node_id,
-          query: event.query,
-          agentSessionId: event.agent_session_id
-        });
-      });
-    }
-    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 (restoredOutputs) {
-        for (const [nodeId, output] of restoredOutputs) {
-          nodeOutputs.set(nodeId, output);
-        }
-      }
-      const scheduleAvailableNodes = async () => {
-        const state = scheduler.getState();
-        const completedNodes = new Set(state.completed);
-        const readyNodes = scheduler.getReadyNodes(completedNodes);
-        const canStart = scheduler.canStartMore();
-        if (readyNodes.length === 0 || !canStart) {
-          return false;
-        }
-        let scheduled = 0;
-        for (const nodeId of readyNodes) {
-          if (!scheduler.canStartMore())
-            break;
-          if (scheduled >= (sessionState.config.parallelLimit ?? Infinity))
-            break;
-          await this.startNode(sessionState, nodeId, globalInput);
-          scheduled++;
-        }
-        return true;
-      };
-      if (pendingNodeId) {
-        await this.resumeNode(sessionState, pendingNodeId, {
-          agentSessionId,
-          userQuery: globalInput?.userQuery
-        });
-      } else {
-        await scheduleAvailableNodes();
-      }
-      while (sessionState.status === "running" && !abortController.signal.aborted) {
-        const state = scheduler.getState();
-        if (state.pending.length === 0 && state.running.length === 0) {
-          break;
-        }
-        try {
-          await this.waitForNextNodeEvent(sessionState, abortController.signal);
-        } catch {
-          break;
-        }
-        await scheduleAvailableNodes();
-      }
-    }
-    waitForNextNodeEvent(sessionState, signal) {
-      return new Promise((resolve) => {
-        const timeoutId = setTimeout(() => {
-          cleanup();
-          resolve();
-        }, 100);
-        const cleanup = () => {
-          clearTimeout(timeoutId);
-          sessionState.eventBus.off("node.completed", onCompleted);
-          sessionState.eventBus.off("node.failed", onFailed);
-        };
-        const onCompleted = (event) => {
-          if (event.type === "node.completed") {
-            cleanup();
-            resolve();
-          }
-        };
-        const onFailed = (event) => {
-          if (event.type === "node.failed") {
-            cleanup();
-            resolve();
-          }
-        };
-        sessionState.eventBus.on("node.completed", onCompleted);
-        sessionState.eventBus.on("node.failed", onFailed);
-        if (signal.aborted) {
-          cleanup();
-          resolve();
-        }
-      });
-    }
-    async startNode(sessionState, nodeId, input) {
-      const { scheduler, executor, eventBus, dagManager } = sessionState;
-      const sessionId = sessionState.sessionId;
-      const runId = this.getRunIdFromSessionId(sessionId);
-      scheduler.markStarted(nodeId);
-      await eventBus.publish(createWorkflowEvent("node.scheduled", runId, {
-        node_id: nodeId
-      }));
-      const nodeDef = dagManager.getNode(nodeId);
-      if (!nodeDef) {
-        scheduler.markFailed(nodeId);
-        return;
-      }
-      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) {
-          await eventBus.publish(createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId));
-          return;
-        }
-        scheduler.markFailed(nodeId);
-      });
-    }
-    async writeNodeStart(sessionId, nodeId, nodeType, input) {
-      if (this.sessionComponent) {
-        await this.sessionComponent.addMessage(sessionId, {
-          role: "workflow.node.start",
-          content: JSON.stringify({ input }),
-          metadata: {
-            type: "workflow.node.start",
-            workflowNodeId: nodeId,
-            workflowNodeType: nodeType,
-            timestamp: Date.now()
-          }
-        });
-      }
-    }
-    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.createExecutionContext(sessionState, nodeId, { userQuery: options?.userQuery }, true);
-      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);
-          }
-        }
-      }
-      executor.executeNode(nodeDef, context).catch((error) => {
-        if (error instanceof AskUserError) {
-          const event = createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId);
-          eventBus.publish(event);
-          return;
-        }
-        scheduler.markFailed(nodeId);
-      });
-    }
-    createExecutionContext(sessionState, nodeId, globalInput, forceGlobalInput) {
-      const nodeDef = sessionState.dagManager.getNode(nodeId);
-      const runId = this.getRunIdFromSessionId(sessionState.sessionId);
-      const deps = nodeDef.depends_on || [];
-      const input = {};
-      for (const depId of deps) {
-        const depOutput = sessionState.nodeOutputs.get(depId);
-        if (depOutput !== undefined) {
-          input[depId] = depOutput;
-        }
-      }
-      const analysis = sessionState.dagManager.analyze();
-      const isEntryNode = analysis.entryNodes.includes(nodeId);
-      if ((isEntryNode || forceGlobalInput) && globalInput) {
-        Object.assign(input, globalInput);
-      }
-      const askUser = (query) => {
-        throw new AskUserError(runId, sessionState.sessionId, nodeId, nodeDef.type, query);
-      };
-      return {
-        runId,
-        sessionId: sessionState.sessionId,
-        workflowName: sessionState.workflowName,
-        nodeId,
-        input,
-        previousOutputs: sessionState.nodeOutputs,
-        config: nodeDef.config ?? {},
-        debug: sessionState.config.debug,
-        eventBus: sessionState.eventBus,
-        nodeOutputs: sessionState.nodeOutputs,
-        workflowHistory: sessionState.workflowHistory,
-        sessionComponent: this.sessionComponent,
-        askUser
-      };
-    }
-    checkAndFinalize(sessionState) {
-      const state = sessionState.scheduler.getState();
-      if (state.pending.length === 0 && state.running.length === 0 && state.ready.length === 0) {
-        if (state.failed.length > 0) {
-          this.failWorkflow(sessionState, new Error(`Nodes failed: ${state.failed.join(", ")}`));
-        } else {
-          this.completeWorkflow(sessionState);
-        }
-      }
-    }
-    async completeWorkflow(sessionState) {
-      const durationMs = Date.now() - sessionState.startedAt.getTime();
-      const sessionId = sessionState.sessionId;
-      const runId = this.getRunIdFromSessionId(sessionId);
-      const output = {};
-      for (const [nodeId, nodeOutput] of sessionState.nodeOutputs) {
-        output[nodeId] = nodeOutput;
-      }
-      if (this.sessionComponent) {
-        const metadata = await this.getSessionMetadata(sessionId);
-        await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "completed" }
-        });
-      }
-      await sessionState.eventBus.publish(createWorkflowEvent("workflow.completed", runId, {
-        result: output,
-        duration_ms: durationMs
-      }), true);
-      sessionState.resolveCompleted({
-        runId,
-        status: "completed",
-        output,
-        durationMs
-      });
-      this.cleanupSession(sessionState);
-    }
-    async failWorkflow(sessionState, error) {
-      const durationMs = Date.now() - sessionState.startedAt.getTime();
-      const sessionId = sessionState.sessionId;
-      const runId = this.getRunIdFromSessionId(sessionId);
-      sessionState.executor.cancelAll();
-      if (this.sessionComponent) {
-        const metadata = await this.getSessionMetadata(sessionId);
-        await this.sessionComponent.update(sessionId, {
-          metadata: { ...metadata, status: "failed" }
-        });
-      }
-      await sessionState.eventBus.publish(createWorkflowEvent("workflow.failed", runId, {
-        error: { message: error.message, stack: error.stack },
-        failed_at: new Date().toISOString()
-      }), true);
-      sessionState.resolveCompleted({
-        runId,
-        status: "failed",
-        error: error.message,
-        durationMs
-      });
-      this.cleanupSession(sessionState);
-    }
-    cleanupSession(sessionState) {
-      sessionState.eventBus.clear();
-      this.activeSessions.delete(sessionState.sessionId);
-    }
-    async waitForCompletion(sessionId, timeout) {
-      const sessionState = this.activeSessions.get(sessionId);
-      if (!sessionState) {
-        throw new Error(`Session not found: ${sessionId}`);
-      }
-      const timeoutMs = timeout ?? 300000;
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`Workflow execution timeout: ${timeoutMs}ms`));
-        }, timeoutMs);
-      });
-      return Promise.race([
-        sessionState.completedPromise,
-        timeoutPromise
-      ]);
-    }
-    async getSessionMetadata(sessionId) {
-      if (!this.sessionComponent) {
-        return { type: "workflow", workflowId: "", workflowName: "", status: "running" };
-      }
-      const session = await this.sessionComponent.get(sessionId);
-      return session?.metadata || { type: "workflow", workflowId: "", workflowName: "", status: "running" };
-    }
-    findDefinitionForWorkflow(workflowIdOrName) {
-      if (!this.workflowRepository) {
-        return null;
-      }
-      let workflow = this.workflowRepository.getById(workflowIdOrName);
-      if (workflow)
-        return workflow.definition;
-      workflow = this.workflowRepository.getByName(workflowIdOrName);
-      if (workflow)
-        return workflow.definition;
-      return null;
-    }
-  };
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.createSession", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "createSession", null);
-  __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.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);
-  __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 })
-  ], WorkflowEngine.prototype, "startNode", null);
-  __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);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.checkAndFinalize", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "checkAndFinalize", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.completeWorkflow", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "completeWorkflow", null);
-  __legacyDecorateClassTS([
-    TracedAs("workflow.engine.failWorkflow", { recordParams: true, recordResult: true, log: true })
-  ], WorkflowEngine.prototype, "failWorkflow", null);
-});
-
-// src/env/workflow/engine/index.ts
-var exports_engine = {};
-__export(exports_engine, {
-  WorkflowEngine: () => WorkflowEngine,
-  Scheduler: () => Scheduler,
-  NodeRegistry: () => NodeRegistry,
-  Executor: () => Executor,
-  EventBus: () => EventBus,
-  DAGManager: () => DAGManager
-});
-var init_engine2 = __esm(() => {
-  init_event_bus();
-  init_dag_manager();
-  init_scheduler();
-  init_executor();
-  init_engine();
-  init_node_registry();
-});
-
-export { EventBus, DAGManager, Scheduler, Executor, NodeRegistry, WorkflowEngine, exports_engine, init_engine2 as init_engine };