@ai-setting/roy-agent-core 1.4.11 → 1.4.13

package/dist/shared/chunk-rncy3rtd.js

@@ -0,0 +1,3140 @@
+import {
+  AgentComponentAdapter,
+  AskUserError,
+  createNodeInterruptEvent,
+  init_agent_component_adapter,
+  init_workflow_hil
+} from "./chunk-0q6s9wm6.js";
+import {
+  createLogger,
+  getMaxOutput,
+  init_logger,
+  simplifyFilePath
+} from "./chunk-a9qmy3sc.js";
+import {
+  getTracerProvider,
+  init_tracer_provider
+} from "./chunk-q9j99fsm.js";
+import {
+  __esm,
+  __export,
+  __legacyDecorateClassTS,
+  __require
+} from "./chunk-wbkh7wat.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/types/event.ts
+import { z } from "zod";
+function createWorkflowEvent(type, runId, data) {
+  return {
+    type,
+    run_id: runId,
+    timestamp: Date.now(),
+    ...data
+  };
+}
+var BaseEventSchema, WorkflowStartedEventSchema, WorkflowPausedEventSchema, WorkflowResumedEventSchema, WorkflowStoppedEventSchema, WorkflowCompletedEventSchema, WorkflowFailedEventSchema, WorkflowOutputEventSchema, NodeScheduledEventSchema, NodeStartedEventSchema, NodeProgressEventSchema, NodeCompletedEventSchema, NodeFailedEventSchema, NodeSkippedEventSchema, NodeDataEventSchema, NodeAddedEventSchema, NodeRemovedEventSchema, ControlPauseEventSchema, ControlResumeEventSchema, ControlStopEventSchema, NodeInterruptEventSchema, WorkflowAskUserEventSchema, WorkflowEventSchema;
+var init_event = __esm(() => {
+  BaseEventSchema = z.object({
+    type: z.string(),
+    run_id: z.string(),
+    timestamp: z.number()
+  });
+  WorkflowStartedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.started"),
+    workflow_name: z.string(),
+    input: z.record(z.string(), z.unknown()).optional()
+  });
+  WorkflowPausedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.paused")
+  });
+  WorkflowResumedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.resumed")
+  });
+  WorkflowStoppedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.stopped"),
+    reason: z.string()
+  });
+  WorkflowCompletedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.completed"),
+    result: z.record(z.string(), z.unknown()).optional(),
+    duration_ms: z.number()
+  });
+  WorkflowFailedEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.failed"),
+    error: z.object({
+      message: z.string(),
+      stack: z.string().optional()
+    }),
+    failed_at: z.string()
+  });
+  WorkflowOutputEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.output"),
+    output: z.record(z.string(), z.unknown())
+  });
+  NodeScheduledEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.scheduled"),
+    node_id: z.string()
+  });
+  NodeStartedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.started"),
+    node_id: z.string(),
+    input: z.any(),
+    agentSessionId: z.string().optional(),
+    userResponse: z.string().optional()
+  });
+  NodeProgressEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.progress"),
+    node_id: z.string(),
+    progress: z.number(),
+    message: z.string().optional()
+  });
+  NodeCompletedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.completed"),
+    node_id: z.string(),
+    output: z.any(),
+    duration_ms: z.number()
+  });
+  NodeFailedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.failed"),
+    node_id: z.string(),
+    error: z.object({
+      message: z.string(),
+      stack: z.string().optional()
+    })
+  });
+  NodeSkippedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.skipped"),
+    node_id: z.string(),
+    reason: z.string()
+  });
+  NodeDataEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.data"),
+    from_node: z.string(),
+    to_node: z.string(),
+    data: z.any()
+  });
+  NodeAddedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.added"),
+    node_id: z.string(),
+    node: z.any()
+  });
+  NodeRemovedEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.removed"),
+    node_id: z.string()
+  });
+  ControlPauseEventSchema = BaseEventSchema.extend({
+    type: z.literal("control.pause")
+  });
+  ControlResumeEventSchema = BaseEventSchema.extend({
+    type: z.literal("control.resume")
+  });
+  ControlStopEventSchema = BaseEventSchema.extend({
+    type: z.literal("control.stop")
+  });
+  NodeInterruptEventSchema = BaseEventSchema.extend({
+    type: z.literal("node.interrupt"),
+    node_id: z.string(),
+    node_type: z.string(),
+    query: z.string()
+  });
+  WorkflowAskUserEventSchema = BaseEventSchema.extend({
+    type: z.literal("workflow.ask-user"),
+    session_id: z.string(),
+    node_id: z.string(),
+    node_type: z.string(),
+    query: z.string()
+  });
+  WorkflowEventSchema = z.union([
+    WorkflowStartedEventSchema,
+    WorkflowPausedEventSchema,
+    WorkflowResumedEventSchema,
+    WorkflowStoppedEventSchema,
+    WorkflowCompletedEventSchema,
+    WorkflowFailedEventSchema,
+    WorkflowOutputEventSchema,
+    NodeScheduledEventSchema,
+    NodeStartedEventSchema,
+    NodeProgressEventSchema,
+    NodeCompletedEventSchema,
+    NodeFailedEventSchema,
+    NodeSkippedEventSchema,
+    NodeDataEventSchema,
+    NodeAddedEventSchema,
+    NodeRemovedEventSchema,
+    ControlPauseEventSchema,
+    ControlResumeEventSchema,
+    ControlStopEventSchema,
+    NodeInterruptEventSchema,
+    WorkflowAskUserEventSchema
+  ]);
+});
+
+// src/env/workflow/types/workflow.ts
+import { z as z2 } from "zod";
+var DependsOnSchema, RetryConfigSchema, NodeDefinitionSchema, WorkflowConfigSchema, OutputDefinitionSchema, WorkflowMetadataSchema, WorkflowDefinitionSchema;
+var init_workflow = __esm(() => {
+  DependsOnSchema = z2.array(z2.string());
+  RetryConfigSchema = z2.object({
+    max_attempts: z2.number().min(1).default(1),
+    backoff: z2.enum(["fixed", "exponential"]).default("exponential"),
+    initial_delay: z2.number().min(0).default(1000)
+  });
+  NodeDefinitionSchema = z2.object({
+    id: z2.string().min(1, "Node ID is required"),
+    type: z2.string().min(1, "Node type is required"),
+    name: z2.string().optional(),
+    config: z2.record(z2.string(), z2.unknown()).optional().default({}),
+    depends_on: z2.array(z2.string()).optional(),
+    condition: z2.string().optional(),
+    retry: RetryConfigSchema.optional(),
+    timeout: z2.number().optional()
+  });
+  WorkflowConfigSchema = z2.object({
+    parallel_limit: z2.number().nullable().optional(),
+    timeout: z2.number().nullable().optional(),
+    retry: RetryConfigSchema.optional(),
+    debug: z2.boolean().optional()
+  });
+  OutputDefinitionSchema = z2.object({
+    name: z2.string(),
+    source: z2.string(),
+    path: z2.string()
+  });
+  WorkflowMetadataSchema = z2.object({
+    author: z2.string().optional(),
+    taskId: z2.number().optional(),
+    tags: z2.array(z2.string()).optional().default([]),
+    created_at: z2.string().optional(),
+    updated_at: z2.string().optional()
+  });
+  WorkflowDefinitionSchema = z2.object({
+    name: z2.string().min(1, "Workflow name is required"),
+    version: z2.string().default("1.0"),
+    description: z2.string().optional(),
+    config: WorkflowConfigSchema.optional().default({}),
+    nodes: z2.array(NodeDefinitionSchema).min(1, "At least one node is required"),
+    entry: z2.union([z2.string(), z2.array(z2.string())]).default("__default_entry__"),
+    outputs: z2.array(OutputDefinitionSchema).optional().default([]),
+    metadata: WorkflowMetadataSchema.optional().default({})
+  });
+});
+
+// src/env/workflow/types/workflow-message.ts
+import { z as z3 } from "zod";
+var WorkflowMessageRoleSchema;
+var init_workflow_message = __esm(() => {
+  init_workflow_hil();
+  WorkflowMessageRoleSchema = z3.enum([
+    "workflow.node.call",
+    "workflow.node.interrupt",
+    "workflow.node.result",
+    "workflow.node.resume"
+  ]);
+});
+
+// src/env/workflow/types/workflow-session.ts
+var init_workflow_session = () => {};
+
+// src/env/workflow/types/context.ts
+var init_context = () => {};
+
+// src/env/workflow/types/run.ts
+import { z as z4 } from "zod";
+var RunStatusSchema, NodeStatusSchema;
+var init_run = __esm(() => {
+  init_workflow_message();
+  RunStatusSchema = z4.enum([
+    "idle",
+    "running",
+    "paused",
+    "stopped",
+    "completed",
+    "failed"
+  ]);
+  NodeStatusSchema = z4.enum([
+    "pending",
+    "scheduled",
+    "started",
+    "running",
+    "completed",
+    "failed",
+    "skipped"
+  ]);
+});
+
+// src/env/workflow/types/index.ts
+var init_types = __esm(() => {
+  init_run();
+  init_workflow();
+  init_workflow_message();
+  init_workflow_session();
+  init_context();
+  init_workflow_hil();
+  init_event();
+  init_run();
+});
+
+// src/env/log-trace/decorator.ts
+function Traced(options) {
+  return function(target, propertyKey, descriptor) {
+    const originalFn = descriptor.value;
+    const spanName = options?.name || propertyKey;
+    descriptor.value = wrapFunction(originalFn, spanName, {
+      recordParams: options?.recordParams ?? true,
+      recordResult: options?.recordResult ?? false,
+      recordError: options?.recordError ?? true,
+      log: options?.log ?? false,
+      maxLogSize: options?.maxLogSize,
+      paramFilter: options?.paramFilter
+    });
+    return descriptor;
+  };
+}
+function TracedAs(name, options) {
+  return Traced({ name, ...options });
+}
+function TracedLightweight(options) {
+  return Traced({ recordParams: false, recordResult: false, log: options?.log ?? false, maxLogSize: options?.maxLogSize });
+}
+function wrapFunction(fn, name, options) {
+  const shouldLog = options?.log ?? false;
+  const getMaxLogSize = () => {
+    if (options?.maxLogSize !== undefined) {
+      return options.maxLogSize;
+    }
+    const configMaxOutput = getMaxOutput();
+    return configMaxOutput !== undefined ? configMaxOutput : 500;
+  };
+  const truncate = (obj) => {
+    if (obj === undefined)
+      return;
+    if (obj === null)
+      return null;
+    const maxLogSize = getMaxLogSize();
+    let str;
+    try {
+      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+    } catch (e) {
+      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    if (maxLogSize > 0 && str.length > maxLogSize) {
+      return str.slice(0, maxLogSize) + " [TRUNCATED]";
+    }
+    try {
+      return JSON.parse(str);
+    } catch {
+      return str;
+    }
+  };
+  const truncateString = (obj) => {
+    if (obj === undefined)
+      return "undefined";
+    if (obj === null)
+      return "null";
+    const maxLogSize = getMaxLogSize();
+    let str;
+    try {
+      str = typeof obj === "string" ? obj : JSON.stringify(obj, null, 0).replace(/\n/g, "");
+    } catch (e) {
+      str = `[Object with circular reference: ${e instanceof Error ? e.message : String(e)}]`;
+    }
+    return maxLogSize > 0 && str.length > maxLogSize ? str.slice(0, maxLogSize) + " [TRUNCATED]" : str;
+  };
+  const TRACE_LOG_PREFIX = "[TRACE]";
+  const getCallerLocation = () => {
+    const originalLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 15;
+    const err = new Error;
+    Error.captureStackTrace(err, getCallerLocation);
+    const stack = err.stack?.split(`
+`) || [];
+    Error.stackTraceLimit = originalLimit;
+    for (let i = 1;i < stack.length; i++) {
+      const line = stack[i];
+      if (line.includes("decorator.ts") || line.includes("decorator.js") || line.includes("logFn") || line.includes("getCallerLocation"))
+        continue;
+      const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
+      if (match) {
+        const filePath = match[1];
+        if (!filePath || filePath === "native")
+          continue;
+        const relativePath = simplifyFilePath(filePath);
+        return `${relativePath}:${match[2]}`;
+      }
+    }
+    return "";
+  };
+  const logFn = (event2, argsOrData, callerLocation) => {
+    if (!shouldLog)
+      return;
+    const logger = createLogger("traced:" + name);
+    const tag = event2 === "enter" ? ">>>" : event2 === "quit" ? "<<<" : "!!!";
+    const prefix = `${TRACE_LOG_PREFIX} ${tag} ${name}`;
+    const originalFnLocation = callerLocation || getCallerLocation();
+    const logMessage = (msg, data) => {
+      if (data !== undefined) {
+        logger.info(`${prefix} ${msg}: ${truncateString(data)}`, { callerLocation: originalFnLocation });
+      } else {
+        logger.info(`${prefix} ${msg}`, { callerLocation: originalFnLocation });
+      }
+    };
+    if (event2 === "enter") {
+      logMessage("enter", argsOrData);
+    } else if (event2 === "quit") {
+      logMessage("quit", options?.recordResult ? argsOrData : undefined);
+    } else {
+      logMessage("error", argsOrData);
+    }
+  };
+  return function(...args) {
+    const tracer = getTracerProvider().getTracer("roy-tracer");
+    const attributes = {};
+    if (options?.recordParams !== false) {
+      if (options?.paramFilter) {
+        attributes["params"] = truncate(options.paramFilter(args));
+      } else {
+        attributes["params"] = truncate(args);
+      }
+    }
+    const callerLocation = getCallerLocation();
+    logFn("enter", args, callerLocation);
+    const span = tracer.startSpan(name, { attributes });
+    try {
+      const result = fn.call(this, ...args);
+      if (result && typeof result === "object" && typeof result.then === "function") {
+        return result.then((resolved) => {
+          span.setAttribute("result", JSON.stringify(truncate(resolved)));
+          span.end(resolved);
+          logFn("quit", options?.recordResult ? resolved : undefined, callerLocation);
+          return resolved;
+        }, (rejected) => {
+          span.setAttribute("error", String(rejected));
+          span.end(undefined, rejected instanceof Error ? rejected : new Error(String(rejected)));
+          logFn("error", rejected.message, callerLocation);
+          throw rejected;
+        });
+      }
+      span.setAttribute("result", JSON.stringify(truncate(result)));
+      span.end(result);
+      logFn("quit", options?.recordResult ? result : undefined, callerLocation);
+      return result;
+    } catch (error) {
+      span.setAttribute("error", String(error));
+      span.end(undefined, error instanceof Error ? error : new Error(String(error)));
+      logFn("error", error.message, callerLocation);
+      throw error;
+    }
+  };
+}
+var init_decorator = __esm(() => {
+  init_tracer_provider();
+  init_logger();
+});
+
+// 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, context2) {
+      const nodeId = definition.id;
+      const nodeType = definition.type;
+      const agentSessionId = context2.agentSessionId;
+      await this.eventBus.publish(createWorkflowEvent("node.started", context2.runId, {
+        node_id: nodeId,
+        input: context2.input
+      }));
+      await this.writeNodeCall(context2.sessionId, nodeId, nodeType, context2.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, context2, abortController.signal, timeout);
+        } else {
+          result = await this.executeWithTimeout(definition, context2, abortController.signal, timeout);
+        }
+        if (result.error instanceof AskUserError) {
+          const interruptEvent = createNodeInterruptEvent(context2.runId, nodeId, nodeType, result.error.query, result.error.agentSessionId || agentSessionId);
+          await this.eventBus.publish(interruptEvent);
+          await this.writeNodeInterrupt(context2.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", context2.runId, {
+            node_id: nodeId,
+            error: {
+              message: errorMessage,
+              stack: errorStack
+            }
+          }));
+          await this.writeNodeResult(context2.sessionId, nodeId, nodeType, result.output, errorMessage, result.durationMs ?? 0);
+        } else {
+          await this.eventBus.publish(createWorkflowEvent("node.completed", context2.runId, {
+            node_id: nodeId,
+            output: result.output,
+            duration_ms: result.durationMs ?? 0
+          }));
+          await this.writeNodeResult(context2.sessionId, nodeId, nodeType, result.output, undefined, result.durationMs ?? 0);
+        }
+        return result;
+      } finally {
+        this.abortControllers.delete(nodeId);
+      }
+    }
+    async executeWithTimeout(definition, context2, signal, timeout) {
+      const startTime = Date.now();
+      const nodeContext = {
+        runId: context2.runId,
+        workflowName: context2.workflowName,
+        eventBus: this.eventBus,
+        debug: context2.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(context2),
+            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(context2);
+          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, context2, 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, context2, 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 writeNodeCall(sessionId, nodeId, nodeType, input, agentSessionId) {
+      if (!this.sessionComponent)
+        return;
+      const startTime = Date.now();
+      const part = {
+        type: "workflow-node-call",
+        nodeId,
+        nodeType,
+        input,
+        startTime,
+        ...agentSessionId ? { agentSessionId } : {}
+      };
+      const contentSummary = this.summarizeCall(nodeType, nodeId, input);
+      await this.sessionComponent.addMessage(sessionId, {
+        role: "workflow.node.call",
+        content: contentSummary,
+        parts: [part],
+        metadata: {
+          _workflowNodeMetadata: true,
+          type: "workflow.node.call",
+          workflowNodeId: nodeId,
+          workflowNodeType: nodeType,
+          ...agentSessionId ? { agentSessionId } : {}
+        }
+      });
+    }
+    summarizeCall(nodeType, nodeId, input) {
+      if (input === undefined || input === null) {
+        return `[${nodeType}] ${nodeId} started`;
+      }
+      if (typeof input === "object") {
+        const keys = Object.keys(input);
+        if (keys.length === 0) {
+          return `[${nodeType}] ${nodeId} started`;
+        }
+        const summary = keys.slice(0, 3).map((k) => `${k}: ${JSON.stringify(input[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 writeNodeResult(sessionId, nodeId, nodeType, output, error, durationMs) {
+      if (!this.sessionComponent)
+        return;
+      const part = {
+        type: "workflow-node-result",
+        nodeId,
+        nodeType,
+        output,
+        error,
+        durationMs
+      };
+      const contentSummary = this.summarizeResult(nodeId, output, error, durationMs);
+      await this.sessionComponent.addMessage(sessionId, {
+        role: "workflow.node.result",
+        content: contentSummary,
+        parts: [part],
+        metadata: {
+          _workflowNodeMetadata: true,
+          type: "workflow.node.result",
+          workflowNodeId: nodeId,
+          workflowNodeType: nodeType,
+          success: !error
+        }
+      });
+    }
+    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, response) {
+      if (!this.sessionComponent)
+        return;
+      const timestamp = Date.now();
+      const part = {
+        type: "workflow-node-resume",
+        response,
+        timestamp
+      };
+      await this.sessionComponent.addMessage(sessionId, {
+        role: "workflow.node.resume",
+        content: response,
+        parts: [part],
+        metadata: {
+          _workflowNodeMetadata: true
+        }
+      });
+    }
+  };
+  __legacyDecorateClassTS([
+    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);
+  __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);
+  __legacyDecorateClassTS([
+    TracedAs("workflow.executor.writeNodeResume", { recordParams: true, recordResult: true, log: true })
+  ], Executor.prototype, "writeNodeResume", null);
+});
+
+// src/env/workflow/nodes/tool-node.ts
+class ToolNode {
+  definition;
+  toolRegistry;
+  type = "tool";
+  id;
+  constructor(definition, toolRegistry) {
+    this.definition = definition;
+    this.toolRegistry = toolRegistry;
+    this.id = definition.id;
+  }
+  async execute(context2) {
+    const startTime = Date.now();
+    try {
+      const toolName = this.definition.config?.tool ?? this.definition.config?.toolName;
+      if (!toolName) {
+        throw new Error("Tool name is required. Please specify config.tool or config.toolName in the node definition.");
+      }
+      let tool;
+      if (this.toolRegistry.getTool) {
+        const result = this.toolRegistry.getTool(toolName);
+        if (!result) {
+          throw new Error(`Tool not found: ${toolName}`);
+        }
+        if ("tool" in result) {
+          tool = result.tool;
+        } else {
+          tool = result;
+        }
+      } else if (this.toolRegistry.getToolByName) {
+        tool = this.toolRegistry.getToolByName(toolName);
+      }
+      if (!tool) {
+        throw new Error(`Tool not found: ${toolName}`);
+      }
+      let input;
+      if (this.definition.config?.command !== undefined) {
+        const commandTemplate = this.definition.config.command;
+        const resolvedCommand = this.resolveTemplateReferences(commandTemplate, context2.previousOutputs, context2.input);
+        input = { command: resolvedCommand };
+        console.log(`[ToolNode] command input: ${resolvedCommand}`);
+      } else if (this.definition.config?.message !== undefined && Object.keys(this.definition.config).length === 1) {
+        const messageTemplate = this.definition.config.message;
+        const resolvedMessage = this.resolveTemplateReferences(messageTemplate, context2.previousOutputs, context2.input);
+        input = { message: resolvedMessage };
+        console.log(`[ToolNode] message input: ${resolvedMessage}`);
+      } else {
+        input = this.definition.config?.input ?? this.definition.config?.args ?? {};
+        input = this.resolveTemplateReferences(input, context2.previousOutputs, context2.input);
+      }
+      let output;
+      try {
+        const toolContext = {
+          session_id: context2.sessionId || `workflow_${context2.runId}`,
+          message_id: context2.nodeId,
+          metadata: {
+            workflowRunId: context2.runId,
+            workflowName: context2.workflowName,
+            nodeId: context2.nodeId
+          }
+        };
+        const executePromise = tool.execute(input, toolContext);
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => reject(new Error(`Tool ${toolName} execution timeout after 30s`)), 30000);
+        });
+        output = await Promise.race([executePromise, timeoutPromise]);
+      } catch (err) {
+        console.log(`[ToolNode] Tool ${toolName} doesn't support context, retrying without context...`);
+        output = await tool.execute(input);
+      }
+      return {
+        output,
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  resolveTemplateReferences(input, previousOutputs, workflowInput) {
+    if (typeof input === "string") {
+      const pureTemplate = this.extractPureTemplate(input) || this.extractDollarTemplate(input);
+      if (pureTemplate) {
+        return this.resolvePureTemplate(pureTemplate, previousOutputs, workflowInput);
+      }
+      return this.resolveStringTemplate(input, previousOutputs, workflowInput);
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.resolveTemplateReferences(item, previousOutputs, workflowInput));
+    }
+    if (input !== null && typeof input === "object") {
+      const resolved = {};
+      for (const [key, value] of Object.entries(input)) {
+        resolved[key] = this.resolveTemplateReferences(value, previousOutputs, workflowInput);
+      }
+      return resolved;
+    }
+    return input;
+  }
+  extractPureTemplate(str) {
+    const trimmed = str.trim();
+    if (trimmed.startsWith("{{") && trimmed.endsWith("}}") && trimmed.length > 4) {
+      const content = trimmed.slice(2, -2).trim();
+      if (!content.includes("{{") && !content.includes("}}")) {
+        return content;
+      }
+    }
+    return null;
+  }
+  extractDollarTemplate(str) {
+    const trimmed = str.trim();
+    if (trimmed.startsWith("${") && trimmed.endsWith("}") && trimmed.length > 3) {
+      const content = trimmed.slice(2, -1).trim();
+      if (!content.includes("${") && !content.includes("}")) {
+        return content;
+      }
+    }
+    return null;
+  }
+  resolvePureTemplate(templateContent, previousOutputs, workflowInput) {
+    const trimmed = templateContent.trim();
+    const originalTemplate = `{{${templateContent}}}`;
+    if (trimmed.startsWith("input.")) {
+      const value = this.getNestedValue(workflowInput, trimmed.slice(6));
+      return value !== undefined ? value : originalTemplate;
+    }
+    if (trimmed.startsWith("nodes.")) {
+      const path = trimmed.slice(6);
+      const segments = path.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return value !== undefined ? value : originalTemplate;
+    }
+    if (trimmed !== "input" && trimmed !== "nodes") {
+      const segments = trimmed.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return value !== undefined ? value : originalTemplate;
+    }
+    return originalTemplate;
+  }
+  resolveStringTemplate(template, previousOutputs, workflowInput) {
+    let resolved = template;
+    resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+      const value = this.getNestedValue(workflowInput, path.trim());
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\$\{input\.([^}]+)\}/g, (match, path) => {
+      const value = this.getNestedValue(workflowInput, path.trim());
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\{\{([^:.{}][^}]*?)\}\}/g, (match, path) => {
+      if (path.trim().startsWith("nodes.") || path.trim().startsWith("input.")) {
+        return match;
+      }
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\$\{([^}]+)\}/g, (match, path) => {
+      if (path.trim().startsWith("nodes.") || path.trim().startsWith("input.")) {
+        return match;
+      }
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const nodeOutput = this.resolvePath(nodeId, undefined, previousOutputs);
+      let extractedValue = this.extractFromWrapper(nodeOutput);
+      if (typeof extractedValue === "string" && restPath === "output") {
+        return this.stringifyValue(extractedValue, match);
+      }
+      if (restPath) {
+        const value = this.getNestedValue(extractedValue, restPath);
+        return this.stringifyValue(value, match);
+      } else {
+        return this.stringifyValue(extractedValue, match);
+      }
+    });
+    return resolved;
+  }
+  resolvePath(nodeId, path, previousOutputs) {
+    let nodeOutput = previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        nodeOutput = previousOutputs.get(normalizedUnderscore);
+      }
+      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+        nodeOutput = previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (nodeOutput === undefined) {
+      return;
+    }
+    if (path === undefined || path === "") {
+      return nodeOutput;
+    }
+    return this.getNestedValue(nodeOutput, path);
+  }
+  getNestedValue(obj, path) {
+    if (obj === null || obj === undefined) {
+      return;
+    }
+    const segments = path.split(".");
+    let current = obj;
+    for (const segment of segments) {
+      if (current === null || current === undefined) {
+        return;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+  extractFromWrapper(value) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    if (typeof value !== "object") {
+      return value;
+    }
+    let result;
+    if ("output" in value) {
+      result = value.output;
+    } else if ("result" in value && !("output" in value)) {
+      result = value.result;
+    } else {
+      return value;
+    }
+    if (typeof result === "string") {
+      return result.trimEnd();
+    }
+    return result;
+  }
+  stringifyValue(value, fallback) {
+    if (value === undefined || value === null) {
+      return fallback;
+    }
+    let str;
+    if (typeof value === "object") {
+      str = JSON.stringify(value);
+    } else {
+      str = String(value);
+    }
+    return str.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/"/g, "\\\"").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  }
+}
+var init_tool_node = () => {};
+
+// src/env/workflow/nodes/skill-node.ts
+class SkillNode {
+  definition;
+  skillRegistry;
+  type = "skill";
+  id;
+  constructor(definition, skillRegistry) {
+    this.definition = definition;
+    this.skillRegistry = skillRegistry;
+    this.id = definition.id;
+  }
+  async execute(context2) {
+    const startTime = Date.now();
+    try {
+      const skillName = this.definition.config?.skill;
+      if (!skillName) {
+        throw new Error("Skill name is required. Please specify config.skill in the node definition.");
+      }
+      const skill = this.skillRegistry.getSkill(skillName);
+      if (!skill) {
+        throw new Error(`Skill not found: ${skillName}`);
+      }
+      const input = this.definition.config?.input ?? {};
+      const resolvedInput = this.resolveTemplateReferences(input, context2.previousOutputs, context2.input);
+      const skillContext = {
+        runId: context2.runId,
+        workflowName: context2.workflowName,
+        nodeId: context2.nodeId,
+        debug: context2.debug
+      };
+      const output = await skill.invoke(resolvedInput, skillContext);
+      return {
+        output,
+        error: undefined,
+        durationMs: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        durationMs: Date.now() - startTime
+      };
+    }
+  }
+  resolveTemplateReferences(input, previousOutputs, workflowInput) {
+    if (typeof input === "string") {
+      const pureTemplate = this.extractPureTemplate(input);
+      if (pureTemplate) {
+        return this.resolvePureTemplate(pureTemplate, previousOutputs, workflowInput);
+      }
+      return this.resolveStringTemplate(input, previousOutputs, workflowInput);
+    }
+    if (Array.isArray(input)) {
+      return input.map((item) => this.resolveTemplateReferences(item, previousOutputs, workflowInput));
+    }
+    if (input !== null && typeof input === "object") {
+      const resolved = {};
+      for (const [key, value] of Object.entries(input)) {
+        resolved[key] = this.resolveTemplateReferences(value, previousOutputs, workflowInput);
+      }
+      return resolved;
+    }
+    return input;
+  }
+  extractPureTemplate(str) {
+    const trimmed = str.trim();
+    if (trimmed.startsWith("{{") && trimmed.endsWith("}}") && trimmed.length > 4) {
+      const content = trimmed.slice(2, -2).trim();
+      if (!content.includes("{{") && !content.includes("}}")) {
+        return content;
+      }
+    }
+    return null;
+  }
+  resolvePureTemplate(templateContent, previousOutputs, workflowInput) {
+    const trimmed = templateContent.trim();
+    const originalTemplate = `{{${templateContent}}}`;
+    if (trimmed.startsWith("input.")) {
+      const value = this.getNestedValue(workflowInput, trimmed.slice(6));
+      return value !== undefined ? value : originalTemplate;
+    }
+    if (trimmed.startsWith("nodes.")) {
+      const path = trimmed.slice(6);
+      const segments = path.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return value !== undefined ? value : originalTemplate;
+    }
+    if (trimmed !== "input" && trimmed !== "nodes") {
+      const segments = trimmed.split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return value !== undefined ? value : originalTemplate;
+    }
+    return originalTemplate;
+  }
+  resolveStringTemplate(template, previousOutputs, workflowInput) {
+    let resolved = template;
+    resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+      const value = this.getNestedValue(workflowInput, path.trim());
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\{\{([^:.{}][^}]*?)\}\}/g, (match, path) => {
+      if (path.trim().startsWith("nodes.") || path.trim().startsWith("input.")) {
+        return match;
+      }
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return this.stringifyValue(value, match);
+    });
+    resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+      const segments = path.trim().split(".");
+      const nodeId = segments[0];
+      const restPath = segments.slice(1).join(".") || undefined;
+      const value = this.resolvePath(nodeId, restPath, previousOutputs);
+      return this.stringifyValue(value, match);
+    });
+    return resolved;
+  }
+  resolvePath(nodeId, path, previousOutputs) {
+    let nodeOutput = previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      const normalizedUnderscore = nodeId.replace(/-/g, "_");
+      const normalizedHyphen = nodeId.replace(/_/g, "-");
+      if (normalizedUnderscore !== nodeId) {
+        nodeOutput = previousOutputs.get(normalizedUnderscore);
+      }
+      if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+        nodeOutput = previousOutputs.get(normalizedHyphen);
+      }
+    }
+    if (nodeOutput === undefined) {
+      return;
+    }
+    let value = this.extractFromWrapper(nodeOutput);
+    if (!path) {
+      return value;
+    }
+    let segments = path.split(".");
+    if (segments.length > 1 && (segments[0] === "output" || segments[0] === "result" || segments[0] === "metadata")) {
+      segments = segments.slice(1);
+    }
+    let current = value;
+    for (const segment of segments) {
+      if (current === null || current === undefined) {
+        return;
+      }
+      current = current[segment];
+    }
+    return current;
+  }
+  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);
+  }
+  stringifyValue(value, originalTemplate) {
+    if (value === undefined) {
+      return originalTemplate;
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+}
+var init_skill_node = () => {};
+
+// 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(context2) {
+      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, context2);
+        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 userResponse = context2.userResponse;
+        let agentSessionId = context2.agentSessionId;
+        if (!userResponse && context2.sessionComponent && !agentSessionId) {
+          agentSessionId = await this.createAgentSubSession(context2);
+          context2.agentSessionId = agentSessionId;
+        }
+        const agentConfig = {
+          type: agentType,
+          prompt: resolvedPrompt,
+          options: {
+            timeout: options.timeout,
+            model: options.model,
+            allowedTools: ["ask_user"]
+          },
+          workflowHistory: context2.workflowHistory,
+          nodeId: this.definition.id,
+          agentSessionId
+        };
+        const resumeOptions = userResponse ? { userResponse, agentSessionId } : undefined;
+        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 = context2.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(context2) {
+      const sessionComponent = context2.sessionComponent;
+      if (!sessionComponent) {
+        return "";
+      }
+      const agentSessionId = `agent_${this.definition.id}_${Date.now()}`;
+      await sessionComponent.create({
+        id: agentSessionId,
+        title: `Agent: ${this.definition.id}`,
+        metadata: {
+          type: "agent",
+          parentSessionId: context2.sessionId,
+          nodeId: this.definition.id,
+          workflowName: context2.workflowName
+        }
+      });
+      const workflowSession = await sessionComponent.get(context2.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(context2.sessionId, {
+          metadata: {
+            ...metadata,
+            agentSessions
+          }
+        });
+      }
+      return agentSessionId;
+    }
+    resolveTemplate(template, context2) {
+      if (!template) {
+        return "";
+      }
+      let resolved = template;
+      resolved = resolved.replace(/\{\{input\.([^}]+)\}\}/g, (match, path) => {
+        const value = this.getNestedValue(context2.input, path);
+        return this.stringifyValue(value, match);
+      });
+      resolved = resolved.replace(/\{\{nodes\.([^}]+)\}\}/g, (match, path) => {
+        const segments = path.split(".");
+        const nodeId = segments[0];
+        let nodeOutput = context2.previousOutputs.get(nodeId);
+        if (nodeOutput === undefined) {
+          const normalizedUnderscore = nodeId.replace(/-/g, "_");
+          const normalizedHyphen = nodeId.replace(/_/g, "-");
+          if (normalizedUnderscore !== nodeId) {
+            nodeOutput = context2.previousOutputs.get(normalizedUnderscore);
+          }
+          if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+            nodeOutput = context2.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 = context2.previousOutputs.get(nodeId);
+        if (nodeOutput === undefined) {
+          const normalizedUnderscore = nodeId.replace(/-/g, "_");
+          const normalizedHyphen = nodeId.replace(/_/g, "-");
+          if (normalizedUnderscore !== nodeId) {
+            nodeOutput = context2.previousOutputs.get(normalizedUnderscore);
+          }
+          if (nodeOutput === undefined && normalizedHyphen !== nodeId) {
+            nodeOutput = context2.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/workflow-node.ts
+class WorkflowNode {
+  workflowRunner;
+  type = "workflow";
+  id;
+  config;
+  constructor(definition, workflowRunner) {
+    this.workflowRunner = workflowRunner;
+    this.id = definition.id;
+    this.config = definition.config ?? {};
+  }
+  async execute(context2) {
+    const startTime = Date.now();
+    try {
+      const workflowName = this.config.workflow_name;
+      if (!workflowName) {
+        throw new Error("workflow_name is required in config. Please specify config.workflow_name in the node definition.");
+      }
+      const previousOutputs = context2.previousOutputs ?? this.convertToMap(context2.nodeOutputs ?? {});
+      const resolvedInput = this.resolveInput(this.config.input ?? {}, previousOutputs);
+      const result = await this.workflowRunner.run(workflowName, resolvedInput);
+      const success = result.status === "completed";
+      return {
+        success,
+        output: result.output,
+        error: success ? undefined : result.error,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: undefined,
+        error: error instanceof Error ? error : new Error(String(error)),
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  convertToMap(nodeOutputs) {
+    const map = new Map;
+    for (const [nodeId, result] of Object.entries(nodeOutputs)) {
+      map.set(nodeId, result.output);
+    }
+    return map;
+  }
+  resolveInput(input, previousOutputs) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(input)) {
+      resolved[key] = this.resolveValue(value, previousOutputs);
+    }
+    return resolved;
+  }
+  resolveValue(value, previousOutputs) {
+    if (typeof value === "string") {
+      return this.resolveStringTemplate(value, previousOutputs);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.resolveValue(item, previousOutputs));
+    }
+    if (value !== null && typeof value === "object") {
+      const resolved = {};
+      for (const [k, v] of Object.entries(value)) {
+        resolved[k] = this.resolveValue(v, previousOutputs);
+      }
+      return resolved;
+    }
+    return value;
+  }
+  resolveStringTemplate(template, previousOutputs) {
+    const templatePattern = /\{\{([^}]+)\}\}/g;
+    return template.replace(templatePattern, (match, path) => {
+      const trimmedPath = path.trim();
+      const value = this.resolvePath(trimmedPath, previousOutputs);
+      if (value !== undefined) {
+        return this.stringifyValue(value, match);
+      }
+      return match;
+    });
+  }
+  resolvePath(path, previousOutputs) {
+    const segments = path.split(".");
+    if (segments.length === 0) {
+      return;
+    }
+    const nodeId = segments[0];
+    let nodeOutput = previousOutputs.get(nodeId);
+    if (nodeOutput === undefined) {
+      return;
+    }
+    nodeOutput = this.extractFromWrapper(nodeOutput);
+    if (segments.length === 1) {
+      return nodeOutput;
+    }
+    let current = 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 (current === null || current === undefined) {
+        return;
+      }
+      current = current[segments[i]];
+    }
+    return current;
+  }
+  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;
+  }
+  stringifyValue(value, originalTemplate) {
+    if (value === undefined) {
+      return originalTemplate;
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return JSON.stringify(value);
+  }
+}
+var init_workflow_node = () => {};
+
+// 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(context2) {
+    const query = this.config.query || "确认继续吗？";
+    const options = this.config.options;
+    const fullQuery = options ? `${query} (选项: ${options.join(", ")})` : query;
+    await context2.eventBus.publish(createNodeInterruptEvent(context2.runId, this.id, this.type, fullQuery));
+    throw new AskUserError(context2.runId, context2.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, context2) {
+    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, context2);
+  }
+}
+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(workflow2, options) {
+      const definition = "definition" in workflow2 ? workflow2.definition : workflow2;
+      const workflowId = "id" in workflow2 ? workflow2.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"
+          };
+          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" };
+      }
+      const messages = this.sessionComponent ? await this.sessionComponent.getMessages(sessionId) : [];
+      const { inferNextNode } = await import("./chunk-25x2pdtp.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;
+      }
+      const userResponse = typeof options?.input === "string" ? options.input : undefined;
+      this.scheduleAndExecute(sessionState, {
+        input: options?.input,
+        pendingNodeId,
+        agentSessionId,
+        userResponse
+      }).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(workflow2, options) {
+      const definition = "definition" in workflow2 ? workflow2.definition : workflow2;
+      const workflowId = "id" in workflow2 ? workflow2.id : `inline_${definition.name}`;
+      const workflowName = definition.name;
+      const sessionId = await this.createSession(workflow2, 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 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) {
+        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 (event2) => {
+        if (event2.type !== "node.completed")
+          return;
+        sessionState.nodeOutputs.set(event2.node_id, event2.output);
+        scheduler.markCompleted(event2.node_id);
+        if (event2.output && typeof event2.output === "object" && "workflowHistory" in event2.output) {
+          const messages = event2.output.workflowHistory;
+          if (Array.isArray(messages)) {
+            sessionState.workflowHistory.push(...messages);
+          }
+        }
+        this.checkAndFinalize(sessionState);
+      });
+      eventBus.on("node.failed", async (event2) => {
+        if (event2.type !== "node.failed")
+          return;
+        scheduler.markFailed(event2.node_id);
+        await this.failWorkflow(sessionState, new Error(event2.error.message));
+      });
+      eventBus.on("node.interrupt", async (event2) => {
+        if (event2.type !== "node.interrupt")
+          return;
+        logger.info(`Workflow paused at node "${event2.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: event2.node_id,
+          query: event2.query
+        }));
+        await this.writeNodeInterrupt(sessionId, event2.node_id, event2.node_type, event2.query, event2.agent_session_id);
+        sessionState.resolveCompleted({
+          runId,
+          status: "paused",
+          pendingNodeId: event2.node_id,
+          query: event2.query,
+          agentSessionId: event2.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, userResponse, 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,
+          userResponse
+        });
+      } 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 = (event2) => {
+          if (event2.type === "node.completed") {
+            cleanup();
+            resolve();
+          }
+        };
+        const onFailed = (event2) => {
+          if (event2.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.writeNodeCall(sessionId, nodeId, nodeDef.type, input);
+      const context2 = this.createExecutionContext(sessionState, nodeId, input);
+      executor.executeNode(nodeDef, context2).catch(async (error) => {
+        if (error instanceof AskUserError) {
+          await eventBus.publish(createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId));
+          return;
+        }
+        scheduler.markFailed(nodeId);
+      });
+    }
+    async writeNodeCall(sessionId, nodeId, nodeType, input) {
+      if (this.sessionComponent) {
+        await this.sessionComponent.addMessage(sessionId, {
+          role: "workflow.node.call",
+          content: JSON.stringify({ input }),
+          metadata: {
+            type: "workflow.node.call",
+            workflowNodeId: nodeId,
+            workflowNodeType: nodeType,
+            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 eventBus.publish(createWorkflowEvent("node.started", runId, {
+        node_id: nodeId,
+        agentSessionId: options?.agentSessionId,
+        userResponse: options?.userResponse
+      }));
+      const nodeDef = dagManager.getNode(nodeId);
+      if (!nodeDef) {
+        scheduler.markFailed(nodeId);
+        return;
+      }
+      const context2 = this.createExecutionContext(sessionState, nodeId, undefined);
+      if (options?.agentSessionId || options?.userResponse) {
+        context2.agentSessionId = options.agentSessionId;
+        context2.userResponse = options.userResponse;
+      }
+      executor.executeNode(nodeDef, context2).catch((error) => {
+        if (error instanceof AskUserError) {
+          const event2 = createNodeInterruptEvent(runId, nodeId, nodeDef.type, error.query, error.agentSessionId);
+          eventBus.publish(event2);
+          return;
+        }
+        scheduler.markFailed(nodeId);
+      });
+    }
+    createExecutionContext(sessionState, nodeId, globalInput) {
+      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();
+      if (analysis.entryNodes.includes(nodeId) && 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 workflow2 = this.workflowRepository.getById(workflowIdOrName);
+      if (workflow2)
+        return workflow2.definition;
+      workflow2 = this.workflowRepository.getByName(workflowIdOrName);
+      if (workflow2)
+        return workflow2.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.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);
+  __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([
+    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 { Traced, TracedAs, TracedLightweight, wrapFunction, init_decorator, EventBus, DAGManager, Scheduler, Executor, NodeRegistry, WorkflowEngine, exports_engine, init_engine2 as init_engine };