@datatechsolutions/ui 2.11.1 → 2.11.3

package/dist/astrlabe/utils.d.mts

@@ -0,0 +1,71 @@
+import { WorkflowNodeType, LogicNodeConfig, WorkflowGraph } from './contracts.mjs';
+import { Node, Edge } from '@xyflow/react';
+
+/**
+ * Layout Engine
+ * =============
+ * Auto-layout for workflow graphs using @dagrejs/dagre.
+ * Pure utility — no React dependencies.
+ */
+
+/** Layout direction: free means no auto-layout is applied. */
+type LayoutDirection = 'free' | 'LR' | 'TB';
+/**
+ * Apply dagre layout to the given nodes and edges.
+ * Returns a new array of nodes with updated positions.
+ * Group child nodes (parentId set) and note nodes are excluded from layout.
+ */
+declare function applyDagreLayout(nodes: Node[], edges: Edge[], direction: Exclude<LayoutDirection, 'free'>): Node[];
+
+/**
+ * Logic Node Default Configs
+ * ==========================
+ * Factory function to create default configs for each logic node type.
+ */
+
+declare function createDefaultLogicNodeConfig(nodeType: WorkflowNodeType): LogicNodeConfig | null;
+
+/**
+ * Workflow Validator
+ * =================
+ * Validates the workflow graph before publishing.
+ * Ensures the graph forms a valid DAG with proper node connections.
+ */
+
+type ValidationResult = {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Validate a workflow graph for publishing.
+ * Checks:
+ * - At least one agent node exists
+ * - All edges have valid source/target nodes
+ * - No orphan nodes (every node has at least one connection, except note nodes)
+ * - Tool nodes connect to agent nodes only
+ * - Agent chain forms a valid DAG (no cycles)
+ * - Rule nodes have incoming edges from agents
+ * - Logic node constraints (start/end uniqueness, config validation)
+ * - New node type validations (answer, question_classifier, parameter_extractor, etc.)
+ */
+declare function validateWorkflowGraph(graph: WorkflowGraph): ValidationResult;
+/**
+ * Topologically sort agent nodes from the graph edges.
+ * Returns agent entityIds in execution order.
+ * Logic nodes are skipped — only agent entityIds are returned.
+ */
+declare function topologicalSortAgents(graph: WorkflowGraph): string[];
+
+/**
+ * Agent ELO Tier
+ * ==============
+ * Derives difficulty tier from agent ELO rating.
+ * Used in node palette, agent flow node, and agent modal.
+ */
+type AgentTier = {
+    key: 'beginner' | 'intermediate' | 'advanced' | 'expert';
+    pillColor: string;
+};
+declare function getAgentTier(elo: number | undefined): AgentTier;
+
+export { type AgentTier, type LayoutDirection, applyDagreLayout, createDefaultLogicNodeConfig, getAgentTier, topologicalSortAgents, validateWorkflowGraph };

package/dist/astrlabe/utils.d.ts

@@ -0,0 +1,71 @@
+import { WorkflowNodeType, LogicNodeConfig, WorkflowGraph } from './contracts.js';
+import { Node, Edge } from '@xyflow/react';
+
+/**
+ * Layout Engine
+ * =============
+ * Auto-layout for workflow graphs using @dagrejs/dagre.
+ * Pure utility — no React dependencies.
+ */
+
+/** Layout direction: free means no auto-layout is applied. */
+type LayoutDirection = 'free' | 'LR' | 'TB';
+/**
+ * Apply dagre layout to the given nodes and edges.
+ * Returns a new array of nodes with updated positions.
+ * Group child nodes (parentId set) and note nodes are excluded from layout.
+ */
+declare function applyDagreLayout(nodes: Node[], edges: Edge[], direction: Exclude<LayoutDirection, 'free'>): Node[];
+
+/**
+ * Logic Node Default Configs
+ * ==========================
+ * Factory function to create default configs for each logic node type.
+ */
+
+declare function createDefaultLogicNodeConfig(nodeType: WorkflowNodeType): LogicNodeConfig | null;
+
+/**
+ * Workflow Validator
+ * =================
+ * Validates the workflow graph before publishing.
+ * Ensures the graph forms a valid DAG with proper node connections.
+ */
+
+type ValidationResult = {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Validate a workflow graph for publishing.
+ * Checks:
+ * - At least one agent node exists
+ * - All edges have valid source/target nodes
+ * - No orphan nodes (every node has at least one connection, except note nodes)
+ * - Tool nodes connect to agent nodes only
+ * - Agent chain forms a valid DAG (no cycles)
+ * - Rule nodes have incoming edges from agents
+ * - Logic node constraints (start/end uniqueness, config validation)
+ * - New node type validations (answer, question_classifier, parameter_extractor, etc.)
+ */
+declare function validateWorkflowGraph(graph: WorkflowGraph): ValidationResult;
+/**
+ * Topologically sort agent nodes from the graph edges.
+ * Returns agent entityIds in execution order.
+ * Logic nodes are skipped — only agent entityIds are returned.
+ */
+declare function topologicalSortAgents(graph: WorkflowGraph): string[];
+
+/**
+ * Agent ELO Tier
+ * ==============
+ * Derives difficulty tier from agent ELO rating.
+ * Used in node palette, agent flow node, and agent modal.
+ */
+type AgentTier = {
+    key: 'beginner' | 'intermediate' | 'advanced' | 'expert';
+    pillColor: string;
+};
+declare function getAgentTier(elo: number | undefined): AgentTier;
+
+export { type AgentTier, type LayoutDirection, applyDagreLayout, createDefaultLogicNodeConfig, getAgentTier, topologicalSortAgents, validateWorkflowGraph };

package/dist/astrlabe/utils.js

@@ -0,0 +1,30 @@
+"use client";
+'use strict';
+
+var chunk3GE3MBUZ_js = require('../chunk-3GE3MBUZ.js');
+var chunkPWBWP5FJ_js = require('../chunk-PWBWP5FJ.js');
+
+
+
+Object.defineProperty(exports, "topologicalSortAgents", {
+  enumerable: true,
+  get: function () { return chunk3GE3MBUZ_js.topologicalSortAgents; }
+});
+Object.defineProperty(exports, "validateWorkflowGraph", {
+  enumerable: true,
+  get: function () { return chunk3GE3MBUZ_js.validateWorkflowGraph; }
+});
+Object.defineProperty(exports, "applyDagreLayout", {
+  enumerable: true,
+  get: function () { return chunkPWBWP5FJ_js.applyDagreLayout; }
+});
+Object.defineProperty(exports, "createDefaultLogicNodeConfig", {
+  enumerable: true,
+  get: function () { return chunkPWBWP5FJ_js.createDefaultLogicNodeConfig; }
+});
+Object.defineProperty(exports, "getAgentTier", {
+  enumerable: true,
+  get: function () { return chunkPWBWP5FJ_js.getAgentTier; }
+});
+//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=utils.js.map

package/dist/astrlabe/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"utils.js"}

package/dist/astrlabe/utils.mjs

@@ -0,0 +1,5 @@
+"use client";
+export { topologicalSortAgents, validateWorkflowGraph } from '../chunk-BLNXRUC4.mjs';
+export { applyDagreLayout, createDefaultLogicNodeConfig, getAgentTier } from '../chunk-TLPPVL3W.mjs';
+//# sourceMappingURL=utils.mjs.map
+//# sourceMappingURL=utils.mjs.map

package/dist/astrlabe/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"utils.mjs"}

