@ai-setting/roy-agent-core 1.5.88 → 1.5.89

package/dist/shared/@ai-setting/{roy-agent-core-0y64qaac.js → roy-agent-core-32m0nb9j.js}

@@ -2,6 +2,9 @@ import {
   TAG_MAX_COUNT,
   TAG_MIN_COUNT
 } from "./roy-agent-core-tq9528d3.js";
+import {
+  validateWorkflowDefinition
+} from "./roy-agent-core-8wd3qwx5.js";
 import {
   AskUserError,
   init_workflow_hil
@@ -409,6 +412,15 @@ function createWorkflowAddTool(workflowService) {
             metadata: { execution_time_ms: 0 }
           };
         }
+        const validation = validateWorkflowDefinition(definition);
+        if (!validation.valid) {
+          return {
+            success: false,
+            output: "",
+            error: `Validation failed: ${validation.errors.join("; ")}`,
+            metadata: { execution_time_ms: 0 }
+          };
+        }
         const workflow = await workflowService.createWorkflow(definition, {
           tags: params.tags
         });
@@ -453,15 +465,92 @@ function createWorkflowAddTool(workflowService) {
   };
 }
 
-// src/env/workflow/tools/workflow-search-tool.ts
+// src/env/workflow/tools/workflow-validate-tool.ts
 init_logger();
 import { z as z6 } from "zod";
