@ai-setting/roy-agent-core 1.4.12 → 1.4.14

package/dist/env/workflow/engine/index.js

@@ -1,4391 +0,0 @@
-// @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __legacyDecorateClassTS = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1;i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// packages/core/src/env/workflow/types/workflow.ts
-import { z } from "zod";
-async function getYamlParser() {
-  if (!yamlParser) {
-    yamlParser = await import("yaml");
-  }
-  return yamlParser;
-}
-async function parseWorkflowFile(content, filename) {
-  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
-  const isJson = filename.endsWith(".json");
-  let definition;
-  if (isYaml) {
-    const yaml = await getYamlParser();
-    definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
-  } else if (isJson) {
-    definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
-  } else {
-    try {
-      definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
-    } catch {
-      const yaml = await getYamlParser();
-      definition = WorkflowDefinitionSchema.parse(yaml.parse(content));
-    }
-  }
-  return {
-    format: isYaml ? "yaml" : "json",
-    definition
-  };
-}
-function parseWorkflowFileSync(content, filename) {
-  const isYaml = filename.endsWith(".yaml") || filename.endsWith(".yml");
-  const isJson = filename.endsWith(".json");
-  let definition;
-  if (isJson) {
-    definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
-  } else if (isYaml) {
-    throw new Error("Synchronous YAML parsing not supported. Use parseWorkflowFile() instead.");
-  } else {
-    try {
-      definition = WorkflowDefinitionSchema.parse(JSON.parse(content));
-    } catch {
-      throw new Error("Cannot auto-detect format. Please use .yaml, .yml, or .json extension.");
-    }
-  }
-  return {
-    format: isJson ? "json" : "yaml",
-    definition
-  };
-}
-var DependsOnSchema, RetryConfigSchema, NodeDefinitionSchema, WorkflowConfigSchema, OutputDefinitionSchema, WorkflowMetadataSchema, WorkflowDefinitionSchema, yamlParser = null;
-var init_workflow = __esm(() => {
-  DependsOnSchema = z.array(z.string());
-  RetryConfigSchema = z.object({
-    max_attempts: z.number().min(1).default(1),
-    backoff: z.enum(["fixed", "exponential"]).default("exponential"),
-    initial_delay: z.number().min(0).default(1000)
-  });
-  NodeDefinitionSchema = z.object({
-    id: z.string().min(1, "Node ID is required"),
-    type: z.string().min(1, "Node type is required"),
-    name: z.string().optional(),
-    config: z.record(z.string(), z.unknown()).optional().default({}),
-    depends_on: z.array(z.string()).optional(),
-    condition: z.string().optional(),
-    retry: RetryConfigSchema.optional(),
-    timeout: z.number().optional()
-  });
-  WorkflowConfigSchema = z.object({
-    parallel_limit: z.number().nullable().optional(),
-    timeout: z.number().nullable().optional(),
-    retry: RetryConfigSchema.optional(),
-    debug: z.boolean().optional()
-  });
-  OutputDefinitionSchema = z.object({
-    name: z.string(),
-    source: z.string(),
-    path: z.string()
-  });
-  WorkflowMetadataSchema = z.object({
-    author: z.string().optional(),
-    taskId: z.number().optional(),
-    tags: z.array(z.string()).optional().default([]),
-    created_at: z.string().optional(),
-    updated_at: z.string().optional()
-  });
-  WorkflowDefinitionSchema = z.object({
-    name: z.string().min(1, "Workflow name is required"),
-    version: z.string().default("1.0"),
-    description: z.string().optional(),
-    config: WorkflowConfigSchema.optional().default({}),
-    nodes: z.array(NodeDefinitionSchema).min(1, "At least one node is required"),
-    entry: z.union([z.string(), z.array(z.string())]).default("__default_entry__"),
-    outputs: z.array(OutputDefinitionSchema).optional().default([]),
-    metadata: WorkflowMetadataSchema.optional().default({})
-  });
-});
-
-// packages/core/src/env/workflow/types/workflow-hil.ts
-function createNodeInterruptEvent(runId, nodeId, nodeType, query, agentSessionId) {
-  return {
-    type: "node.interrupt",
-    run_id: runId,
-    timestamp: Date.now(),
-    node_id: nodeId,
-    node_type: nodeType,
-    query,
-    ...agentSessionId ? { agent_session_id: agentSessionId } : {}
-  };
-}
-function createWorkflowAskUserEvent(runId, sessionId, nodeId, nodeType, query) {
-  return {
-    type: "workflow.ask-user",
-    run_id: runId,
-    timestamp: Date.now(),
-    session_id: sessionId,
-    node_id: nodeId,
-    node_type: nodeType,
-    query
-  };
-}
-var AskUserError;
-var init_workflow_hil = __esm(() => {
-  AskUserError = class AskUserError extends Error {
-    runId;
-    sessionId;
-    nodeId;
-    nodeType;
-    query;
-    agentSessionId;
-    timestamp;
-    type = "ask-user";
-    name = "AskUserError";
-    constructor(runId, sessionId, nodeId, nodeType, query, agentSessionId, timestamp = Date.now()) {
-      super(`[${nodeType}:${nodeId}] Ask user: ${query}`);
-      this.runId = runId;
-      this.sessionId = sessionId;
-      this.nodeId = nodeId;
-      this.nodeType = nodeType;
-      this.query = query;
-      this.agentSessionId = agentSessionId;
-      this.timestamp = timestamp;
-    }
-    toEvent() {
-      return {
-        type: "workflow.ask-user",
-        run_id: this.runId,
-        timestamp: this.timestamp,
-        session_id: this.sessionId,
-        node_id: this.nodeId,
-        node_type: this.nodeType,
-        query: this.query
-      };
-    }
-  };
-});
-
-// packages/core/src/env/workflow/types/workflow-message.ts
-import { z as z2 } from "zod";
-var WorkflowMessageRoleSchema;
-var init_workflow_message = __esm(() => {
-  init_workflow_hil();
-  WorkflowMessageRoleSchema = z2.enum([
-    "workflow.node.call",
-    "workflow.node.interrupt",
-    "workflow.node.result",
-    "workflow.node.resume"
-  ]);
-});
-
-// packages/core/src/env/workflow/types/workflow-session.ts
-function isWorkflowSessionMetadata(metadata) {
-  if (typeof metadata !== "object" || metadata === null || !("type" in metadata) || metadata.type !== "workflow") {
-    return false;
-  }
-  const m = metadata;
-  if (!m.workflowId || typeof m.workflowId !== "string") {
-    return false;
-  }
-  if (!m.workflowName || typeof m.workflowName !== "string") {
-    return false;
-  }
-  if (!m.status || typeof m.status !== "string") {
-    return false;
-  }
-  const validStatuses = ["running", "paused", "completed", "failed", "stopped"];
-  if (!validStatuses.includes(m.status)) {
-    return false;
-  }
-  return true;
-}
-function getWorkflowSessionStatus(metadata) {
-  return metadata.status || "running";
-}
-// packages/core/src/env/workflow/types/event.ts
-import { z as z3 } 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 = z3.object({
-    type: z3.string(),
-    run_id: z3.string(),
-    timestamp: z3.number()
-  });
-  WorkflowStartedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.started"),
-    workflow_name: z3.string(),
-    input: z3.record(z3.string(), z3.unknown()).optional()
-  });
-  WorkflowPausedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.paused")
-  });
-  WorkflowResumedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.resumed")
-  });
-  WorkflowStoppedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.stopped"),
-    reason: z3.string()
-  });
-  WorkflowCompletedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.completed"),
-    result: z3.record(z3.string(), z3.unknown()).optional(),
-    duration_ms: z3.number()
-  });
-  WorkflowFailedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.failed"),
-    error: z3.object({
-      message: z3.string(),
-      stack: z3.string().optional()
-    }),
-    failed_at: z3.string()
-  });
-  WorkflowOutputEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.output"),
-    output: z3.record(z3.string(), z3.unknown())
-  });
-  NodeScheduledEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.scheduled"),
-    node_id: z3.string()
-  });
-  NodeStartedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.started"),
-    node_id: z3.string(),
-    input: z3.any(),
-    agentSessionId: z3.string().optional(),
-    userResponse: z3.string().optional()
-  });
-  NodeProgressEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.progress"),
-    node_id: z3.string(),
-    progress: z3.number(),
-    message: z3.string().optional()
-  });
-  NodeCompletedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.completed"),
-    node_id: z3.string(),
-    output: z3.any(),
-    duration_ms: z3.number()
-  });
-  NodeFailedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.failed"),
-    node_id: z3.string(),
-    error: z3.object({
-      message: z3.string(),
-      stack: z3.string().optional()
-    })
-  });
-  NodeSkippedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.skipped"),
-    node_id: z3.string(),
-    reason: z3.string()
-  });
-  NodeDataEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.data"),
-    from_node: z3.string(),
-    to_node: z3.string(),
-    data: z3.any()
-  });
-  NodeAddedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.added"),
-    node_id: z3.string(),
-    node: z3.any()
-  });
-  NodeRemovedEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.removed"),
-    node_id: z3.string()
-  });
-  ControlPauseEventSchema = BaseEventSchema.extend({
-    type: z3.literal("control.pause")
-  });
-  ControlResumeEventSchema = BaseEventSchema.extend({
-    type: z3.literal("control.resume")
-  });
-  ControlStopEventSchema = BaseEventSchema.extend({
-    type: z3.literal("control.stop")
-  });
-  NodeInterruptEventSchema = BaseEventSchema.extend({
-    type: z3.literal("node.interrupt"),
-    node_id: z3.string(),
-    node_type: z3.string(),
-    query: z3.string()
-  });
-  WorkflowAskUserEventSchema = BaseEventSchema.extend({
-    type: z3.literal("workflow.ask-user"),
-    session_id: z3.string(),
-    node_id: z3.string(),
-    node_type: z3.string(),
-    query: z3.string()
-  });
-  WorkflowEventSchema = z3.union([
-    WorkflowStartedEventSchema,
-    WorkflowPausedEventSchema,
-    WorkflowResumedEventSchema,
-    WorkflowStoppedEventSchema,
-    WorkflowCompletedEventSchema,
-    WorkflowFailedEventSchema,
-    WorkflowOutputEventSchema,
-    NodeScheduledEventSchema,
-    NodeStartedEventSchema,
-    NodeProgressEventSchema,
-    NodeCompletedEventSchema,
-    NodeFailedEventSchema,
-    NodeSkippedEventSchema,
-    NodeDataEventSchema,
-    NodeAddedEventSchema,
-    NodeRemovedEventSchema,
-    ControlPauseEventSchema,
-    ControlResumeEventSchema,
-    ControlStopEventSchema,
-    NodeInterruptEventSchema,
-    WorkflowAskUserEventSchema
-  ]);
-});
-
-// packages/core/src/env/workflow/types/run.ts
-import { z as z4 } from "zod";
-function createNodeExecutionContext(params) {
-  return {
-    ...params,
-    askUser: (query) => {
-      throw new AskUserError(params.runId, params.sessionId, params.nodeId, "unknown", query);
-    }
-  };
-}
-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"
-  ]);
-});
-
-// packages/core/src/env/workflow/types/index.ts
-var init_types = __esm(() => {
-  init_run();
-  init_workflow();
-  init_workflow_message();
-  init_workflow_hil();
-  init_event();
-  init_run();
-});
-
-// packages/core/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 (event2) => {
-      if (executed) {
-        return;
-      }
-      executed = true;
-      try {
-        await handler(event2);
-      } 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(event2, waitForHandlers = false) {
-    const handlers = this.handlers.get(event2.type);
-    const handlerPromises = [];
-    if (handlers) {
-      for (const handler of handlers) {
-        const promise = this.executeHandler(handler, event2);
-        handlerPromises.push(promise);
-      }
-    }
-    for (const handler of this.wildcardHandlers) {
-      const promise = this.executeHandler(handler, event2);
-      handlerPromises.push(promise);
-    }
-    if (waitForHandlers && handlerPromises.length > 0) {
-      await Promise.allSettled(handlerPromises);
-    }
-  }
-  async executeHandler(handler, event2) {
-    try {
-      await handler(event2);
-    } 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
-    };
-  }
-}
-
-// packages/core/src/env/workflow/engine/dag-manager.ts
-class DAGManager {
-  workflow;
-  nodeMap;
-  extendedDefinition = null;
-  cachedAnalysis = null;
-  constructor(workflow2) {
-    if (!workflow2.nodes || workflow2.nodes.length === 0) {
-      throw new Error("At least one node is required");
-    }
-    this.workflow = workflow2;
-    this.nodeMap = new Map;
-    for (const node of workflow2.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;
-  }
-}
-
-// packages/core/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;
-  }
-}
-
-// packages/core/src/env/log-trace/span-storage.ts
-var exports_span_storage = {};
-__export(exports_span_storage, {
-  SQLiteSpanStorage: () => SQLiteSpanStorage
-});
-
-class SQLiteSpanStorage {
-  db = null;
-  dbPath;
-  initialized = false;
-  constructor(dbPath) {
-    if (!dbPath) {
-      throw new Error("SQLiteSpanStorage requires a valid dbPath parameter");
-    }
-    if (dbPath === ":memory:") {
-      throw new Error("SQLiteSpanStorage does not support :memory: mode. Use a file path instead.");
-    }
-    this.dbPath = dbPath;
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    const { Database } = __require("bun:sqlite");
-    const fs = __require("fs");
-    const path = __require("path");
-    const dir = path.dirname(this.dbPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new Database(this.dbPath);
-    this.db.run("PRAGMA journal_mode=WAL");
-    this.db.run("PRAGMA busy_timeout=5000");
-    this.db.run("PRAGMA synchronous=NORMAL");
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS span (
-        span_id TEXT PRIMARY KEY,
-        trace_id TEXT NOT NULL,
-        parent_span_id TEXT,
-        name TEXT NOT NULL,
-        kind TEXT NOT NULL,
-        status TEXT NOT NULL,
-        start_time INTEGER NOT NULL,
-        end_time INTEGER,
-        attributes TEXT,
-        result TEXT,
-        error TEXT,
-        time_created INTEGER NOT NULL
-      )
-    `);
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_trace ON span(trace_id)");
-    this.db.run("CREATE INDEX IF NOT EXISTS idx_span_parent ON span(parent_span_id)");
-    this.initialized = true;
-  }
-  save(span) {
-    if (!this.db)
-      return;
-    const stmt = this.db.prepare(`
-      INSERT OR REPLACE INTO span 
-      (span_id, trace_id, parent_span_id, name, kind, status, start_time, end_time, attributes, result, error, time_created)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-    const resultValue = span.result !== undefined && span.result !== null ? typeof span.result === "string" ? span.result : JSON.stringify(span.result) : null;
-    stmt.run(span.spanId, span.traceId, span.parentSpanId || null, span.name, span.kind, span.status, span.startTime, span.endTime || null, JSON.stringify(span.attributes), resultValue, span.error || null, Date.now());
-  }
-  saveBatch(spans) {
-    for (const span of spans) {
-      this.save(span);
-    }
-  }
-  findByTraceId(traceId) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare("SELECT * FROM span WHERE trace_id = ?").all(traceId);
-    return this.buildTree(rows.map(this.rowToSpan));
-  }
-  findBySpanId(spanId) {
-    if (!this.db)
-      return;
-    const row = this.db.prepare("SELECT * FROM span WHERE span_id = ?").get(spanId);
-    return row ? this.rowToSpan(row) : undefined;
-  }
-  listTraces(limit = 10) {
-    if (!this.db)
-      return [];
-    const rows = this.db.prepare(`
-      SELECT trace_id, 
-             MIN(start_time) as start_time,
-             MAX(end_time) as end_time,
-             COUNT(*) as span_count
-      FROM span 
-      GROUP BY trace_id 
-      ORDER BY start_time DESC 
-      LIMIT ?
-    `).all(limit);
-    return rows.map((row) => ({
-      traceId: row.trace_id,
-      rootSpanName: "unknown",
-      startTime: row.start_time,
-      endTime: row.end_time,
-      duration: row.end_time - row.start_time,
-      spanCount: row.span_count,
-      status: "ok"
-    }));
-  }
-  deleteByTraceId(traceId) {
-    if (this.db) {
-      this.db.prepare("DELETE FROM span WHERE trace_id = ?").run(traceId);
-    }
-  }
-  close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-  rowToSpan(row) {
-    return {
-      traceId: row.trace_id,
-      spanId: row.span_id,
-      parentSpanId: row.parent_span_id,
-      name: row.name,
-      kind: row.kind,
-      status: row.status,
-      startTime: row.start_time,
-      endTime: row.end_time,
-      attributes: row.attributes ? JSON.parse(row.attributes) : {},
-      result: row.result || undefined,
-      error: row.error || undefined
-    };
-  }
-  buildTree(spans) {
-    const spanMap = new Map;
-    const roots = [];
-    for (const span of spans) {
-      spanMap.set(span.spanId, { ...span, children: [] });
-    }
-    for (const span of spanMap.values()) {
-      if (span.parentSpanId) {
-        const parent = spanMap.get(span.parentSpanId);
-        if (parent) {
-          parent.children.push(span);
-        } else {
-          roots.push(span);
-        }
-      } else {
-        roots.push(span);
-      }
-    }
-    return roots;
-  }
-}
-
-// packages/core/src/env/log-trace/opentelemetry/propagation.ts
-function padLeft(str, length) {
-  return str.padStart(length, "0");
-}
-function isValidHex(str) {
-  return /^[0-9a-f]+$/i.test(str);
-}
-function serialize(context2) {
-  const traceId = padLeft(context2.traceId.toLowerCase(), TRACE_ID_LENGTH);
-  const spanId = padLeft(context2.spanId.toLowerCase(), PARENT_SPAN_ID_LENGTH);
-  const parts = [
-    TRACE_CONTEXT_VERSION,
-    traceId,
-    spanId,
-    TRACE_FLAGS_SAMPLED
-  ];
-  return parts.join("-");
-}
-function parse(traceparent) {
-  if (!traceparent || typeof traceparent !== "string") {
-    return;
-  }
-  const trimmed = traceparent.trim();
-  const parts = trimmed.split("-");
-  if (parts.length !== 4) {
-    return;
-  }
-  const [version, traceId, senderSpanId, flags] = parts;
-  if (version !== TRACE_CONTEXT_VERSION) {
-    if (version > TRACE_CONTEXT_VERSION) {
-      return;
-    }
-  }
-  if (traceId.length !== TRACE_ID_LENGTH || !isValidHex(traceId)) {
-    return;
-  }
-  if (senderSpanId.length !== PARENT_SPAN_ID_LENGTH || !isValidHex(senderSpanId)) {
-    return;
-  }
-  if (flags.length !== FLAGS_LENGTH || !isValidHex(flags)) {
-    return;
-  }
-  return {
-    traceId: traceId.toLowerCase(),
-    spanId: senderSpanId.toLowerCase()
-  };
-}
-var TRACE_CONTEXT_VERSION = "00", TRACE_FLAGS_SAMPLED = "01", TRACEPARENT_HEADER = "TRACEPARENT", TRACE_ID_LENGTH = 32, PARENT_SPAN_ID_LENGTH = 16, FLAGS_LENGTH = 2, propagation;
-var init_propagation = __esm(() => {
-  propagation = {
-    inject(carrier, context2) {
-      carrier[TRACEPARENT_HEADER] = serialize(context2);
-    },
-    extract(carrier) {
-      const traceparent = carrier[TRACEPARENT_HEADER];
-      if (!traceparent) {
-        return;
-      }
-      return parse(traceparent);
-    },
-    getTraceparentHeader() {
-      return TRACEPARENT_HEADER;
-    }
-  };
-});
-
-// packages/core/src/env/log-trace/types.ts
-var SpanKind, SpanStatus;
-var init_types2 = __esm(() => {
-  ((SpanKind2) => {
-    SpanKind2["CLIENT"] = "client";
-    SpanKind2["SERVER"] = "server";
-    SpanKind2["INTERNAL"] = "internal";
-  })(SpanKind ||= {});
-  ((SpanStatus2) => {
-    SpanStatus2["OK"] = "ok";
-    SpanStatus2["ERROR"] = "error";
-  })(SpanStatus ||= {});
-});
-
-// packages/core/src/env/log-trace/opentelemetry/tracer-provider.ts
-var exports_tracer_provider = {};
-__export(exports_tracer_provider, {
-  resetTracerProvider: () => resetTracerProvider,
-  getTracerProvider: () => getTracerProvider,
-  OTelTracerProvider: () => OTelTracerProvider
-});
-
-class OTelSpanImpl {
-  name;
-  kind;
-  spanContext;
-  attributes = {};
-  startTime;
-  endTime;
-  error;
-  storage;
-  parentSpanContext;
-  onEnd;
-  constructor(name, spanContext, storage, parentSpanContext, onEnd) {
-    this.name = name;
-    this.kind = "internal";
-    this.spanContext = spanContext;
-    this.parentSpanContext = parentSpanContext;
-    this.startTime = Date.now();
-    this.storage = storage;
-    this.onEnd = onEnd;
-  }
-  setAttribute(key, value) {
-    this.attributes[key] = value;
-  }
-  addEvent(name, attributes) {
-    const events = this.attributes._events || [];
-    events.push({ name, attributes });
-    this.attributes._events = events;
-  }
-  end(result, error) {
-    this.endTime = Date.now();
-    if (error) {
-      this.error = error.message;
-    }
-    this.storage.save({
-      traceId: this.spanContext.traceId,
-      spanId: this.spanContext.spanId,
-      parentSpanId: this.spanContext.parentSpanId,
-      name: this.name,
-      kind: this.kind,
-      status: error ? "error" /* ERROR */ : "ok" /* OK */,
-      startTime: this.startTime,
-      endTime: this.endTime,
-      attributes: this.attributes,
-      result,
-      error: this.error
-    });
-    this.onEnd?.();
-  }
-}
-
-class OTelTracerImpl {
-  name;
-  version;
-  storage;
-  currentContext;
-  activeSpans = new Map;
-  onSpanEndCallback;
-  provider;
-  constructor(name, version, storage, provider) {
-    this.name = name;
-    this.version = version;
-    this.storage = storage;
-    this.provider = provider;
-  }
-  setOnSpanEndCallback(callback) {
-    this.onSpanEndCallback = callback;
-  }
-  getActiveSpanCount() {
-    return this.activeSpans.size;
-  }
-  startSpan(name, options) {
-    const parentFromOptions = options?.parent;
-    const hasExplicitParent = options && "parent" in options;
-    const globalContext = this.provider.getGlobalContext();
-    let effectiveParentContext;
-    if (hasExplicitParent) {
-      effectiveParentContext = parentFromOptions;
-    } else if (this.currentContext) {
-      effectiveParentContext = this.currentContext;
-    } else if (globalContext) {
-      effectiveParentContext = globalContext;
-    }
-    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
-    const spanId = this.generateSpanId();
-    let parentSpanId;
-    if (hasExplicitParent && parentFromOptions) {
-      parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
-    } else if (this.currentContext) {
-      parentSpanId = this.currentContext.spanId;
-    } else if (globalContext) {
-      parentSpanId = globalContext.spanId;
-    }
-    const spanContext = {
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    this.currentContext = {
-      traceId,
-      spanId,
-      parentSpanId
-    };
-    const span = new OTelSpanImpl(name, spanContext, this.storage, effectiveParentContext, () => this.handleSpanEnd(spanContext.spanId, effectiveParentContext?.spanId));
-    if (options?.attributes) {
-      for (const [key, value] of Object.entries(options.attributes)) {
-        span.setAttribute(key, value);
-      }
-    }
-    this.activeSpans.set(spanId, span);
-    return span;
-  }
-  injectToEnv(env) {
-    if (this.currentContext) {
-      propagation.inject(env, this.currentContext);
-    }
-  }
-  getCurrentContext() {
-    return this.currentContext;
-  }
-  setCurrentContext(context2) {
-    this.currentContext = context2;
-  }
-  endSpan(span) {
-    const spanContext = span.spanContext;
-    this.activeSpans.delete(spanContext.spanId);
-    const currentTraceId = this.currentContext?.traceId;
-    if (spanContext.parentSpanId) {
-      const parentSpan = this.activeSpans.get(spanContext.parentSpanId);
-      if (parentSpan) {
-        const parentContext = {
-          traceId: spanContext.traceId,
-          spanId: parentSpan.spanContext.spanId,
-          parentSpanId: parentSpan.spanContext.parentSpanId
-        };
-        this.currentContext = parentContext;
-        return parentContext;
-      }
-      if (currentTraceId) {
-        const parentContext = {
-          traceId: currentTraceId,
-          spanId: spanContext.parentSpanId,
-          parentSpanId: undefined
-        };
-        this.currentContext = parentContext;
-        return parentContext;
-      }
-    }
-    this.currentContext = undefined;
-    return;
-  }
-  generateTraceId() {
-    const timestamp = Date.now().toString(16).padStart(12, "0");
-    const random = Array.from({ length: 5 }, () => Math.floor(Math.random() * 4294967295).toString(16).padStart(8, "0")).join("");
-    return (timestamp + random).slice(0, 32).padStart(32, "0");
-  }
-  generateSpanId() {
-    return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
-  }
-  handleSpanEnd(spanId, parentSpanId) {
-    this.activeSpans.delete(spanId);
-    const currentTraceId = this.currentContext?.traceId;
-    if (parentSpanId) {
-      const parentSpan = this.activeSpans.get(parentSpanId);
-      if (parentSpan) {
-        this.currentContext = {
-          traceId: parentSpan.spanContext.traceId,
-          spanId: parentSpan.spanContext.spanId,
-          parentSpanId: parentSpan.spanContext.parentSpanId
-        };
-        return;
-      }
-      if (currentTraceId) {
-        this.currentContext = {
-          traceId: currentTraceId,
-          spanId: parentSpanId,
-          parentSpanId: undefined
-        };
-        return;
-      }
-    }
-    this.currentContext = undefined;
-  }
-}
-
-class OTelTracerProvider {
-  tracers = new Map;
-  storage;
-  initialized = false;
-  globalContext;
-  constructor(storage, dbPath) {
-    this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
-  }
-  async initialize() {
-    if (this.initialized)
-      return;
-    await this.storage.initialize();
-    this.initialized = true;
-  }
-  isInitialized() {
-    return this.initialized;
-  }
-  getGlobalContext() {
-    return this.globalContext;
-  }
-  setGlobalContext(context2) {
-    this.globalContext = context2;
-  }
-  getTracer(name, version) {
-    const key = `${name}@${version || "0.0.0"}`;
-    let tracer = this.tracers.get(key);
-    if (!tracer) {
-      tracer = new OTelTracerImpl(name, version, this.storage, this);
-      this.tracers.set(key, tracer);
-      if (this.initialized) {
-        this.restoreFromEnv(tracer);
-      }
-    }
-    return tracer;
-  }
-  restoreFromEnv(tracer) {
-    const extracted = propagation.extract(process.env);
-    if (extracted) {
-      tracer.setCurrentContext({
-        traceId: extracted.traceId,
-        spanId: extracted.spanId,
-        parentSpanId: undefined
-      });
-    }
-  }
-  shutdown() {
-    for (const tracer of this.tracers.values()) {}
-    this.tracers.clear();
-    this.storage.close();
-    this.initialized = false;
-    this.globalContext = undefined;
-    delete process.env["TRACEPARENT"];
-    delete process.env["TRACE_ID"];
-    delete process.env["LOG_TRACE_REQUEST_ID"];
-  }
-  getStorage() {
-    return this.storage;
-  }
-}
-function getTracerProvider() {
-  if (!providerInstance) {
-    providerInstance = new OTelTracerProvider;
-  }
-  return providerInstance;
-}
-function resetTracerProvider() {
-  if (providerInstance) {
-    providerInstance.shutdown();
-    providerInstance = null;
-  }
-}
-function getDefaultDbPath() {
-  const os = __require("os");
-  const path = __require("path");
-  const home = os.homedir();
-  const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
-  return path.join(dataHome, "roy-agent", "traces.db");
-}
-var providerInstance = null;
-var init_tracer_provider = __esm(() => {
-  init_propagation();
-  init_types2();
-});
-
-// packages/core/src/env/log-trace/logger.ts
-import { appendFileSync, existsSync, mkdirSync } from "fs";
-import { join } from "path";
-function simplifyFilePath(fullPath) {
-  let path = fullPath.replace(/\\/g, "/");
-  const bunfsMatch = path.match(/\/\$bunfs\/root\/(.+)$/);
-  if (bunfsMatch) {
-    const virtualPath = bunfsMatch[1];
-    const packagesMatch = virtualPath.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
-    if (packagesMatch) {
-      return packagesMatch[1];
-    }
-    return virtualPath;
-  }
-  const fileProtocolMatch = path.match(/@roy-agent\+core@file\+([^/]+)\/node_modules\/@roy-agent\/core\/(.+)$/);
-  if (fileProtocolMatch) {
-    const rootPkg = fileProtocolMatch[1].replace(/\+/g, "/");
-    const remaining = fileProtocolMatch[2];
-    const prefix = rootPkg;
-    const suffix = remaining.startsWith("src/") ? remaining : `src/${remaining}`;
-    return `${prefix}/${suffix}`;
-  }
-  const packagesRootMatch = path.match(/(packages\/[^/]+\/src\/[^/]+\/.+)$/);
-  if (packagesRootMatch) {
-    return packagesRootMatch[1];
-  }
-  const rootMarkers = ["packages/core/src", "packages/core", "packages"];
-  for (const marker of rootMarkers) {
-    const idx = path.indexOf(marker);
-    if (idx !== -1) {
-      return path.substring(idx);
-    }
-  }
-  return path;
-}
-function getDefaultLogDir() {
-  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  try {
-    const xdg = __require("xdg-basedir");
-    if (xdg.xdgData) {
-      return join(xdg.xdgData, "roy-agent", "logs");
-    }
-  } catch {}
-  return join(home, ".local", "share", "roy-agent", "logs");
-}
-function isQuietMode() {
-  return quietMode;
-}
-function setQuietMode(enabled) {
-  quietMode = enabled;
-}
-function setConfigComponent(component) {
-  configComponentInstance = component;
-}
-function getLogLevel() {
-  if (configComponentInstance) {
-    const level = configComponentInstance.get("log_trace.logging.level");
-    if (level && ["debug", "info", "warn", "error"].includes(level)) {
-      return level;
-    }
-  }
-  const envLevel = process.env.LOG_LEVEL;
-  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
-    return envLevel;
-  }
-  return "info";
-}
-function getCategoryLogLevel(category) {
-  if (configComponentInstance) {
-    const levels = configComponentInstance.get("log_trace.logging.levels");
-    if (levels && typeof levels === "object") {
-      const categoryLevel = levels[category];
-      if (categoryLevel && ["debug", "info", "warn", "error"].includes(categoryLevel)) {
-        return categoryLevel;
-      }
-    }
-    const directLevel = configComponentInstance.get(`log_trace.logging.levels.${category}`);
-    if (directLevel && ["debug", "info", "warn", "error"].includes(directLevel)) {
-      return directLevel;
-    }
-  }
-  const envKey = `LOG_LEVEL_${category.toUpperCase().replace(/:/g, "_")}`;
-  const envLevel = process.env[envKey];
-  if (envLevel && ["debug", "info", "warn", "error"].includes(envLevel)) {
-    return envLevel;
-  }
-  return getLogLevel();
-}
-function isAbsolutePath(path) {
-  if (path.startsWith("/")) {
-    return true;
-  }
-  if (/^[a-zA-Z]:[/\\]/.test(path)) {
-    return true;
-  }
-  return false;
-}
-function expandHomeDir(path) {
-  if (path.startsWith("~")) {
-    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-    return join(home, path.slice(1));
-  }
-  return path;
-}
-function getLogFile() {
-  if (configComponentInstance) {
-    const file = configComponentInstance.get("log_trace.logging.file");
-    if (file) {
-      return file;
-    }
-  }
-  return "app.log";
-}
-function getLogDir() {
-  if (configComponentInstance) {
-    const dir = configComponentInstance.get("log_trace.logging.dir");
-    if (dir) {
-      return dir;
-    }
-  }
-  return getDefaultLogDir();
-}
-function getMaxOutput() {
-  if (configComponentInstance) {
-    const maxOutput = configComponentInstance.get("log-trace.logging.maxOutput");
-    if (typeof maxOutput === "number") {
-      return maxOutput;
-    }
-  }
-  return;
-}
-function setLogDirOverride(dir) {
-  logDirOverride = dir;
-}
-function getLogDirOverride() {
-  return logDirOverride;
-}
-
-class Logger {
-  prefix;
-  constructor(prefix) {
-    this.prefix = prefix;
-  }
-  shouldLog(level) {
-    const categoryLevel = getCategoryLogLevel(this.prefix);
-    return levelPriority[level] >= levelPriority[categoryLevel];
-  }
-  ensureLogDirectory(dir) {
-    if (!existsSync(dir)) {
-      try {
-        mkdirSync(dir, { recursive: true });
-      } catch (err) {
-        console.error("[Logger] Failed to create log directory:", dir, err);
-      }
-    }
-  }
-  getCallerLocation() {
-    const originalLimit = Error.stackTraceLimit;
-    Error.stackTraceLimit = 10;
-    const err = new Error;
-    Error.captureStackTrace(err, this.formatMessage);
-    const stack = err.stack?.split(`
-`) || [];
-    Error.stackTraceLimit = originalLimit;
-    for (let i = 1;i < stack.length; i++) {
-      const line = stack[i];
-      if (line.includes("at ") && !line.includes("logger.ts") && !line.includes("formatMessage")) {
-        const match = line.match(/at\s+.+\s+\((.+):(\d+):\d+\)/) || line.match(/at\s+(.+):(\d+):\d+/);
-        if (match) {
-          const filePath = match[1];
-          const relativePath = this.getRelativePath(filePath);
-          return {
-            file: relativePath,
-            line: parseInt(match[2], 10)
-          };
-        }
-      }
-    }
-    return null;
-  }
-  getRelativePath(fullPath) {
-    return simplifyFilePath(fullPath);
-  }
-  formatMessage(level, message, data) {
-    const now = new Date;
-    const timestamp = now.toLocaleString("zh-CN", {
-      timeZone: "Asia/Shanghai",
-      year: "numeric",
-      month: "2-digit",
-      day: "2-digit",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      hour12: false
-    }).replace(/\//g, "-") + "." + String(now.getMilliseconds()).padStart(3, "0");
-    const prefix = this.prefix ? `[${this.prefix}]` : "";
-    let traceIdStr = "";
-    try {
-      const provider = getTracerProvider();
-      const tracer = provider.getTracer("roy-tracer");
-      const context2 = tracer.getCurrentContext();
-      if (context2?.traceId) {
-        traceIdStr = `[traceId=${context2.traceId}]`;
-      }
-    } catch {}
-    let locationStr = "";
-    if (data && typeof data === "object" && "callerLocation" in data) {
-      const logData = data;
-      locationStr = logData.callerLocation ? ` [${logData.callerLocation}]` : "";
-      const { callerLocation: _callerLocation, ...rest } = logData;
-      data = Object.keys(rest).length > 0 ? rest : undefined;
-    } else {
-      const location = this.getCallerLocation();
-      if (location) {
-        locationStr = ` [${location.file}:${location.line}]`;
-      }
-    }
-    let formatted = `${timestamp} [${level.toUpperCase()}]${traceIdStr}${locationStr}${prefix} ${message}`;
-    if (data !== undefined) {
-      if (typeof data === "object") {
-        formatted += " " + JSON.stringify(data).replace(/\n/g, "");
-      } else {
-        formatted += " " + String(data);
-      }
-    }
-    const maxOutput = getMaxOutput();
-    if (maxOutput && maxOutput > 0 && formatted.length > maxOutput) {
-      formatted = formatted.substring(0, maxOutput) + " [TRUNCATED]";
-    }
-    return formatted;
-  }
-  writeToFile(message) {
-    try {
-      const dir = getLogDir();
-      const filename = getLogFile();
-      const expandedDir = expandHomeDir(dir);
-      const resolvedDir = isAbsolutePath(expandedDir) ? expandedDir : join(process.cwd(), expandedDir);
-      this.ensureLogDirectory(resolvedDir);
-      const logFile = join(resolvedDir, filename);
-      appendFileSync(logFile, message + `
-`, "utf-8");
-    } catch (err) {
-      console.error("[Logger] Failed to write to log file:", err);
-    }
-  }
-  log(level, message, data) {
-    if (!this.shouldLog(level))
-      return;
-    const formatted = this.formatMessage(level, message, data);
-    this.writeToFile(formatted);
-    if (!isQuietMode()) {
-      const consoleMethod = level === "error" ? console.error : level === "warn" ? console.warn : level === "info" ? console.log : console.debug;
-      consoleMethod(formatted);
-    }
-  }
-  debug(message, data) {
-    this.log("debug", message, data);
-  }
-  info(message, data) {
-    this.log("info", message, data);
-  }
-  warn(message, data) {
-    this.log("warn", message, data);
-  }
-  error(message, data) {
-    this.log("error", message, data);
-  }
-}
-function createLogger(prefix) {
-  if (!loggerCache.has(prefix)) {
-    loggerCache.set(prefix, new Logger(prefix));
-  }
-  return loggerCache.get(prefix);
-}
-function getLogLevels() {
-  return ["debug", "info", "warn", "error"];
-}
-var configComponentInstance = null, quietMode = false, logDirOverride, levelPriority, loggerCache;
-var init_logger = __esm(() => {
-  init_tracer_provider();
-  levelPriority = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3
-  };
-  loggerCache = new Map;
-});
-
-// packages/core/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();
-});
-
-// packages/core/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 `\u274C ${nodeId} failed: ${error}`;
-      }
-      if (output === undefined || output === null) {
-        return `\u2705 ${nodeId} completed (${durationMs}ms)`;
-      }
-      if (typeof output === "object") {
-        const keys = Object.keys(output);
-        if (keys.length === 0) {
-          return `\u2705 ${nodeId} completed (${durationMs}ms)`;
-        }
-        const summary = keys.slice(0, 3).join(", ");
-        return `\u2705 ${nodeId}: ${summary} (${durationMs}ms)`;
-      }
-      const strOutput = String(output);
-      const truncated = strOutput.length > 100 ? strOutput.substring(0, 100) + "..." : strOutput;
-      return `\u2705 ${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);
-});
-
-// packages/core/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, "\\$");
-  }
-}
-
-// packages/core/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);
-  }
-}
-
-// packages/core/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);
-});
-
-// packages/core/src/env/workflow/nodes/agent-component-adapter.ts
-var exports_agent_component_adapter = {};
-__export(exports_agent_component_adapter, {
-  AgentComponentAdapter: () => AgentComponentAdapter
-});
-
-class AgentComponentAdapter {
-  agentComponent;
-  options;
-  _sessionComponent;
-  agentSessionPrefix = "agent";
-  _currentAgentSessionId;
-  pendingSessions = new Map;
-  runSessionToAgentSessions = new Map;
-  constructor(agentComponent, options = {}, _sessionComponent) {
-    this.agentComponent = agentComponent;
-    this.options = options;
-    this._sessionComponent = _sessionComponent;
-  }
-  setSessionComponent(sessionComponent) {
-    this._sessionComponent = sessionComponent;
-  }
-  getCurrentAgentSessionId() {
-    return this._currentAgentSessionId;
-  }
-  registerAgent(name, config) {
-    this.agentComponent.registerAgent(name, {
-      type: config.type || "general",
-      model: config.model,
-      systemPrompt: config.systemPrompt,
-      maxIterations: config.maxIterations,
-      allowedTools: config.allowedTools,
-      deniedTools: config.deniedTools,
-      timeout: config.timeout,
-      maxErrorRetries: config.maxErrorRetries
-    });
-    if (config.sessionIdPrefix) {
-      this.agentSessionPrefixes.set(name, config.sessionIdPrefix);
-    }
-  }
-  async run(config, resumeOptions) {
-    const startTime = Date.now();
-    const nodeId = config.nodeId || "unknown";
-    const runId = config.runId || "unknown";
-    const workflowSessionId = config.workflowSessionId;
-    const existingAgentSessionId = config.agentSessionId;
-    const resumeAgentSessionId = resumeOptions?.agentSessionId;
-    const isResume = !!resumeOptions?.userResponse || !!existingAgentSessionId || !!resumeAgentSessionId;
-    let agentSessionId;
-    if (isResume && (this._currentAgentSessionId || existingAgentSessionId || resumeAgentSessionId)) {
-      agentSessionId = resumeAgentSessionId || existingAgentSessionId || this._currentAgentSessionId;
-      if (resumeOptions?.userResponse && this._sessionComponent && agentSessionId) {
-        try {
-          await this._sessionComponent.addMessage(agentSessionId, {
-            role: "user",
-            content: resumeOptions.userResponse,
-            metadata: {
-              type: "user_intent",
-              intent: "workflow.resume",
-              workflowNodeId: nodeId
-            }
-          });
-        } catch (error) {
-          console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
-        }
-      }
-    } else {
-      if (this._sessionComponent) {
-        agentSessionId = `${this.agentSessionPrefix}_${runId}_${nodeId}_${Date.now()}`;
-        try {
-          await this._sessionComponent.create({
-            title: `Agent Session: ${config.type} (${agentSessionId})`,
-            metadata: {
-              type: "agent",
-              workflowRunId: runId,
-              workflowNodeId: nodeId
-            }
-          });
-          this._currentAgentSessionId = agentSessionId;
-          if (workflowSessionId) {
-            const mapping = this.runSessionToAgentSessions.get(workflowSessionId) || [];
-            mapping.push(agentSessionId);
-            this.runSessionToAgentSessions.set(workflowSessionId, mapping);
-          }
-          this.pendingSessions.set(agentSessionId, {
-            agentSessionId,
-            nodeId,
-            runId,
-            createdAt: Date.now()
-          });
-        } catch (error) {
-          console.warn(`Failed to create agent session ${agentSessionId}:`, error);
-        }
-      }
-    }
-    try {
-      const context2 = {};
-      if (config.options?.timeout) {
-        context2.abort = new AbortController;
-      }
-      if (agentSessionId) {
-        context2.sessionId = agentSessionId;
-      }
-      if (config.options?.allowedTools) {
-        context2.allowedTools = config.options.allowedTools;
-      }
-      if (config.options?.deniedTools) {
-        context2.deniedTools = config.options.deniedTools;
-      }
-      if (config.workflowHistory) {
-        context2.workflowHistory = config.workflowHistory;
-      }
-      const result = await this.agentComponent.run(config.type || "general", config.prompt, context2);
-      if (result.error?.startsWith("__ASK_USER_ERROR__:")) {
-        const jsonStr = result.error.substring("__ASK_USER_ERROR__:".length);
-        const errorInfo = JSON.parse(jsonStr);
-        throw new AskUserError(runId, errorInfo.sessionId, errorInfo.nodeId, errorInfo.nodeType || "agent", errorInfo.query);
-      }
-      const duration = Date.now() - startTime;
-      if (agentSessionId) {
-        this.pendingSessions.delete(agentSessionId);
-      }
-      const messages = result._messages || [];
-      return {
-        output: result.finalText || result.output,
-        metadata: {
-          duration,
-          iterations: result.iterations,
-          toolCalls: result.toolCalls?.length,
-          agentSessionId
-        },
-        messages
-      };
-    } catch (error) {
-      const isAskUserError = error instanceof Error && error.name === "AskUserError";
-      if (isAskUserError) {
-        throw error;
-      }
-      const duration = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      if (agentSessionId) {
-        this.pendingSessions.delete(agentSessionId);
-      }
-      return {
-        output: undefined,
-        metadata: {
-          duration,
-          error: errorMessage,
-          agentSessionId
-        }
-      };
-    } finally {
-      if (!isResume) {
-        this._currentAgentSessionId = undefined;
-      }
-    }
-  }
-  async resumeAgent(agentSessionId, userResponse, config) {
-    if (this._sessionComponent) {
-      try {
-        await this._sessionComponent.addMessage(agentSessionId, {
-          role: "user",
-          content: userResponse,
-          metadata: {
-            type: "user_intent",
-            intent: "workflow.resume"
-          }
-        });
-        this.pendingSessions.delete(agentSessionId);
-        this._currentAgentSessionId = agentSessionId;
-      } catch (error) {
-        console.warn(`Failed to add user response to agent session ${agentSessionId}:`, error);
-      }
-    }
-    config.agentSessionId = agentSessionId;
-    return this.run(config, { userResponse });
-  }
-  getPendingSession(agentSessionId) {
-    return this.pendingSessions.get(agentSessionId);
-  }
-  getPendingSessionsForRun(runId) {
-    return Array.from(this.pendingSessions.values()).filter((session) => session.runId === runId);
-  }
-  getAgentSessionsForWorkflowSession(workflowSessionId) {
-    return this.runSessionToAgentSessions.get(workflowSessionId) || [];
-  }
-  hasAgent(name) {
-    return this.agentComponent.getAgent(name) !== undefined;
-  }
-  listAgents() {
-    return this.agentComponent.listAgents().map((a) => a.name);
-  }
-  getAgentComponent() {
-    return this.agentComponent;
-  }
-  agentSessionPrefixes = new Map;
-}
-var init_agent_component_adapter = __esm(() => {
-  init_workflow_hil();
-});
-
-// packages/core/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);
-  }
-}
-
-// packages/core/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 || "\u786E\u8BA4\u7EE7\u7EED\u5417\uFF1F";
-    const options = this.config.options;
-    const fullQuery = options ? `${query} (\u9009\u9879: ${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();
-});
-
-// packages/core/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_agent_node();
-  init_agent_component_adapter();
-  init_ask_user_node();
-});
-
-// packages/core/src/env/workflow/utils/session-recovery.ts
-var exports_session_recovery = {};
-__export(exports_session_recovery, {
-  parseNodeOutputs: () => parseNodeOutputs,
-  inferNextNode: () => inferNextNode,
-  hasPendingAskUser: () => hasPendingAskUser,
-  getAgentSessionIdFromInterrupt: () => getAgentSessionIdFromInterrupt,
-  findLastInterruptMessage: () => findLastInterruptMessage,
-  findLastCallMessage: () => findLastCallMessage
-});
-function inferNextNode(messages, definition) {
-  if (messages.length === 0) {
-    return { type: "entry_node", nodeId: definition.entryNode };
-  }
-  const lastMessage = messages[messages.length - 1];
-  const metadata = lastMessage.metadata;
-  switch (metadata?.type) {
-    case "workflow.node.call":
-      return {
-        type: "resume_node",
-        nodeId: metadata.workflowNodeId,
-        agentSessionId: metadata.agentSessionId
-      };
-    case "workflow.node.interrupt":
-      return {
-        type: "ask_user",
-        nodeId: metadata.workflowNodeId,
-        agentSessionId: metadata.agentSessionId
-      };
-    case "workflow.node.result":
-      return getNextNodes(metadata.workflowNodeId, definition);
-    default:
-      const lastCall = findLastCallMessage(messages);
-      if (lastCall) {
-        const callMetadata = lastCall.metadata;
-        return {
-          type: "resume_node",
-          nodeId: callMetadata.workflowNodeId,
-          agentSessionId: callMetadata.agentSessionId
-        };
-      }
-      return { type: "entry_node", nodeId: definition.entryNode };
-  }
-}
-function getNextNodes(completedNodeId, definition) {
-  if (!definition.edges) {
-    return { type: "next_nodes", nodeIds: [] };
-  }
-  const nextNodeIds = definition.edges.filter((edge) => edge.from === completedNodeId).map((edge) => edge.to);
-  return { type: "next_nodes", nodeIds: nextNodeIds };
-}
-function findLastInterruptMessage(messages) {
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.metadata?.type === "workflow.node.interrupt") {
-      return msg;
-    }
-  }
-  return null;
-}
-function findLastCallMessage(messages) {
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.metadata?.type === "workflow.node.call") {
-      return msg;
-    }
-  }
-  return null;
-}
-function parseNodeOutputs(messages) {
-  const outputs = new Map;
-  let lastCallNodeId = null;
-  for (const msg of messages) {
-    const metadata = msg.metadata;
-    if (metadata?.type === "workflow.node.call") {
-      lastCallNodeId = metadata.workflowNodeId;
-    } else if (metadata?.type === "workflow.node.result" && lastCallNodeId) {
-      try {
-        outputs.set(lastCallNodeId, JSON.parse(msg.content));
-      } catch {
-        outputs.set(lastCallNodeId, msg.content);
-      }
-      lastCallNodeId = null;
-    }
-  }
-  return outputs;
-}
-function hasPendingAskUser(messages) {
-  if (messages.length === 0)
-    return false;
-  const lastMessage = messages[messages.length - 1];
-  const metadata = lastMessage.metadata;
-  return metadata?.type === "workflow.node.interrupt";
-}
-function getAgentSessionIdFromInterrupt(messages) {
-  const lastInterrupt = findLastInterruptMessage(messages);
-  if (!lastInterrupt)
-    return null;
-  const metadata = lastInterrupt.metadata;
-  return metadata?.agentSessionId || null;
-}
-
-// packages/core/src/env/workflow/engine/engine.ts
-import { EventEmitter } from "events";
-var logger, WorkflowEngine;
-var init_engine = __esm(() => {
-  init_event();
-  init_workflow_hil();
-  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: inferNextNode2 } = await Promise.resolve().then(() => exports_session_recovery);
-      const entry = workflowDef.entry;
-      const entryNode = Array.isArray(entry) ? entry[0] : entry;
-      const resumePoint = inferNextNode2(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);
-});
-
-// packages/core/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_executor();
-  init_engine();
-  init_node_registry();
-});
-init_engine2();
-
-export {
-  WorkflowEngine,
-  Scheduler,
-  NodeRegistry,
-  Executor,
-  EventBus,
-  DAGManager
-};