package/dist/astrlabe/workflow-canvas.d.mts

@@ -0,0 +1,5 @@
+import 'react/jsx-runtime';
+import 'react';
+export { i as Workspace, h as WorkspaceProps } from '../workflow-canvas-CJwGehdk.mjs';
+import '@xyflow/react';
+import './contracts.mjs';

package/dist/astrlabe/workflow-canvas.d.ts

@@ -0,0 +1,5 @@
+import 'react/jsx-runtime';
+import 'react';
+export { i as Workspace, h as WorkspaceProps } from '../workflow-canvas-DSm0iyof.js';
+import '@xyflow/react';
+import './contracts.js';

package/dist/astrlabe/workflow-canvas.js

@@ -0,0 +1,19 @@
+"use client";
+'use strict';
+
+var chunkXAQME7DD_js = require('../chunk-XAQME7DD.js');
+require('../chunk-PBKTXX4Y.js');
+require('../chunk-S7KHTUHA.js');
+require('../chunk-UZ3CMNUJ.js');
+require('../chunk-P4YYEM4B.js');
+require('../chunk-PWBWP5FJ.js');
+require('../chunk-YXN2K77G.js');
+
+
+
+Object.defineProperty(exports, "Workspace", {
+  enumerable: true,
+  get: function () { return chunkXAQME7DD_js.Workspace; }
+});
+//# sourceMappingURL=workflow-canvas.js.map
+//# sourceMappingURL=workflow-canvas.js.map