-var logger5 = createLogger("workflow-search-tool");
-var WorkflowSearchInputSchema = z6.object({
-  keyword: z6.string().optional().describe("Search keyword in name and description (case-insensitive substring)"),
-  tags: z6.array(z6.string()).optional().describe("Filter by tags (ALL must match - AND filter)"),
-  limit: z6.number().positive().optional().describe("Maximum number of results"),
-  offset: z6.number().min(0).optional().describe("Pagination offset")
+import yaml2 from "yaml";
+var logger5 = createLogger("workflow-validate-tool");
+var WorkflowValidateInputSchema = z6.object({
+  definition: z6.any().optional().describe("Workflow definition object (alternative to definition_yaml)"),
+  definition_yaml: z6.string().optional().describe("Workflow definition as YAML or JSON string"),
+  yaml: z6.string().optional().describe("Alias for definition_yaml — workflow definition as YAML or JSON string")
+});
+function createWorkflowValidateTool(_workflowService) {
+  return {
+    name: "workflow_validate",
+    description: `Validate a workflow definition (YAML or JSON) without persisting it. ` + `Checks for: duplicate node IDs, missing dependencies, cycles, empty node IDs. ` + `Returns { valid: boolean, errors: string[], workflowName?, nodeCount }. ` + `Use this BEFORE workflow_add to ensure the workflow is structurally sound.`,
+    parameters: WorkflowValidateInputSchema,
+    execute: async (args, _ctx) => {
+      try {
+        const params = WorkflowValidateInputSchema.parse(args);
+        let definition;
+        if (params.definition && typeof params.definition === "object") {
+          definition = params.definition;
+        } else {
+          const yamlText = params.yaml ?? params.definition_yaml;
+          if (!yamlText || typeof yamlText !== "string") {
+            return {
+              success: false,
+              output: "",
+              error: "Must provide either 'definition' (object), 'definition_yaml', or 'yaml' (string)",
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+          try {
+            definition = yaml2.parse(yamlText);
+          } catch (yamlErr) {
+            return {
+              success: false,
+              output: "",
+              error: `Invalid YAML: ${yamlErr instanceof Error ? yamlErr.message : String(yamlErr)}`,
+              metadata: { execution_time_ms: 0 }
+            };
+          }
+        }
+        if (!definition || typeof definition !== "object") {
+          return {
+            success: false,
+            output: "",
+            error: "Parsed definition is not an object",
+            metadata: { execution_time_ms: 0 }
+          };
+        }
+        const result = validateWorkflowDefinition(definition);
+        const nodeCount = Array.isArray(definition.nodes) ? definition.nodes.length : 0;
+        const output = {
+          valid: result.valid,
+          errors: result.errors,
+          workflowName: definition.name,
+          nodeCount
+        };
+        return {
+          success: result.valid,
+          output: JSON.stringify(output, null, 2),
+          error: result.valid ? undefined : `Validation failed: ${result.errors.join("; ")}`,
+          metadata: { execution_time_ms: 0 }
+        };
+      } catch (error) {
+        logger5.error("[workflow_validate] failed", { error });
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: 0 }
+        };
+      }
+    }
+  };
+}
+
+// src/env/workflow/tools/workflow-search-tool.ts
+init_logger();
+import { z as z7 } from "zod";
+var logger6 = createLogger("workflow-search-tool");
+var WorkflowSearchInputSchema = z7.object({
+  keyword: z7.string().optional().describe("Search keyword in name and description (case-insensitive substring)"),
+  tags: z7.array(z7.string()).optional().describe("Filter by tags (ALL must match - AND filter)"),
+  limit: z7.number().positive().optional().describe("Maximum number of results"),
+  offset: z7.number().min(0).optional().describe("Pagination offset")
 });
 function createWorkflowSearchTool(workflowService) {
   return {
@@ -507,7 +596,7 @@ function createWorkflowSearchTool(workflowService) {
           metadata: { execution_time_ms: 0 }
         };
       } catch (error) {
-        logger5.error("Failed to search workflows", { error });
+        logger6.error("Failed to search workflows", { error });
         return {
           success: false,
           output: "",
@@ -521,13 +610,13 @@ function createWorkflowSearchTool(workflowService) {
 
 // src/env/workflow/tools/run-workflow.ts
 init_logger();
-import { z as z7 } from "zod";
-var logger6 = createLogger("run-workflow-tool");
-var RunWorkflowInputSchema = z7.object({
-  workflow_name: z7.string().describe("Name of the workflow to run"),
-  input: z7.record(z7.any()).optional().describe("Input to pass to the workflow"),
-  sync: z7.boolean().default(true).describe("Wait for completion (default: true)"),
-  timeout: z7.number().positive().optional().describe("Timeout in milliseconds (default: 1800000 = 30 min)")
+import { z as z8 } from "zod";
+var logger7 = createLogger("run-workflow-tool");
+var RunWorkflowInputSchema = z8.object({
+  workflow_name: z8.string().describe("Name of the workflow to run"),
+  input: z8.record(z8.any()).optional().describe("Input to pass to the workflow"),
+  sync: z8.boolean().default(true).describe("Wait for completion (default: true)"),
+  timeout: z8.number().positive().optional().describe("Timeout in milliseconds (default: 1800000 = 30 min)")
 });
 function createRunWorkflowTool(workflowService) {
   return {
@@ -549,7 +638,7 @@ function createRunWorkflowTool(workflowService) {
     execute: async (args, ctx) => {
       const startTime = Date.now();
       const { workflow_name, input, sync = true, timeout = 1800000 } = args;
-      logger6.info(`Running workflow: ${workflow_name}`, { input, sync, timeout });
+      logger7.info(`Running workflow: ${workflow_name}`, { input, sync, timeout });
       let timeoutHandle;
       let durationMs;
       try {
@@ -623,8 +712,8 @@ function createRunWorkflowTool(workflowService) {
             }
           };
         }
-        if (logger6?.error) {
-          logger6.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
+        if (logger7?.error) {
+          logger7.error(`Failed to run workflow: ${workflow_name}`, { error: errorMessage });
         }
         return {
           success: false,
@@ -664,10 +753,10 @@ function createLegacyRunWorkflowTool(workflowService) {
 
 // src/env/workflow/tools/workflow-run-status-tool.ts
 init_logger();
-import { z as z8 } from "zod";
-var logger7 = createLogger("workflow-run-status-tool");
-var WorkflowRunStatusInputSchema = z8.object({
-  run_id: z8.string().describe("Run/session ID to query status")
+import { z as z9 } from "zod";
+var logger8 = createLogger("workflow-run-status-tool");
+var WorkflowRunStatusInputSchema = z9.object({
+  run_id: z9.string().describe("Run/session ID to query status")
 });
 function createWorkflowRunStatusTool(workflowService) {
   return {
@@ -707,7 +796,7 @@ function createWorkflowRunStatusTool(workflowService) {
           metadata: { execution_time_ms: 0 }
         };
       } catch (error) {
-        logger7.error("Failed to get run status", { error });
+        logger8.error("Failed to get run status", { error });
         return {
           success: false,
           output: "",
@@ -721,11 +810,11 @@ function createWorkflowRunStatusTool(workflowService) {
 
 // src/env/workflow/tools/workflow-run-stop-tool.ts
 init_logger();
-import { z as z9 } from "zod";
-var logger8 = createLogger("workflow-run-stop-tool");
-var WorkflowRunStopInputSchema = z9.object({
-  run_id: z9.string().describe("Run/session ID to stop"),
-  reason: z9.string().optional().describe("Optional reason for stopping the workflow")
+import { z as z10 } from "zod";
+var logger9 = createLogger("workflow-run-stop-tool");
+var WorkflowRunStopInputSchema = z10.object({
+  run_id: z10.string().describe("Run/session ID to stop"),
+  reason: z10.string().optional().describe("Optional reason for stopping the workflow")
 });
 function createWorkflowRunStopTool(workflowService) {
   return {
@@ -747,7 +836,7 @@ function createWorkflowRunStopTool(workflowService) {
           metadata: { execution_time_ms: 0 }
         };
       } catch (error) {
-        logger8.error("Failed to stop workflow run", { error });
+        logger9.error("Failed to stop workflow run", { error });
         return {
           success: false,
           output: "",
@@ -759,4 +848,4 @@ function createWorkflowRunStopTool(workflowService) {
   };
 }
 
-export { AskUserInputSchema, askUserTool, askUserToolInstance, WorkflowGetInputSchema, createWorkflowGetTool, WorkflowListInputSchema, createWorkflowListTool, WorkflowTagListInputSchema, createWorkflowTagListTool, WorkflowAddInputSchema, createWorkflowAddTool, WorkflowSearchInputSchema, createWorkflowSearchTool, RunWorkflowInputSchema, createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, createLegacyRunWorkflowTool, WorkflowRunStatusInputSchema, createWorkflowRunStatusTool, WorkflowRunStopInputSchema, createWorkflowRunStopTool };
+export { AskUserInputSchema, askUserTool, askUserToolInstance, WorkflowGetInputSchema, createWorkflowGetTool, WorkflowListInputSchema, createWorkflowListTool, WorkflowTagListInputSchema, createWorkflowTagListTool, WorkflowAddInputSchema, createWorkflowAddTool, WorkflowValidateInputSchema, createWorkflowValidateTool, WorkflowSearchInputSchema, createWorkflowSearchTool, RunWorkflowInputSchema, createRunWorkflowTool, initRunWorkflowTool, getRunWorkflowTool, resetRunWorkflowTool, createLegacyRunWorkflowTool, WorkflowRunStatusInputSchema, createWorkflowRunStatusTool, WorkflowRunStopInputSchema, createWorkflowRunStopTool };

package/dist/shared/@ai-setting/{roy-agent-core-9y09xfav.js → roy-agent-core-3f6k060j.js}

@@ -35,6 +35,10 @@ import {
   parseWorkflowJsonOutput,
   validateJsonOutputSchema
 } from "./roy-agent-core-1db4vpc6.js";
+import {
+  DAGManager,
+  init_dag_manager
+} from "./roy-agent-core-4yq23m5g.js";
 import {
   AskUserError,
   createNodeInterruptEvent,
@@ -147,422 +151,6 @@ var init_event_bus = __esm(() => {
   logger = createLogger("workflow.eventbus");
 });
 
-// src/env/workflow/engine/dag-manager.ts
-class DAGManager {
-  workflow;
-  nodeMap;
-  extendedDefinition = null;
-  cachedAnalysis = null;
-  allowCycles;
-  constructor(workflow, options) {
-    if (!workflow.nodes || workflow.nodes.length === 0) {
-      throw new Error("At least one node is required");
-    }
-    this.workflow = workflow;
-    this.nodeMap = new Map;
-    this.allowCycles = options?.allowCycles ?? false;
-    for (const node of workflow.nodes) {
-      if (node.id === "") {
-        throw new Error("Node ID cannot be empty");
-      }
-      if (this.nodeMap.has(node.id)) {
-        throw new Error(`Duplicate node ID: ${node.id}`);
-      }
-      this.nodeMap.set(node.id, node);
-    }
-  }
-  getExtendedDefinition() {
-    if (this.extendedDefinition) {
-      return this.extendedDefinition;
-    }
-    const analysis = this.analyze();
-    this.extendedDefinition = {
-      ...this.workflow,
-      computedEntry: analysis.entryNodes,
-      nodeMap: this.nodeMap,
-      topologicalOrder: this.getTopologicalOrder()
-    };
-    return this.extendedDefinition;
-  }
-  analyze() {
-    if (this.cachedAnalysis) {
-      return this.cachedAnalysis;
-    }
-    const dependencies = this.buildDependenciesMap();
-    const dependents = this.buildDependentsMap(dependencies);
-    const entryNodes = this.findEntryNodes(dependencies);
-    const exitNodes = this.findExitNodes(dependents);
-    const levels = this.computeLevels(dependencies);
-    const criticalPath = this.findCriticalPath(levels, dependencies);
-    this.cachedAnalysis = {
-      entryNodes,
-      exitNodes,
-      levels,
-      dependencies,
-      dependents,
-      criticalPath
-    };
-    return this.cachedAnalysis;
-  }
-  buildDependenciesMap() {
-    const dependencies = new Map;
-    for (const node of this.workflow.nodes) {
-      const deps = node.depends_on || [];
-      dependencies.set(node.id, [...deps]);
-    }
-    if (this.workflow.edges) {
-      for (const edge of this.workflow.edges) {
-        const targetDeps = dependencies.get(edge.to);
-        if (!targetDeps)
-          continue;
-        if (targetDeps.includes(edge.from))
-          continue;
-        if (!this.isReachable(edge.from, edge.to, dependencies)) {
-          targetDeps.push(edge.from);
-        }
-      }
-    }
-    return dependencies;
-  }
-  isReachable(source, target, dependencies) {
-    if (source === target)
-      return true;
-    const visited = new Set;
-    const queue = [source];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current === target)
-        return true;
-      if (visited.has(current))
-        continue;
-      visited.add(current);
-      const deps = dependencies.get(current) || [];
-      for (const dep of deps) {
-        if (!visited.has(dep))
-          queue.push(dep);
-      }
-    }
-    return false;
-  }
-  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 analysis = this.analyze();
-    const deps = analysis.dependencies.get(nodeId);
-    if (!deps) {
-      return true;
-    }
-    for (const dep of deps) {
-      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(options) {
-    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.allowCycles && !options?.skipCycleCheck && 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) || [];
-  }
-  getDownstreamUntil(fromNodeId, untilNodeId) {
-    const result = [];
-    const visited = new Set;
-    const queue = [...this.getDependents(fromNodeId)];
-    while (queue.length > 0) {
-      const nodeId = queue.shift();
-      if (visited.has(nodeId))
-        continue;
-      visited.add(nodeId);
-      result.push(nodeId);
-      if (nodeId === untilNodeId) {
-        continue;
-      }
-      for (const dependent of this.getDependents(nodeId)) {
-        if (!visited.has(dependent)) {
-          queue.push(dependent);
-        }
-      }
-    }
-    return result;
-  }
-  getDefinition() {
-    return this.workflow;
-  }
-  getNode(nodeId) {
-    return this.nodeMap.get(nodeId);
-  }
-  getNodeIds() {
-    return Array.from(this.nodeMap.keys());
-  }
-  getNodeCount() {
-    return this.nodeMap.size;
-  }
-  buildEdges(explicitEdges = []) {
-    const derivedEdges = [];
-    const explicitEdgeSet = new Set(explicitEdges.map((e) => `${e.from}->${e.to}`));
-    for (const node of this.workflow.nodes) {
-      const deps = node.depends_on || [];
-      for (const dep of deps) {
-        const edgeKey = `${dep}->${node.id}`;
-        if (!explicitEdgeSet.has(edgeKey)) {
-          derivedEdges.push({ from: dep, to: node.id });
-        }
-      }
-    }
-    return [...explicitEdges, ...derivedEdges];
-  }
-}
-var init_dag_manager = () => {};
-
 // src/env/workflow/engine/scheduler.ts
 class Scheduler {
   dagManager;
@@ -2584,4 +2172,4 @@ var init_engine2 = __esm(() => {
   init_node_registry();
 });
 
-export { EventBus, DAGManager, Scheduler, Executor, NodeRegistry, WorkflowEngine, exports_engine, init_engine2 as init_engine };
+export { EventBus, Scheduler, Executor, NodeRegistry, WorkflowEngine, exports_engine, init_engine2 as init_engine };