@ema.co/mcp-toolkit 2026.2.23 → 2026.2.24

package/dist/mcp/demo-generator.js

@@ -301,6 +301,134 @@ export const DEMO_SCENARIOS = {
             },
         ],
     },
+    "finance-dunning": {
+        id: "finance-dunning",
+        name: "Finance Automated Dunning",
+        description: "AR dunning assistant: balance inquiries, payment links, disputes, payment plans, and escalation",
+        persona_types: ["chat", "voice"],
+        tags: ["finance", "ar", "dunning", "collections", "receivables", "billing"],
+        intents: [
+            {
+                name: "balance_inquiry",
+                description: "What do I owe? Current balance and aging",
+                example_questions: ["What's my balance?", "Do I have any overdue invoices?", "What do I owe?"],
+            },
+            {
+                name: "payment_made",
+                description: "Customer says they already paid",
+                example_questions: ["I paid last week", "I already sent the wire", "Check your records"],
+            },
+            {
+                name: "dispute",
+                description: "Dispute invoice or amount",
+                example_questions: ["This invoice is wrong", "We never received that order", "I'm disputing this charge"],
+            },
+            {
+                name: "payment_plan",
+                description: "Request installments or extension",
+                example_questions: ["Can I pay in two installments?", "I need 30 more days", "Can we set up a payment plan?"],
+            },
+            {
+                name: "how_to_pay",
+                description: "How to pay or payment link",
+                example_questions: ["How do I pay?", "Where's the payment link?", "What payment methods do you accept?"],
+            },
+            {
+                name: "escalate",
+                description: "Request to speak to a person",
+                example_questions: ["I want to talk to someone", "Transfer me to collections", "I need to speak to AR"],
+            },
+            {
+                name: "Fallback",
+                description: "Anything else",
+                example_questions: ["What's the weather?", "Tell me about your company"],
+            },
+        ],
+        entities: [
+            {
+                type: "customer",
+                count: 3,
+                template: {
+                    id: "CUST-AR-{{id}}",
+                    name: "{{name}}",
+                    email: "{{email}}",
+                    payment_terms_days: 30,
+                    payment_plan_active: false,
+                },
+            },
+            {
+                type: "invoice",
+                count: 3,
+                template: {
+                    invoice_id: "INV-{{id}}",
+                    customer_id: "CUST-AR-{{cust}}",
+                    amount_due: "{{amount}}",
+                    due_date: "{{due_date}}",
+                    days_past_due: "{{days}}",
+                    dunning_level: "{{level}}",
+                    payment_link: "{{payment_link}}",
+                },
+            },
+            {
+                type: "dunning_policy",
+                count: 1,
+                template: {
+                    reminder_1_days: "1-7",
+                    reminder_2_days: "8-14",
+                    final_notice_days: "15-30",
+                    escalation_days: "31+",
+                    payment_plan_note: "Payment plan requests are reviewed by AR within 1 business day.",
+                },
+            },
+        ],
+        qa_pairs: [
+            {
+                phase: "intro",
+                question: "Hi, I have a question about my invoice.",
+                answer_template: "Hi! I'm here to help with your invoice and payment questions. I can look up your balance, share the payment link, or help with a dispute or payment plan request. What would you like to do?",
+                intent: "balance_inquiry",
+            },
+            {
+                phase: "main",
+                question: "What do I owe?",
+                answer_template: "Your current balance is {{amount_due}} (invoice {{invoice_id}}, due {{due_date}}). You can pay here: {{payment_link}}. If you need a payment plan or have already paid, tell me and I'll help.",
+                intent: "balance_inquiry",
+                required_entity_type: "invoice",
+            },
+            {
+                phase: "main",
+                question: "How do I pay?",
+                answer_template: "You can pay online using this link: {{payment_link}}. We accept major credit cards and ACH. If you've already paid, please have your payment reference or date ready and I can help verify.",
+                intent: "how_to_pay",
+                required_entity_type: "invoice",
+            },
+            {
+                phase: "main",
+                question: "I already paid last week.",
+                answer_template: "Thanks for letting us know. Our AR team will verify the payment. Can you share the payment reference number or the date you paid? We'll follow up if anything doesn't match.",
+                intent: "payment_made",
+            },
+            {
+                phase: "advanced",
+                question: "This invoice is wrong.",
+                answer_template: "I'm sorry to hear that. I'm not able to adjust invoices here. I've escalated this to our AR team—they'll contact you to resolve the dispute. You should hear back within 1 business day.",
+                intent: "dispute",
+            },
+            {
+                phase: "advanced",
+                question: "Can I pay in two installments?",
+                answer_template: "Payment plan requests are reviewed by our AR team. I've submitted your request; someone will get back to you within 1 business day with options.",
+                intent: "payment_plan",
+                required_entity_type: "dunning_policy",
+            },
+            {
+                phase: "closing",
+                question: "I want to talk to someone.",
+                answer_template: "No problem. I've requested that our AR team contact you. You should hear from someone within 1 business day. Is there anything else I can help with in the meantime?",
+                intent: "escalate",
+            },
+        ],
+    },
 };
 // ─────────────────────────────────────────────────────────────────────────────
 // Sample Entity Data