package/dist/astrlabe/workflow-canvas.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"workflow-canvas.js"}

package/dist/astrlabe/workflow-canvas.mjs

@@ -0,0 +1,10 @@
+"use client";
+export { Workspace } from '../chunk-LJSJMBLO.mjs';
+import '../chunk-XO7IYJSF.mjs';
+import '../chunk-QWG2FMUN.mjs';
+import '../chunk-D2JF6C3E.mjs';
+import '../chunk-OZNTQROP.mjs';
+import '../chunk-TLPPVL3W.mjs';
+import '../chunk-7VJ7CMMT.mjs';
+//# sourceMappingURL=workflow-canvas.mjs.map
+//# sourceMappingURL=workflow-canvas.mjs.map

package/dist/astrlabe/workflow-canvas.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"workflow-canvas.mjs"}

package/dist/astrlabe/workflow-preview-canvas.d.mts

@@ -0,0 +1,10 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { WorkflowGraph } from './contracts.mjs';
+
+type WorkflowPreviewCanvasProps = {
+    graph: WorkflowGraph;
+    className?: string;
+};
+declare function WorkflowPreviewCanvas({ graph, className }: WorkflowPreviewCanvasProps): react_jsx_runtime.JSX.Element;
+
+export { WorkflowPreviewCanvas, type WorkflowPreviewCanvasProps };

package/dist/astrlabe/workflow-preview-canvas.d.ts

@@ -0,0 +1,10 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { WorkflowGraph } from './contracts.js';
+
+type WorkflowPreviewCanvasProps = {
+    graph: WorkflowGraph;
+    className?: string;
+};
+declare function WorkflowPreviewCanvas({ graph, className }: WorkflowPreviewCanvasProps): react_jsx_runtime.JSX.Element;
+
+export { WorkflowPreviewCanvas, type WorkflowPreviewCanvasProps };

package/dist/astrlabe/workflow-preview-canvas.js

@@ -0,0 +1,28 @@
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/astrlabe/workflow-preview-canvas.tsx
+function WorkflowPreviewCanvas({ graph, className }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className, style: { overflow: "auto", padding: 12 }, children: /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "grid", gap: 10 }, children: graph.nodes.map((node) => /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        border: "1px solid #cbd5e1",
+        borderRadius: 10,
+        padding: "10px 12px",
+        background: "#fff"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontSize: 12, color: "#64748b", textTransform: "uppercase" }, children: node.type }),
+        /* @__PURE__ */ jsxRuntime.jsx("div", { style: { fontSize: 14, fontWeight: 600 }, children: node.data?.label || node.id })
+      ]
+    },
+    node.id
+  )) }) });
+}
+
+exports.WorkflowPreviewCanvas = WorkflowPreviewCanvas;
+//# sourceMappingURL=workflow-preview-canvas.js.map
+//# sourceMappingURL=workflow-preview-canvas.js.map

