@ema.co/mcp-toolkit 2026.1.24 → 2026.1.26-3

package/dist/mcp/handlers/workflow/utils.js

@@ -0,0 +1,132 @@
+/**
+ * Shared utilities for workflow handlers
+ */
+/**
+ * Get the type/category of an action node
+ */
+export function getActionType(action) {
+    const name = action.name;
+    if (!name)
+        return "unknown";
+    // Categorize by action name patterns
+    if (name.includes("hitl") || name.includes("human"))
+        return "hitl";
+    if (name.includes("email") || name.includes("send"))
+        return "communication";
+    if (name.includes("search") || name.includes("retrieve"))
+        return "retrieval";
+    if (name.includes("classify") || name.includes("categorize"))
+        return "classification";
+    if (name.includes("generate") || name.includes("compose"))
+        return "generation";
+    if (name.includes("output") || name === "WORKFLOW_OUTPUT")
+        return "output";
+    if (name.includes("input") || name === "WORKFLOW_INPUT")
+        return "input";
+    return "processing";
+}
+/**
+ * Sanitize workflow for deployment
+ * Removes internal-only fields, validates structure
+ */
+export function sanitizeWorkflowForDeploy(workflow) {
+    const sanitized = { ...workflow };
+    // Remove internal fields that shouldn't be sent to API
+    delete sanitized._internal;
+    delete sanitized._metadata;
+    delete sanitized._debug;
+    // Ensure actions array exists
+    if (!sanitized.actions) {
+        sanitized.actions = [];
+    }
+    // Validate and clean actions
+    const actions = sanitized.actions;
+    sanitized.actions = actions.filter(a => {
+        // Must have name
+        if (!a.name || typeof a.name !== "string")
+            return false;
+        // Must have id
+        if (!a.id && !a.name)
+            return false;
+        return true;
+    });
+    return sanitized;
+}
+/**
+ * Check if a node has a path to the output
+ */
+export function checkNodeHasPath(nodeId, connections, outputNodeId, visited = new Set()) {
+    if (nodeId === outputNodeId)
+        return true;
+    if (visited.has(nodeId))
+        return false;
+    visited.add(nodeId);
+    const outgoing = connections.filter(c => c.from === nodeId);
+    for (const conn of outgoing) {
+        if (checkNodeHasPath(conn.to, connections, outputNodeId, visited)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Find orphan nodes (nodes with no path to output)
+ */
+export function findOrphanNodes(workflow) {
+    const actions = workflow.actions;
+    if (!actions || actions.length === 0)
+        return [];
+    // Find output node
+    const outputNode = actions.find(a => a.name?.includes("OUTPUT") ||
+        a.id?.includes("OUTPUT"));
+    if (!outputNode) {
+        // No output node - can't determine orphans
+        return [];
+    }
+    const outputId = (outputNode.id ?? outputNode.name);
+    // Build connection list
+    const connections = [];
+    for (const action of actions) {
+        const inputs = action.inputs;
+        if (inputs) {
+            const actionId = (action.id ?? action.name);
+            for (const [_key, value] of Object.entries(inputs)) {
+                if (typeof value === "string" && value.includes(".")) {
+                    const sourceAction = value.split(".")[0];
+                    connections.push({ from: sourceAction, to: actionId });
+                }
+            }
+        }
+    }
+    // Find orphans
+    const orphans = [];
+    for (const action of actions) {
+        const actionId = (action.id ?? action.name);
+        const actionName = action.name;
+        if (actionId === outputId)
+            continue; // Skip output node
+        if (!checkNodeHasPath(actionId, connections, outputId)) {
+            orphans.push({
+                id: actionId,
+                name: actionName,
+                reason: "No path to output node",
+            });
+        }
+    }
+    return orphans;
+}
+/**
+ * Extract enum type name from a value
+ */
+export function extractEnumTypeName(value) {
+    if (typeof value === "object" && value !== null) {
+        const obj = value;
+        if (typeof obj.name === "string")
+            return obj.name;
+        if (typeof obj.type === "string")
+            return obj.type;
+    }
+    if (typeof value === "string")
+        return value;
+    return undefined;
+}