@@ -473,6 +601,55 @@ export const SAMPLE_ENTITIES = {
             manager: "Bob Director",
         },
     ],
+    invoice: [
+        {
+            id: "INV-2025-001234",
+            invoice_id: "INV-2025-001234",
+            customer_id: "CUST-AR-001",
+            amount_due: 12500.0,
+            currency: "USD",
+            due_date: "2025-01-20",
+            days_past_due: 34,
+            dunning_level: 3,
+            payment_link: "https://pay.example.com/INV-2025-001234",
+            line_items_summary: "Subscription Q1 2025",
+        },
+        {
+            id: "INV-2025-005678",
+            invoice_id: "INV-2025-005678",
+            customer_id: "CUST-AR-002",
+            amount_due: 4850.0,
+            currency: "USD",
+            due_date: "2025-02-01",
+            days_past_due: 22,
+            dunning_level: 3,
+            payment_link: "https://pay.example.com/INV-2025-005678",
+            line_items_summary: "Professional services February 2025",
+        },
+        {
+            id: "INV-2025-009999",
+            invoice_id: "INV-2025-009999",
+            customer_id: "CUST-AR-003",
+            amount_due: 899.0,
+            currency: "USD",
+            due_date: "2025-02-15",
+            days_past_due: 8,
+            dunning_level: 2,
+            payment_link: "https://pay.example.com/INV-2025-009999",
+            line_items_summary: "Monthly license March 2025",
+        },
+    ],
+    dunning_policy: [
+        {
+            id: "dunning-policy",
+            name: "Dunning Policy",
+            reminder_1_days: "1-7",
+            reminder_2_days: "8-14",
+            final_notice_days: "15-30",
+            escalation_days: "31+",
+            payment_plan_note: "Payment plan requests are reviewed by AR within 1 business day. Do not send reminders to customers on active payment plans.",
+        },
+    ],
     benefit: [
         {
             id: "BEN-001",

package/dist/mcp/domain/validation-rules.js

@@ -68,6 +68,19 @@ export const INPUT_SOURCE_RULES = [
         severity: "warning",
         fix: "Use user_query for query, pass chat_conversation via named_inputs if needed",
     },
+    // Rule validation inputs
+    {
+        actionPattern: "rule_validation_with_documents",
+        recommended: "entity_extraction.extraction_columns for map_of_extracted_columns, workflowInput.document for primary_docs",
+        avoid: ["omitting primary_docs", "wiring phases in parallel instead of sequentially"],
+        reason: "rule_validation_with_documents requires both extracted columns and original documents. " +
+            "primary_docs gives the validator context from the original document. " +
+            "When chaining multiple validation phases, wire them sequentially (phase1.ruleset_output → phase2.map_of_extracted_columns) " +
+            "so each phase builds on prior validation results.",
+        severity: "critical",
+        fix: "Wire entity_extraction.extraction_columns → rule_validation.map_of_extracted_columns AND " +
+            "workflowInput.document → rule_validation.primary_docs. For multi-phase: chain sequentially, not in parallel.",
+    },
     // Email-specific rules - GUIDANCE ONLY (not hard backend constraints)
     // NOTE: Backend accepts TEXT_WITH_SOURCES for email_to, so this is soft guidance
     // The correct pattern is: entity_extraction → fixed_response with {{email}} template → send_email

package/dist/mcp/domain/workflow-graph-optimizer.js

@@ -12,7 +12,7 @@ import { AUTO_TRANSFORMS, ADVISORY_TRANSFORMS, } from "./workflow-graph-transfor
 function deepClone(obj) {
     return JSON.parse(JSON.stringify(obj));
 }
-function calculateMetrics(workflowDef, graph) {
+function calculateMetrics(graph) {
     const nodeCount = graph.nodes.size;
     const edgeCount = graph.edges.length;
     // Dead nodes: total - reachable from trigger
@@ -50,6 +50,83 @@ function generateImprovementSummary(before, after) {
     summary += `. ${before.nodeCount} \u2192 ${after.nodeCount} nodes.`;
     return summary;
 }
+/**
+ * Show the immediate neighborhood (parents → node → children) of a set of nodes
+ * from the graph state BEFORE a transform ran. Used to explain why nodes were
+ * classified as dead/trailing so the viewer can verify the reasoning.
+ *
+ * Example output:
+ *   orphaned_search (search)
+ *     ← (no parents — unreachable from trigger)
+ *     → respond_unused
+ *   respond_unused (respond_for_external_actions)
+ *     ← orphaned_search
+ *     → (no children — does not reach any output)
+ */
+function buildNodeNeighborhood(nodeIds, graph) {
+    if (nodeIds.length === 0)
+        return undefined;
+    const resultNodeIds = new Set(graph.outputMappings.map((m) => m.nodeId));
+    const lines = [];
+    for (const nodeId of nodeIds) {
+        const node = graph.nodes.get(nodeId);
+        if (!node)
+            continue;
+        const parents = [...(graph.reverse.get(nodeId) ?? [])];
+        const children = [...(graph.forward.get(nodeId) ?? [])];
+        const parentStr = parents.length > 0
+            ? parents.join(" · ")
+            : "(no parents)";
+        const childStr = children.length > 0
+            ? children.map((c) => resultNodeIds.has(c) ? `${c} [→OUTPUT]` : c).join(" · ")
+            : "(no children — does not reach any output)";
+        lines.push(`  ${nodeId} (${node.actionType})`);
+        lines.push(`    ← ${parentStr}`);
+        lines.push(`    → ${childStr}`);
+    }
+    return lines.join("\n") || undefined;
+}
+/**
+ * Build a compact edge-list flow diagram of the workflow graph.
+ *
+ * Lists nodes in topological order (or declaration order for triggerless workflows),
+ * showing depth, type, children, and which nodes map to outputs.
+ */
+function buildFlowDiagram(graph) {
+    if (graph.nodes.size === 0)
+        return "(empty workflow — no nodes)";
+    const resultNodeIds = new Set(graph.outputMappings.map((m) => m.nodeId));
+    const lines = [];
+    // Header line
+    const triggerNote = graph.trigger
+        ? `entry: ${graph.trigger}`
+        : "no recognized trigger (dashboard/document workflow — all nodes kept)";
+    lines.push(`${graph.nodes.size} nodes · ${graph.edges.length} edges · ${triggerNote}`);
+    // Topological order for consistent depth-first traversal; fall back to declaration order
+    const topoOrder = getTopologicalOrder(graph);
+    const nodeOrder = topoOrder.length === graph.nodes.size ? topoOrder : [...graph.nodes.keys()];
+    for (const nodeId of nodeOrder) {
+        const node = graph.nodes.get(nodeId);
+        if (!node)
+            continue;
+        const children = [...(graph.forward.get(nodeId) ?? [])];
+        const tags = [];
+        if (node.isTrigger)
+            tags.push("ENTRY");
+        if (resultNodeIds.has(nodeId))
+            tags.push("→OUTPUT");
+        if (node.hasSideEffects && !node.isTrigger)
+            tags.push("side-effect");
+        const tagStr = tags.length ? `  [${tags.join(", ")}]` : "";
+        // Indent up to 6 levels to avoid runaway indentation on deep graphs
+        const indent = "  ".repeat(Math.min(node.depth, 6));
+        lines.push(`${indent}${nodeId} (${node.actionType})${tagStr}`);
+        if (children.length > 0) {
+            lines.push(`${indent}  └─► ${children.join(" · ")}`);
+        }
+    }
+    return lines.join("\n");
+}
 function validateWorkflow(workflowDef) {
     const errors = [];
     const warnings = [];
@@ -97,7 +174,7 @@ export function optimizeWorkflow(workflowDef, options) {
     // Graceful handling of invalid input
     if (!workflowDef || typeof workflowDef !== "object") {
         return {
-            workflowDef: workflowDef ?? {},
+            workflowDef: (workflowDef ?? {}),
             modified: false,
             appliedTransforms: [],
             advisories: [],
@@ -107,6 +184,7 @@ export function optimizeWorkflow(workflowDef, options) {
                 improvement: "No changes needed.",
             },
             validation: { valid: false, errors: ["Invalid workflow_def input"], warnings: [] },
+            flow_diagram: "(no workflow_def provided)",
         };
     }
     try {
@@ -114,14 +192,16 @@ export function optimizeWorkflow(workflowDef, options) {
         let currentWorkflowDef = deepClone(workflowDef);
         // Step 2: Calculate "before" metrics
         let graph = buildWorkflowGraph(currentWorkflowDef);
-        const beforeMetrics = calculateMetrics(currentWorkflowDef, graph);
+        const beforeMetrics = calculateMetrics(graph);
         // Step 3: Auto-apply transforms (convergence loop)
+        // Captures pass number and before-graph neighborhood for each change.
         const appliedTransforms = [];
         if (autoApply && maxPasses > 0) {
             for (let pass = 0; pass < maxPasses; pass++) {
                 let anyApplied = false;
                 for (const transform of AUTO_TRANSFORMS) {
                     try {
+                        const graphBefore = graph; // snapshot before this transform
                         const result = transform.apply(currentWorkflowDef, graph);
                         if (result && result.applied) {
                             currentWorkflowDef = result.workflowDef;
@@ -131,6 +211,12 @@ export function optimizeWorkflow(workflowDef, options) {
                                 description: result.description,
                                 nodesRemoved: result.nodesRemoved,
                                 nodesModified: result.nodesModified,
+                                pass: pass + 1,
+                                // Show neighborhood of affected nodes in the before-graph so the
+                                // viewer can verify why each node was classified as removable.
+                                flow_context: result.nodesRemoved.length > 0
+                                    ? buildNodeNeighborhood(result.nodesRemoved, graphBefore)
+                                    : undefined,
                             });
                             anyApplied = true;
                         }
@@ -143,17 +229,15 @@ export function optimizeWorkflow(workflowDef, options) {
                     break; // Converged
             }
         }
-        // Step 4: Calculate "after" metrics
+        // Step 4: Calculate "after" metrics and rebuild final graph
         graph = buildWorkflowGraph(currentWorkflowDef);
-        const afterMetrics = calculateMetrics(currentWorkflowDef, graph);
+        const afterMetrics = calculateMetrics(graph);
         // Step 5: Run advisory transforms
         const advisories = [];
         for (const transform of ADVISORY_TRANSFORMS) {
             try {
                 const result = transform.apply(currentWorkflowDef, graph);
                 if (result && !result.applied) {
-                    // Advisory: applied=false means it's a finding, not a fix
-                    // Extract affected nodes from the description or result fields
                     const affectedNodes = extractAffectedNodes(result);
                     advisories.push({
                         id: transform.id,
@@ -166,21 +250,18 @@ export function optimizeWorkflow(workflowDef, options) {
                 // Advisory failure: skip
             }
         }
-        // Step 6: Generate improvement summary
+        // Step 6: Generate improvement summary + validation + flow diagram
         const improvement = generateImprovementSummary(beforeMetrics, afterMetrics);
-        // Step 7: Post-optimization validation
         const validation = validateWorkflow(currentWorkflowDef);
+        const flow_diagram = buildFlowDiagram(graph);
         return {
             workflowDef: currentWorkflowDef,
             modified: appliedTransforms.length > 0,
             appliedTransforms,
             advisories,
-            metrics: {
-                before: beforeMetrics,
-                after: afterMetrics,
-                improvement,
-            },
+            metrics: { before: beforeMetrics, after: afterMetrics, improvement },
             validation,
+            flow_diagram,
         };
     }
     catch {
@@ -196,6 +277,7 @@ export function optimizeWorkflow(workflowDef, options) {
                 improvement: "No changes needed.",
             },
             validation: { valid: false, errors: ["Optimization failed unexpectedly"], warnings: [] },
+            flow_diagram: "(optimization failed)",
         };
     }
 }

package/dist/mcp/domain/workflow-graph-transforms.js

@@ -66,32 +66,46 @@ function nodeSignature(action) {
     }
     return JSON.stringify({ actionType, version, inputWiring });
 }
-/** Check if an action has side effects based on its type. */
-function hasSideEffects(action) {
-    const actionType = extractActionType(action);
-    const SIDE_EFFECT_FREE = new Set([
-        "search", "call_llm", "entity_extraction", "respond_with_sources",
-        "respond_for_external_actions", "conversation_to_search_query",
-        "combine_search_results", "text_categorizer", "chat_categorizer",
-        "response_validator", "fixed_response", "live_web_search",
-        "ai_web_search", "json_mapper", "custom_agent",
-    ]);
-    const TRIGGER_TYPES = new Set(["chat_trigger", "voice_trigger", "document_trigger"]);
-    if (TRIGGER_TYPES.has(actionType))
-        return false;
-    if (SIDE_EFFECT_FREE.has(actionType))
-        return false;
-    return true;
-}
-/** Check if an action is a trigger node. */
-function isTriggerAction(action) {
-    const actionType = extractActionType(action);
-    return actionType === "chat_trigger" || actionType === "voice_trigger" || actionType === "document_trigger";
-}
 /** Get all node names from actions array. */
 function getActionNames(actions) {
     return new Set(actions.map((a) => a.name).filter(Boolean));
 }
+/**
+ * Recursively rewire actionOutput references from oldName → newName in a binding.
+ * Mirrors extractEdgesFromBinding in workflow-graph.ts: handles the same nesting
+ * depth so graph construction and reference rewiring stay symmetric.
+ *
+ * Handles:
+ *   actionOutput         → base case: mutate actionName if matches
+ *   multiBinding         → recurse into elements[]
+ *   namedBinding         → recurse into .value
+ */
+function rewireBinding(binding, oldName, newName) {
+    if (!binding || typeof binding !== "object")
+        return;
+    if (binding.actionOutput) {
+        const ao = binding.actionOutput;
+        if (ao.actionName === oldName) {
+            ao.actionName = newName;
+        }
+        return;
+    }
+    if (binding.multiBinding) {
+        const mb = binding.multiBinding;
+        const elements = mb.elements ?? [];
+        for (const elem of elements) {
+            rewireBinding(elem, oldName, newName);
+        }
+        return;
+    }
+    if (binding.namedBinding) {
+        const nb = binding.namedBinding;
+        const value = nb.value;
+        if (value) {
+            rewireBinding(value, oldName, newName);
+        }
+    }
+}
 /**
  * Rewire all references from oldName to newName in the actions array.
  * This updates actionOutput bindings, multiBinding refs, and runIf refs.
@@ -101,35 +115,7 @@ function rewireReferences(actions, oldName, newName) {
         const inputs = action.inputs;
         if (inputs) {
             for (const val of Object.values(inputs)) {
-                const binding = val;
-                if (binding?.actionOutput) {
-                    const ao = binding.actionOutput;
-                    if (ao.actionName === oldName) {
-                        ao.actionName = newName;
-                    }
-                }
-                if (binding?.multiBinding) {
-                    const mb = binding.multiBinding;
-                    const elements = mb.elements ?? [];
-                    for (const elem of elements) {
-                        if (elem.namedBinding) {
-                            const nb = elem.namedBinding;
-                            const value = nb.value;
-                            if (value?.actionOutput) {
-                                const ao = value.actionOutput;
-                                if (ao.actionName === oldName) {
-                                    ao.actionName = newName;
-                                }
-                            }
-                        }
-                        else if (elem.actionOutput) {
-                            const ao = elem.actionOutput;
-                            if (ao.actionName === oldName) {
-                                ao.actionName = newName;
-                            }
-                        }
-                    }
-                }
+                rewireBinding(val, oldName, newName);
             }
         }
         // Rewire runIf
@@ -187,7 +173,7 @@ const removeDeadNodes = {
                 const node = graph.nodes.get(nodeId);
                 const hasDisplayName = node.displayName && node.displayName !== nodeId;
                 const isReferencedInResults = Object.values(results).some((r) => r.actionName === nodeId);
-                const hasActionOutputInputs = [...node.inputs.values()].some((ref) => ref.type === "action_output");
+                const hasActionOutputInputs = [...node.inputs.values()].some((ref) => ref.type === "action_output" || ref.type === "multi_binding");
                 if (hasDisplayName || isReferencedInResults || hasActionOutputInputs) {
                     // Intentional node: skip removal (could attempt wiring, but
                     // wiring heuristics are risky so we just keep it)
@@ -310,9 +296,10 @@ const mergeIdenticalNodes = {
             // Group by signature, skipping triggers and side-effect nodes
             const groups = new Map();
             for (const action of actions) {
-                if (isTriggerAction(action))
+                const graphNode = graph.nodes.get(action.name);
+                if (graphNode?.isTrigger)
                     continue;
-                if (hasSideEffects(action))
+                if (graphNode?.hasSideEffects ?? true)
                     continue;
                 const sig = nodeSignature(action);
                 if (!groups.has(sig))
@@ -521,6 +508,15 @@ const removeTrailingNodes = {
         try {
             if (graph.nodes.size === 0)
                 return null;
+            // Dashboard/document workflows have no recognized trigger action.
+            // Without a trigger, every supplier node (which has no forward path to a result
+            // because it IS an upstream input) would be incorrectly classified as trailing.
+            if (!graph.trigger)
+                return null;
+            // Without any result mappings we cannot identify what contributes to output,
+            // so every non-trigger side-effect-free node would appear trailing.
+            if (graph.outputMappings.length === 0)
+                return null;
             // Build set of nodes that contribute to output mappings
             const resultNodes = new Set(graph.outputMappings.map((m) => m.nodeId));
             // Find nodes that are downstream of result nodes but don't contribute to results

package/dist/mcp/domain/workflow-graph.js

@@ -117,23 +117,8 @@ export function buildWorkflowGraph(workflowDef) {
             }
             else if (binding.multiBinding) {
                 inputRefs.set(inputName, { type: "multi_binding" });
-                // Parse elements for nested actionOutput refs
-                const mb = binding.multiBinding;
-                const elements = mb.elements ?? [];
-                for (const elem of elements) {
-                    if (elem.namedBinding) {
-                        const nb = elem.namedBinding;
-                        const value = nb.value;
-                        if (value?.actionOutput) {
-                            const ao = value.actionOutput;
-                            addEdge(edges, forward, reverse, ao.actionName, nodeId, ao.output, inputName);
-                        }
-                    }
-                    else if (elem.actionOutput) {
-                        const ao = elem.actionOutput;
-                        addEdge(edges, forward, reverse, ao.actionName, nodeId, ao.output, inputName);
-                    }
-                }
+                // Recursively traverse nested multiBinding/namedBinding structures to find all actionOutput refs
+                extractEdgesFromBinding(binding, nodeId, inputName, edges, forward, reverse);
             }
             else if (binding.widgetConfig) {
                 inputRefs.set(inputName, { type: "widget" });
@@ -363,6 +348,43 @@ function extractEnumTypeName(et) {
     }
     return undefined;
 }
+/**
+ * Recursively extract actionOutput edges from an arbitrarily nested binding structure.
+ *
+ * Handles:
+ *   actionOutput         → base case: emit edge
+ *   multiBinding         → recurse into elements[]
+ *   namedBinding         → recurse into .value
+ *
+ * This covers nested proto patterns like:
+ *   { multiBinding: { elements: [{ namedBinding: { value: { multiBinding: { elements: [{ actionOutput: {...} }] } } } }] } }
+ */
+function extractEdgesFromBinding(binding, targetNode, targetInput, edges, forward, reverse) {
+    if (!binding || typeof binding !== "object")
+        return;
+    if (binding.actionOutput) {
+        const ao = binding.actionOutput;
+        if (ao.actionName) {
+            addEdge(edges, forward, reverse, ao.actionName, targetNode, ao.output ?? "", targetInput);
+        }
+        return;
+    }
+    if (binding.multiBinding) {
+        const mb = binding.multiBinding;
+        const elements = mb.elements ?? [];
+        for (const elem of elements) {
+            extractEdgesFromBinding(elem, targetNode, targetInput, edges, forward, reverse);
+        }
+        return;
+    }
+    if (binding.namedBinding) {
+        const nb = binding.namedBinding;
+        const value = nb.value;
+        if (value) {
+            extractEdgesFromBinding(value, targetNode, targetInput, edges, forward, reverse);
+        }
+    }
+}
 function addEdge(edges, forward, reverse, source, target, sourceOutput, targetInput) {
     edges.push({ source, target, sourceOutput, targetInput });
     if (!forward.has(source))