package/dist/astrlabe/workflow-preview-canvas.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/astrlabe/workflow-preview-canvas.tsx"],"names":["jsx","jsxs"],"mappings":";;;;;AAOO,SAAS,qBAAA,CAAsB,EAAE,KAAA,EAAO,SAAA,EAAU,EAA+B;AACtF,EAAA,uBACEA,cAAA,CAAC,SAAI,SAAA,EAAsB,KAAA,EAAO,EAAE,QAAA,EAAU,MAAA,EAAQ,OAAA,EAAS,EAAA,EAAG,EAChE,QAAA,kBAAAA,cAAA,CAAC,SAAI,KAAA,EAAO,EAAE,OAAA,EAAS,MAAA,EAAQ,GAAA,EAAK,EAAA,IACjC,QAAA,EAAA,KAAA,CAAM,KAAA,CAAM,GAAA,CAAI,CAAC,IAAA,qBAChBC,eAAA;AAAA,IAAC,KAAA;AAAA,IAAA;AAAA,MAEC,KAAA,EAAO;AAAA,QACL,MAAA,EAAQ,mBAAA;AAAA,QACR,YAAA,EAAc,EAAA;AAAA,QACd,OAAA,EAAS,WAAA;AAAA,QACT,UAAA,EAAY;AAAA,OACd;AAAA,MAEA,QAAA,EAAA;AAAA,wBAAAD,cAAA,CAAC,KAAA,EAAA,EAAI,KAAA,EAAO,EAAE,QAAA,EAAU,EAAA,EAAI,KAAA,EAAO,SAAA,EAAW,aAAA,EAAe,WAAA,EAAY,EAAI,QAAA,EAAA,IAAA,CAAK,IAAA,EAAK,CAAA;AAAA,wBACvFA,cAAA,CAAC,KAAA,EAAA,EAAI,KAAA,EAAO,EAAE,QAAA,EAAU,EAAA,EAAI,UAAA,EAAY,GAAA,EAAI,EAAI,QAAA,EAAA,IAAA,CAAK,IAAA,EAAM,KAAA,IAAS,KAAK,EAAA,EAAG;AAAA;AAAA,KAAA;AAAA,IATvE,IAAA,CAAK;AAAA,GAWb,GACH,CAAA,EACF,CAAA;AAEJ","file":"workflow-preview-canvas.js","sourcesContent":["import type { WorkflowGraph } from './contracts'\n\nexport type WorkflowPreviewCanvasProps = {\n  graph: WorkflowGraph\n  className?: string\n}\n\nexport function WorkflowPreviewCanvas({ graph, className }: WorkflowPreviewCanvasProps) {\n  return (\n    <div className={className} style={{ overflow: 'auto', padding: 12 }}>\n      <div style={{ display: 'grid', gap: 10 }}>\n        {graph.nodes.map((node) => (\n          <div\n            key={node.id}\n            style={{\n              border: '1px solid #cbd5e1',\n              borderRadius: 10,\n              padding: '10px 12px',\n              background: '#fff',\n            }}\n          >\n            <div style={{ fontSize: 12, color: '#64748b', textTransform: 'uppercase' }}>{node.type}</div>\n            <div style={{ fontSize: 14, fontWeight: 600 }}>{node.data?.label || node.id}</div>\n          </div>\n        ))}\n      </div>\n    </div>\n  )\n}\n"]}

package/dist/astrlabe/workflow-preview-canvas.mjs

@@ -0,0 +1,26 @@
+"use client";
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/astrlabe/workflow-preview-canvas.tsx
+function WorkflowPreviewCanvas({ graph, className }) {
+  return /* @__PURE__ */ jsx("div", { className, style: { overflow: "auto", padding: 12 }, children: /* @__PURE__ */ jsx("div", { style: { display: "grid", gap: 10 }, children: graph.nodes.map((node) => /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        border: "1px solid #cbd5e1",
+        borderRadius: 10,
+        padding: "10px 12px",
+        background: "#fff"
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", { style: { fontSize: 12, color: "#64748b", textTransform: "uppercase" }, children: node.type }),
+        /* @__PURE__ */ jsx("div", { style: { fontSize: 14, fontWeight: 600 }, children: node.data?.label || node.id })
+      ]
+    },
+    node.id
+  )) }) });
+}
+
+export { WorkflowPreviewCanvas };
+//# sourceMappingURL=workflow-preview-canvas.mjs.map
+//# sourceMappingURL=workflow-preview-canvas.mjs.map

package/dist/astrlabe/workflow-preview-canvas.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/astrlabe/workflow-preview-canvas.tsx"],"names":[],"mappings":";;;AAOO,SAAS,qBAAA,CAAsB,EAAE,KAAA,EAAO,SAAA,EAAU,EAA+B;AACtF,EAAA,uBACE,GAAA,CAAC,SAAI,SAAA,EAAsB,KAAA,EAAO,EAAE,QAAA,EAAU,MAAA,EAAQ,OAAA,EAAS,EAAA,EAAG,EAChE,QAAA,kBAAA,GAAA,CAAC,SAAI,KAAA,EAAO,EAAE,OAAA,EAAS,MAAA,EAAQ,GAAA,EAAK,EAAA,IACjC,QAAA,EAAA,KAAA,CAAM,KAAA,CAAM,GAAA,CAAI,CAAC,IAAA,qBAChB,IAAA;AAAA,IAAC,KAAA;AAAA,IAAA;AAAA,MAEC,KAAA,EAAO;AAAA,QACL,MAAA,EAAQ,mBAAA;AAAA,QACR,YAAA,EAAc,EAAA;AAAA,QACd,OAAA,EAAS,WAAA;AAAA,QACT,UAAA,EAAY;AAAA,OACd;AAAA,MAEA,QAAA,EAAA;AAAA,wBAAA,GAAA,CAAC,KAAA,EAAA,EAAI,KAAA,EAAO,EAAE,QAAA,EAAU,EAAA,EAAI,KAAA,EAAO,SAAA,EAAW,aAAA,EAAe,WAAA,EAAY,EAAI,QAAA,EAAA,IAAA,CAAK,IAAA,EAAK,CAAA;AAAA,wBACvF,GAAA,CAAC,KAAA,EAAA,EAAI,KAAA,EAAO,EAAE,QAAA,EAAU,EAAA,EAAI,UAAA,EAAY,GAAA,EAAI,EAAI,QAAA,EAAA,IAAA,CAAK,IAAA,EAAM,KAAA,IAAS,KAAK,EAAA,EAAG;AAAA;AAAA,KAAA;AAAA,IATvE,IAAA,CAAK;AAAA,GAWb,GACH,CAAA,EACF,CAAA;AAEJ","file":"workflow-preview-canvas.mjs","sourcesContent":["import type { WorkflowGraph } from './contracts'\n\nexport type WorkflowPreviewCanvasProps = {\n  graph: WorkflowGraph\n  className?: string\n}\n\nexport function WorkflowPreviewCanvas({ graph, className }: WorkflowPreviewCanvasProps) {\n  return (\n    <div className={className} style={{ overflow: 'auto', padding: 12 }}>\n      <div style={{ display: 'grid', gap: 10 }}>\n        {graph.nodes.map((node) => (\n          <div\n            key={node.id}\n            style={{\n              border: '1px solid #cbd5e1',\n              borderRadius: 10,\n              padding: '10px 12px',\n              background: '#fff',\n            }}\n          >\n            <div style={{ fontSize: 12, color: '#64748b', textTransform: 'uppercase' }}>{node.type}</div>\n            <div style={{ fontSize: 14, fontWeight: 600 }}>{node.data?.label || node.id}</div>\n          </div>\n        ))}\n      </div>\n    </div>\n  )\n}\n"]}

package/dist/chunk-3GE3MBUZ.js

@@ -0,0 +1,279 @@
+"use client";
+'use strict';
+
+// src/astrlabe/utils/workflow-validator.ts
+function validateWorkflowGraph(graph) {
+  const errors = [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    nodeMap.set(node.id, node);
+  }
+  const agentNodes = graph.nodes.filter((node) => node.type === "agent");
+  if (agentNodes.length === 0) {
+    errors.push("At least one agent node is required");
+  }
+  for (const edge of graph.edges) {
+    if (!nodeMap.has(edge.source)) {
+      errors.push(`Edge "${edge.id}" references non-existent source node "${edge.source}"`);
+    }
+    if (!nodeMap.has(edge.target)) {
+      errors.push(`Edge "${edge.id}" references non-existent target node "${edge.target}"`);
+    }
+  }
+  const connectedNodeIds = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    connectedNodeIds.add(edge.source);
+    connectedNodeIds.add(edge.target);
+  }
+  for (const node of graph.nodes) {
+    if (node.type === "note") continue;
+    if (!connectedNodeIds.has(node.id)) {
+      errors.push(`Node "${node.data.label}" (${node.type}) is not connected to any other node`);
+    }
+  }
+  for (const edge of graph.edges) {
+    const sourceNode = nodeMap.get(edge.source);
+    const targetNode = nodeMap.get(edge.target);
+    if (!sourceNode || !targetNode) continue;
+    if (sourceNode.type === "tool" && targetNode.type !== "agent") {
+      errors.push(`Tool "${sourceNode.data.label}" can only connect to agent nodes, not ${targetNode.type} nodes`);
+    }
+  }
+  const ruleNodes = graph.nodes.filter((node) => node.type === "rule");
+  for (const ruleNode of ruleNodes) {
+    const incomingEdges = graph.edges.filter((edge) => edge.target === ruleNode.id);
+    const hasAgentSource = incomingEdges.some((edge) => {
+      const sourceNode = nodeMap.get(edge.source);
+      return sourceNode?.type === "agent";
+    });
+    if (incomingEdges.length === 0 || !hasAgentSource) {
+      errors.push(`Rule "${ruleNode.data.label}" must have an incoming connection from an agent`);
+    }
+  }
+  if (agentNodes.length > 1) {
+    const cycleError = detectCycle(agentNodes, graph.edges, nodeMap);
+    if (cycleError) {
+      errors.push(cycleError);
+    }
+  }
+  const startNodes = graph.nodes.filter((node) => node.type === "start");
+  if (startNodes.length > 1) {
+    errors.push("Only one Start node is allowed");
+  }
+  const endNodes = graph.nodes.filter((node) => node.type === "end");
+  if (endNodes.length > 1) {
+    errors.push("Only one End node is allowed");
+  }
+  for (const startNode of startNodes) {
+    const incomingEdges = graph.edges.filter((edge) => edge.target === startNode.id);
+    if (incomingEdges.length > 0) {
+      errors.push("Start node cannot have incoming connections");
+    }
+  }
+  for (const endNode of endNodes) {
+    const outgoingEdges = graph.edges.filter((edge) => edge.source === endNode.id);
+    if (outgoingEdges.length > 0) {
+      errors.push("End node cannot have outgoing connections");
+    }
+  }
+  const ifElseNodes = graph.nodes.filter((node) => node.type === "if_else");
+  for (const ifElseNode of ifElseNodes) {
+    const config = ifElseNode.data.config;
+    if (!config || config.conditions.length === 0) {
+      errors.push("IF/ELSE node must have at least one condition");
+    }
+  }
+  const codeNodes = graph.nodes.filter((node) => node.type === "code");
+  for (const codeNode of codeNodes) {
+    const config = codeNode.data.config;
+    if (!config || !config.code.trim()) {
+      errors.push("Code node must have code content");
+    }
+  }
+  const httpNodes = graph.nodes.filter((node) => node.type === "http_request");
+  for (const httpNode of httpNodes) {
+    const config = httpNode.data.config;
+    if (!config || !config.url.trim()) {
+      errors.push("HTTP Request node must have a URL");
+    }
+  }
+  const templateNodes = graph.nodes.filter((node) => node.type === "template_transform");
+  for (const templateNode of templateNodes) {
+    const config = templateNode.data.config;
+    if (!config || !config.template.trim()) {
+      errors.push("Template node must have template content");
+    }
+  }
+  const knowledgeBaseNodes = graph.nodes.filter((node) => node.type === "knowledge_base");
+  for (const knowledgeBaseNode of knowledgeBaseNodes) {
+    const config = knowledgeBaseNode.data.config;
+    if (!config || !config.sourceId.trim()) {
+      errors.push("Knowledge Base node must have a source configured");
+    }
+  }
+  const iterationNodes = graph.nodes.filter((node) => node.type === "iteration");
+  for (const iterationNode of iterationNodes) {
+    const outgoingEdges = graph.edges.filter((edge) => edge.source === iterationNode.id);
+    if (outgoingEdges.length === 0) {
+      errors.push("Iteration node must have at least one outgoing connection");
+    }
+  }
+  const answerNodes = graph.nodes.filter((node) => node.type === "answer");
+  for (const answerNode of answerNodes) {
+    const config = answerNode.data.config;
+    if (!config || !config.outputTemplate.trim()) {
+      errors.push("Answer node must have a non-empty output template");
+    }
+  }
+  const questionClassifierNodes = graph.nodes.filter((node) => node.type === "question_classifier");
+  for (const questionClassifierNode of questionClassifierNodes) {
+    const config = questionClassifierNode.data.config;
+    if (!config || config.categories.length < 2) {
+      errors.push("Question Classifier node must have at least 2 categories");
+    } else {
+      const emptyCategories = config.categories.filter((category) => !category.name.trim());
+      if (emptyCategories.length > 0) {
+        errors.push("Question Classifier node has categories with empty names");
+      }
+    }
+  }
+  const parameterExtractorNodes = graph.nodes.filter((node) => node.type === "parameter_extractor");
+  for (const parameterExtractorNode of parameterExtractorNodes) {
+    const config = parameterExtractorNode.data.config;
+    if (!config || config.parameters.length === 0) {
+      errors.push("Parameter Extractor node must have at least 1 parameter");
+    } else {
+      const emptyParameters = config.parameters.filter((parameter) => !parameter.name.trim());
+      if (emptyParameters.length > 0) {
+        errors.push("Parameter Extractor node has parameters with empty names");
+      }
+    }
+  }
+  const variableAssignerNodes = graph.nodes.filter((node) => node.type === "variable_assigner");
+  for (const variableAssignerNode of variableAssignerNodes) {
+    const config = variableAssignerNode.data.config;
+    if (!config || config.assignments.length === 0) {
+      errors.push("Variable Assigner node must have at least 1 assignment");
+    }
+  }
+  const variableAggregatorNodes = graph.nodes.filter((node) => node.type === "variable_aggregator");
+  for (const variableAggregatorNode of variableAggregatorNodes) {
+    const config = variableAggregatorNode.data.config;
+    if (!config || config.inputVariables.length === 0) {
+      errors.push("Variable Aggregator node must have at least 1 input variable");
+    }
+    if (!config || !config.outputVariable.trim()) {
+      errors.push("Variable Aggregator node must have a non-empty output variable");
+    }
+  }
+  const documentExtractorNodes = graph.nodes.filter((node) => node.type === "document_extractor");
+  for (const documentExtractorNode of documentExtractorNodes) {
+    const config = documentExtractorNode.data.config;
+    if (!config || !config.outputVariable.trim()) {
+      errors.push("Document Extractor node must have a non-empty output variable");
+    }
+  }
+  const listOperatorNodes = graph.nodes.filter((node) => node.type === "list_operator");
+  for (const listOperatorNode of listOperatorNodes) {
+    const config = listOperatorNode.data.config;
+    if (!config || !config.inputVariable.trim()) {
+      errors.push("List Operator node must have a non-empty input variable");
+    }
+    if (!config || !config.outputVariable.trim()) {
+      errors.push("List Operator node must have a non-empty output variable");
+    }
+  }
+  const iterationStartNodes = graph.nodes.filter((node) => node.type === "iteration_start");
+  for (const iterationStartNode of iterationStartNodes) {
+    const incomingEdges = graph.edges.filter((edge) => edge.target === iterationStartNode.id);
+    const hasIterationSource = incomingEdges.some((edge) => {
+      const sourceNode = nodeMap.get(edge.source);
+      return sourceNode?.type === "iteration";
+    });
+    if (incomingEdges.length === 0 || !hasIterationSource) {
+      errors.push("Iteration Start node must have an incoming connection from an Iteration node");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function detectCycle(agentNodes, edges, nodeMap) {
+  const agentIds = new Set(agentNodes.map((node) => node.id));
+  const adjacencyList = /* @__PURE__ */ new Map();
+  for (const agentId of agentIds) {
+    adjacencyList.set(agentId, []);
+  }
+  for (const edge of edges) {
+    const sourceNode = nodeMap.get(edge.source);
+    const targetNode = nodeMap.get(edge.target);
+    if (sourceNode?.type === "agent" && targetNode?.type === "agent" && agentIds.has(edge.source) && agentIds.has(edge.target)) {
+      adjacencyList.get(edge.source).push(edge.target);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  function hasCycleDfs(nodeId) {
+    visited.add(nodeId);
+    inStack.add(nodeId);
+    const neighbors = adjacencyList.get(nodeId) ?? [];
+    for (const neighbor of neighbors) {
+      if (!visited.has(neighbor)) {
+        if (hasCycleDfs(neighbor)) return true;
+      } else if (inStack.has(neighbor)) {
+        return true;
+      }
+    }
+    inStack.delete(nodeId);
+    return false;
+  }
+  for (const agentId of agentIds) {
+    if (!visited.has(agentId)) {
+      if (hasCycleDfs(agentId)) {
+        return "Cycle detected in agent pipeline \u2014 agents must form a directed acyclic graph (DAG)";
+      }
+    }
+  }
+  return null;
+}
+function topologicalSortAgents(graph) {
+  const agentNodes = graph.nodes.filter((node) => node.type === "agent");
+  const agentIdSet = new Set(agentNodes.map((node) => node.id));
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacencyList = /* @__PURE__ */ new Map();
+  for (const node of agentNodes) {
+    inDegree.set(node.id, 0);
+    adjacencyList.set(node.id, []);
+  }
+  for (const edge of graph.edges) {
+    if (agentIdSet.has(edge.source) && agentIdSet.has(edge.target)) {
+      adjacencyList.get(edge.source).push(edge.target);
+      inDegree.set(edge.target, (inDegree.get(edge.target) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const [nodeId, degree] of inDegree) {
+    if (degree === 0) queue.push(nodeId);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    for (const neighbor of adjacencyList.get(current) ?? []) {
+      const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+  const nodeIdToEntityId = /* @__PURE__ */ new Map();
+  for (const node of agentNodes) {
+    nodeIdToEntityId.set(node.id, node.data.entityId);
+  }
+  return sorted.map((nodeId) => nodeIdToEntityId.get(nodeId) ?? nodeId);
+}
+
+exports.topologicalSortAgents = topologicalSortAgents;
+exports.validateWorkflowGraph = validateWorkflowGraph;
+//# sourceMappingURL=chunk-3GE3MBUZ.js.map
+//# sourceMappingURL=chunk-3GE3MBUZ.js.map