@ema.co/mcp-toolkit 2026.2.23 → 2026.2.27

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

@@ -1,587 +0,0 @@
-/**
- * Workflow Fix/Apply Helpers (MCP-Specific)
- *
- * NOTE: This is DIFFERENT from sdk/workflow-fixer.ts:
- *
- * - applyWorkflowFixes() (here): MCP handler helper that takes PRE-DETECTED issues
- *   and persona context. Handles Voice AI results mapping, HITL paths, etc.
- *
- * - autoFixWorkflow() (SDK): Self-contained auto-detection + fixing without
- *   persona context. Better for SDK consumers who want one-call fixing.
- *
- * These are COMPLEMENTARY, not duplicates.
- */
-/**
- * Generate a human-readable summary of a workflow for Auto Builder prompts.
- * This creates a description the Auto Builder can understand to recreate the workflow.
- */
-export function summarizeWorkflow(workflowDef) {
-    const actions = workflowDef.actions;
-    if (!actions || actions.length === 0) {
-        return "Empty workflow with no actions";
-    }
-    const lines = [];
-    // Count action types
-    const actionTypes = new Map();
-    const nodeNames = [];
-    for (const action of actions) {
-        const actionType = action.actionType;
-        const typeName = actionType?.name?.name ?? "unknown";
-        actionTypes.set(typeName, (actionTypes.get(typeName) ?? 0) + 1);
-        const nodeName = String(action.name ?? "");
-        if (nodeName)
-            nodeNames.push(nodeName);
-    }
-    // Summary header
-    lines.push(`Workflow with ${actions.length} nodes:`);
-    // List action types and counts
-    for (const [type, count] of actionTypes.entries()) {
-        lines.push(`- ${type}: ${count}`);
-    }
-    // List node names
-    if (nodeNames.length > 0) {
-        lines.push(`\nNodes: ${nodeNames.slice(0, 20).join(", ")}${nodeNames.length > 20 ? "..." : ""}`);
-    }
-    const FEATURE_INDICATORS = {
-        categorizer: "This workflow uses intent-based routing with a categorizer.",
-        hitl: "This workflow includes human-in-the-loop approval steps.",
-        general_hitl: "This workflow includes human-in-the-loop approval steps.",
-        entity_extraction: "This workflow extracts structured data from documents.",
-        search: "This workflow searches a knowledge base.",
-    };
-    for (const [actionType, description] of Object.entries(FEATURE_INDICATORS)) {
-        if (actionTypes.has(actionType)) {
-            lines.push(`\n${description}`);
-        }
-    }
-    // Include raw workflow JSON for Auto Builder to parse
-    lines.push("\n--- Full workflow_def JSON ---");
-    lines.push(JSON.stringify(workflowDef, null, 2));
-    return lines.join("\n");
-}
-/**
- * Apply automatic fixes to a workflow based on detected issues.
- * This function attempts to fix common issues like missing WORKFLOW_OUTPUT,
- * wrong input sources, and other structural problems.
- *
- * @deprecated This function violates the LLM-driven architecture principle.
- * MCP should not auto-fix workflows - it should return suggestions for the Agent to apply.
- * Per CLAUDE.md: "Auto-fix issues | ❌ FORBIDDEN | ✅ Proposes fixes"
- *
- * This function will be removed in a future version. Instead:
- * 1. Use workflow(mode="get") to get current workflow_def
- * 2. Return issues as suggestions to the Agent
- * 3. Agent modifies workflow_def and deploys via workflow(mode="deploy")
- */
-export function applyWorkflowFixes(workflowDef, issues, persona) {
-    // Log deprecation warning
-    console.warn("[DEPRECATED] applyWorkflowFixes() called - this function violates LLM-driven architecture and will be removed");
-    // Deep clone the workflow to avoid mutating the original
-    const fixedWorkflow = JSON.parse(JSON.stringify(workflowDef));
-    const appliedFixes = [];
-    const actions = fixedWorkflow.actions;
-    if (!actions) {
-        return { fixedWorkflow, appliedFixes: [{ issue_type: "unknown", description: "No actions array found in workflow", applied: false }] };
-    }
-    for (const issue of issues) {
-        let fixed = false;
-        let fixDescription = "";
-        let failReason = "";
-        switch (issue.type) {
-            case "missing_workflow_output": {
-                // For Voice AI, WORKFLOW_OUTPUT is handled via results mapping, not a node
-                // Check if results mapping exists
-                const results = fixedWorkflow.results;
-                if (results && Object.keys(results).length > 0) {
-                    // Results mapping exists, this is valid for Voice AI
-                    fixed = true;
-                    fixDescription = "Workflow uses results mapping (valid for Voice AI) - no WORKFLOW_OUTPUT node needed";
-                }
-                else {
-                    // Try to add results mapping for all response nodes
-                    const responseNodes = actions.filter(a => {
-                        const name = String(a.name ?? "");
-                        return name.includes("respond") || name.includes("response");
-                    });
-                    if (responseNodes.length > 0) {
-                        const newResults = {};
-                        for (const respNode of responseNodes) {
-                            const nodeName = String(respNode.name);
-                            newResults[`${nodeName}.response_with_sources`] = {
-                                actionName: nodeName,
-                                outputName: "response_with_sources",
-                            };
-                        }
-                        fixedWorkflow.results = newResults;
-                        fixed = true;
-                        fixDescription = `Added results mapping for ${responseNodes.length} response node(s)`;
-                    }
-                    else {
-                        failReason = "No response nodes found to map to results";
-                    }
-                }
-                break;
-            }
-            case "wrong_input_source": {
-                const targetNode = actions.find(a => String(a.name) === issue.node);
-                if (!targetNode || !targetNode.inputs) {
-                    failReason = `Could not find node "${issue.node}" or its inputs`;
-                    break;
-                }
-                const inputs = targetNode.inputs;
-                const nodeType = String(targetNode.actionType || targetNode.type || "");
-                // CASE 1: Email field needs entity extraction
-                // This requires adding a new node, not just rebinding
-                const isEmailField = issue.reason?.toLowerCase().includes("email") ||
-                    issue.current?.toLowerCase().includes("email_to") ||
-                    (nodeType.includes("send_email") && inputs.email_to);
-                if (isEmailField && inputs.email_to) {
-                    // Check if entity_extraction already exists
-                    let extractorNode = actions.find(a => String(a.actionType || a.type || "").includes("entity_extraction") ||
-                        String(a.name).includes("entity_extract"));
-                    if (!extractorNode) {
-                        // Create entity_extraction node
-                        const extractorName = "entity_extractor_email";
-                        extractorNode = {
-                            name: extractorName,
-                            actionType: "entity_extraction",
-                            inputs: {
-                                conversation: {
-                                    actionOutput: {
-                                        actionName: "trigger",
-                                        output: "chat_conversation",
-                                    },
-                                },
-                                entities_to_extract: {
-                                    literalValue: {
-                                        value: "email_address",
-                                    },
-                                },
-                            },
-                            outputs: ["email_address", "extracted_entities"],
-                        };
-                        actions.push(extractorNode);
-                        // Wire email_to to use extracted email
-                        inputs.email_to = {
-                            actionOutput: {
-                                actionName: extractorName,
-                                output: "email_address",
-                            },
-                        };
-                        fixed = true;
-                        fixDescription = `Added entity_extraction node "${extractorName}" and wired ${issue.node}.email_to to use extracted email_address`;
-                    }
-                    else {
-                        // Extractor exists, just rewire
-                        inputs.email_to = {
-                            actionOutput: {
-                                actionName: String(extractorNode.name),
-                                output: "email_address",
-                            },
-                        };
-                        fixed = true;
-                        fixDescription = `Wired ${issue.node}.email_to to use ${extractorNode.name}.email_address`;
-                    }
-                    break;
-                }
-                // CASE 2: Simple rebinding (conversation/query sources)
-                let inputField;
-                const possibleFields = ["conversation", "query", "input", "text"];
-                for (const field of possibleFields) {
-                    if (inputs[field]) {
-                        inputField = field;
-                        break;
-                    }
-                }
-                if (inputField && inputs[inputField]) {
-                    const inputBinding = inputs[inputField];
-                    if (inputBinding.actionOutput) {
-                        const actionOutput = inputBinding.actionOutput;
-                        // Update to use recommended source
-                        if (issue.recommended === "chat_conversation") {
-                            actionOutput.actionName = "trigger";
-                            actionOutput.output = "chat_conversation";
-                            fixed = true;
-                        }
-                        else if (issue.recommended === "user_query") {
-                            actionOutput.actionName = "trigger";
-                            actionOutput.output = "user_query";
-                            fixed = true;
-                        }
-                        else if (issue.recommended === "summarized_conversation") {
-                            // Check if summarizer exists
-                            const summarizer = actions.find(a => String(a.name).includes("summarizer") ||
-                                String(a.name).includes("conversation_to_search"));
-                            if (summarizer) {
-                                actionOutput.actionName = String(summarizer.name);
-                                actionOutput.output = "summarized_conversation";
-                                fixed = true;
-                            }
-                            else {
-                                failReason = "Recommended summarized_conversation but no summarizer node exists";
-                                break;
-                            }
-                        }
-                        if (fixed) {
-                            fixDescription = `Changed ${issue.node}.${inputField} from ${issue.current} to ${issue.recommended}`;
-                        }
-                    }
-                }
-                else if (!inputField) {
-                    failReason = `Could not find input field (tried: conversation, query, input, text) in node "${issue.node}"`;
-                }
-                if (!fixed && !failReason) {
-                    failReason = `Could not determine how to fix input source for "${issue.node}"`;
-                }
-                break;
-            }
-            case "incomplete_hitl": {
-                // This requires adding new nodes which is complex
-                // Mark as not auto-fixable
-                failReason = "HITL paths require manual configuration of success/failure response nodes";
-                break;
-            }
-            case "missing_category_edge": {
-                // Check if using runIf pattern (valid alternative to edges)
-                const nodesWithRunIf = actions.filter(a => a.runIf !== undefined);
-                const categorizerName = issue.node;
-                const nodesUsingCategorizer = nodesWithRunIf.filter(a => {
-                    const runIf = a.runIf;
-                    if (!runIf?.lhs)
-                        return false;
-                    const lhs = runIf.lhs;
-                    const actionOutput = lhs.actionOutput;
-                    return actionOutput?.actionName === categorizerName;
-                });
-                if (nodesUsingCategorizer.length > 0) {
-                    fixed = true;
-                    fixDescription = `Categorizer "${categorizerName}" uses runIf pattern (${nodesUsingCategorizer.length} conditional nodes) - valid alternative to explicit edges`;
-                }
-                else {
-                    failReason = "Categorizer needs manual configuration of category routing edges";
-                }
-                break;
-            }
-            case "malformed_runif": {
-                // Fix malformed runIf: "category_<Name>" vs "true" -> "category" vs "<Name>"
-                const targetNode = actions.find(a => String(a.name) === issue.node);
-                if (targetNode?.runIf) {
-                    const runIf = targetNode.runIf;
-                    const lhs = runIf.lhs;
-                    const rhs = runIf.rhs;
-                    if (lhs?.actionOutput && rhs?.inline) {
-                        const actionOutput = lhs.actionOutput;
-                        const inlineRhs = rhs.inline;
-                        const output = String(actionOutput.output ?? "");
-                        if (output.startsWith("category_")) {
-                            // Extract category name and fix the format
-                            const categoryName = output.replace(/^category_/, "");
-                            actionOutput.output = "category";
-                            inlineRhs.enumValue = categoryName;
-                            fixed = true;
-                            fixDescription = `Fixed runIf for "${issue.node}": output="category", enumValue="${categoryName}"`;
-                        }
-                    }
-                }
-                if (!fixed) {
-                    failReason = `Could not find node "${issue.node}" or its runIf condition`;
-                }
-                break;
-            }
-            case "malformed_hitl_runif": {
-                // Fix malformed HITL runIf: "hitl_status_HITL Success" -> output="hitl_status", enumValue="HITL Success"
-                const targetNodeHitl = actions.find(a => String(a.name) === issue.node);
-                if (targetNodeHitl?.runIf) {
-                    const runIfHitl = targetNodeHitl.runIf;
-                    const lhsHitl = runIfHitl.lhs;
-                    const rhsHitl = runIfHitl.rhs;
-                    if (lhsHitl?.actionOutput && rhsHitl?.inline) {
-                        const actionOutputHitl = lhsHitl.actionOutput;
-                        const inlineRhsHitl = rhsHitl.inline;
-                        const outputHitl = String(actionOutputHitl.output ?? "");
-                        // Malformed patterns: "hitl_status_HITL Success" or "hitl_status_HITL Failure" or "hitl_status HITL Success"
-                        const hitlMatch = outputHitl.match(/^hitl_status[_\s]?(HITL[ _]?(?:Success|Failure))$/i);
-                        if (hitlMatch) {
-                            // Extract the enum value (e.g., "HITL Success")
-                            let enumVal = hitlMatch[1].replace(/_/g, " ");
-                            // Normalize to "HITL Success" or "HITL Failure"
-                            if (enumVal.toLowerCase().includes("success")) {
-                                enumVal = "HITL Success";
-                            }
-                            else if (enumVal.toLowerCase().includes("failure")) {
-                                enumVal = "HITL Failure";
-                            }
-                            actionOutputHitl.output = "hitl_status";
-                            inlineRhsHitl.enumValue = enumVal;
-                            fixed = true;
-                            fixDescription = `Fixed HITL runIf for "${issue.node}": output="hitl_status", enumValue="${enumVal}"`;
-                        }
-                    }
-                }
-                if (!fixed) {
-                    failReason = `Could not find node "${issue.node}" or its runIf condition`;
-                }
-                break;
-            }
-            case "orphan": {
-                // Remove orphan nodes
-                const orphanIndex = actions.findIndex(a => String(a.name) === issue.node);
-                if (orphanIndex >= 0) {
-                    actions.splice(orphanIndex, 1);
-                    fixed = true;
-                    fixDescription = `Removed orphan node "${issue.node}" (not connected to workflow)`;
-                }
-                else {
-                    failReason = `Could not find orphan node "${issue.node}" to remove`;
-                }
-                break;
-            }
-            case "redundant_search": {
-                // This is an optimization, not a critical fix - skip auto-fix
-                failReason = "Redundant search is an optimization suggestion - consider consolidating manually";
-                break;
-            }
-            case "type_mismatch": {
-                // Type mismatch fix strategy:
-                // 1. Handle multiBinding inputs - find and fix bindings inside multiBinding
-                // 2. Handle nested named_inputs targets - find binding inside named_inputs.multiBinding
-                // 3. For CHAT_CONVERSATION expected: use trigger.chat_conversation, move old to named_inputs
-                // 4. For SEARCH_RESULT expected: find actual search node output
-                // 5. For DOCUMENT/TEXT_WITH_SOURCES mismatches: move to named_inputs (accepts ANY type)
-                const sourceNode = issue.source?.split(".")[0];
-                const sourceOutput = issue.source?.split(".")[1];
-                const targetNode = issue.target?.split(".")[0];
-                const targetInput = issue.target?.split(".")[1];
-                const expectedType = issue.expected;
-                const gotType = issue.got;
-                if (!sourceNode || !targetNode || !targetInput) {
-                    failReason = "Missing source/target node information";
-                    break;
-                }
-                const targetAction = actions.find(a => String(a.name) === targetNode);
-                if (!targetAction || !targetAction.inputs) {
-                    failReason = `Could not find target node "${targetNode}"`;
-                    break;
-                }
-                const inputs = targetAction.inputs;
-                let inputBinding = inputs[targetInput];
-                let actionOutput;
-                let isNestedInNamedInputs = false;
-                let nestedBindingIndex = -1;
-                // Check for autoDetectedBinding - some bindings use this structure alongside or instead of others
-                if (inputBinding && !inputBinding.actionOutput && inputBinding.autoDetectedBinding) {
-                    const autoBinding = inputBinding.autoDetectedBinding;
-                    if (autoBinding.actionOutput) {
-                        actionOutput = autoBinding.actionOutput;
-                    }
-                }
-                // Check if targetInput is a named_inputs reference (e.g., "named_inputs_conversation")
-                if (!inputBinding && targetInput.startsWith("named_inputs_")) {
-                    const namedInputKey = targetInput.replace("named_inputs_", "");
-                    const namedInputs = inputs.named_inputs;
-                    if (namedInputs?.multiBinding) {
-                        const mb = namedInputs.multiBinding;
-                        if (mb.elements) {
-                            nestedBindingIndex = mb.elements.findIndex(el => el.namedBinding?.name?.toLowerCase() === namedInputKey.toLowerCase());
-                            if (nestedBindingIndex >= 0) {
-                                const namedBinding = mb.elements[nestedBindingIndex].namedBinding;
-                                if (namedBinding?.value?.actionOutput) {
-                                    actionOutput = namedBinding.value.actionOutput;
-                                    isNestedInNamedInputs = true;
-                                    inputBinding = namedBinding.value;
-                                }
-                            }
-                        }
-                    }
-                    // If we couldn't find the binding in multiBinding, the type mismatch for named_inputs
-                    // is actually acceptable since named_inputs accepts ANY type
-                    if (!actionOutput && namedInputs) {
-                        fixed = true;
-                        fixDescription = `${targetNode}.${targetInput} is in named_inputs (accepts any type) - type mismatch is acceptable`;
-                        break;
-                    }
-                }
-                // If direct binding exists, check for actionOutput or multiBinding
-                if (!actionOutput && inputBinding) {
-                    if (inputBinding.actionOutput) {
-                        actionOutput = inputBinding.actionOutput;
-                    }
-                    else if (inputBinding.multiBinding) {
-                        // Handle multiBinding - find the element that references the source node
-                        const mb = inputBinding.multiBinding;
-                        if (mb.elements) {
-                            for (let i = 0; i < mb.elements.length; i++) {
-                                const el = mb.elements[i];
-                                const elActionOutput = el.namedBinding?.value?.actionOutput;
-                                if (elActionOutput && String(elActionOutput.actionName) === sourceNode) {
-                                    actionOutput = elActionOutput;
-                                    nestedBindingIndex = i;
-                                    break;
-                                }
-                            }
-                        }
-                        // Also check if elements have direct actionOutput (not inside namedBinding)
-                        if (!actionOutput && mb.elements) {
-                            for (let i = 0; i < mb.elements.length; i++) {
-                                const el = mb.elements[i];
-                                // Check for actionOutput directly on element
-                                if (el.actionOutput) {
-                                    actionOutput = el.actionOutput;
-                                    nestedBindingIndex = i;
-                                    break;
-                                }
-                            }
-                        }
-                        // If source not found in multiBinding, DON'T mark as fixed - the type mismatch is real
-                        // We need to find and remove/fix the mismatched binding
-                        if (!actionOutput && mb.elements) {
-                            // Find ANY binding that has type mismatch and try to fix it
-                            for (let i = 0; i < mb.elements.length; i++) {
-                                const el = mb.elements[i];
-                                const elActionOutput = el.namedBinding?.value?.actionOutput;
-                                if (elActionOutput) {
-                                    // Use the first actionOutput we find - it's likely the mismatched one
-                                    actionOutput = elActionOutput;
-                                    nestedBindingIndex = i;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                }
-                if (!actionOutput) {
-                    failReason = `No actionOutput binding found for ${targetNode}.${targetInput}`;
-                    break;
-                }
-                // === FIX STRATEGY 1: CHAT_CONVERSATION expected ===
-                // If binding is nested in named_inputs, redirect to trigger.chat_conversation
-                if (expectedType?.includes("CHAT_CONVERSATION")) {
-                    const oldActionName = String(actionOutput.actionName ?? "");
-                    const oldOutput = String(actionOutput.output ?? "");
-                    if (isNestedInNamedInputs) {
-                        // Binding is inside named_inputs - change it to use trigger.chat_conversation
-                        actionOutput.actionName = "trigger";
-                        actionOutput.output = "chat_conversation";
-                        // Rename the named binding to indicate it's now conversation
-                        const namedInputs = inputs.named_inputs;
-                        const mb = namedInputs.multiBinding;
-                        if (mb.elements && nestedBindingIndex >= 0 && mb.elements[nestedBindingIndex]?.namedBinding) {
-                            // Keep the old binding as additional context
-                            mb.elements.push({
-                                namedBinding: {
-                                    name: `${targetInput.replace("named_inputs_", "")}_context`,
-                                    value: { actionOutput: { actionName: oldActionName, output: oldOutput } }
-                                }
-                            });
-                        }
-                        fixed = true;
-                        fixDescription = `Fixed ${targetNode}.${targetInput}: now uses trigger.chat_conversation`;
-                        break;
-                    }
-                    // Standard case: direct binding - change to trigger.chat_conversation
-                    actionOutput.actionName = "trigger";
-                    actionOutput.output = "chat_conversation";
-                    // Add old binding to named_inputs so it's still available
-                    const namedInputs = inputs.named_inputs;
-                    const contextName = targetInput === "conversation" ? "context" : `${targetInput}_context`;
-                    if (namedInputs?.multiBinding) {
-                        // Append to existing multiBinding
-                        const mb = namedInputs.multiBinding;
-                        if (!mb.elements)
-                            mb.elements = [];
-                        mb.elements.push({
-                            namedBinding: {
-                                name: contextName,
-                                value: { actionOutput: { actionName: oldActionName, output: oldOutput } }
-                            }
-                        });
-                    }
-                    else {
-                        // Create new named_inputs with multiBinding
-                        inputs.named_inputs = {
-                            multiBinding: {
-                                elements: [{
-                                        namedBinding: {
-                                            name: contextName,
-                                            value: { actionOutput: { actionName: oldActionName, output: oldOutput } }
-                                        }
-                                    }]
-                            }
-                        };
-                    }
-                    fixed = true;
-                    fixDescription = `Fixed ${targetNode}.${targetInput}: now uses trigger.chat_conversation, old binding moved to named_inputs.${contextName}`;
-                    break;
-                }
-                // === FIX STRATEGY 2: SEARCH_RESULT expected ===
-                // Find an actual search node and use its search_results output
-                if (expectedType?.includes("SEARCH_RESULT") && gotType?.includes("TEXT_WITH_SOURCES")) {
-                    // Find a search node (excluding web_search which has different output)
-                    const searchNode = actions.find(a => {
-                        const name = String(a.name ?? "");
-                        const actionType = a.actionType?.name?.name ?? "";
-                        return (name.includes("search") || actionType.includes("search_datastore"))
-                            && !name.includes("web_search")
-                            && !name.includes("combine");
-                    });
-                    if (searchNode) {
-                        // Change to use search node's output directly
-                        // Don't add old binding to named_inputs - it causes type mismatches
-                        actionOutput.actionName = String(searchNode.name);
-                        actionOutput.output = "search_results";
-                        fixed = true;
-                        fixDescription = `Fixed ${targetNode}.${targetInput}: now uses ${searchNode.name}.search_results`;
-                    }
-                    else {
-                        failReason = `No search_datastore node found to provide SEARCH_RESULT for ${targetNode}`;
-                    }
-                    break;
-                }
-                // === FIX STRATEGY 3: DOCUMENT or other type → remove the mismatched binding ===
-                // Simply remove the bad binding - don't move to named_inputs (causes type mismatches)
-                if (gotType?.includes("DOCUMENT") ||
-                    (expectedType?.includes("TEXT_WITH_SOURCES") && !gotType?.includes("TEXT_WITH_SOURCES"))) {
-                    // If binding is inside multiBinding of the target input, remove the bad element
-                    if (inputBinding?.multiBinding && nestedBindingIndex >= 0) {
-                        const mb = inputBinding.multiBinding;
-                        if (mb.elements && mb.elements.length > 1) {
-                            // Remove the mismatched element, keep others
-                            mb.elements.splice(nestedBindingIndex, 1);
-                            fixed = true;
-                            fixDescription = `Fixed ${targetNode}.${targetInput}: removed mismatched binding from multiBinding`;
-                            break;
-                        }
-                        else if (mb.elements && mb.elements.length === 1) {
-                            // Only one element - remove entire binding
-                            delete inputBinding.multiBinding;
-                        }
-                    }
-                    // Remove the mismatched binding from the typed input entirely
-                    delete inputs[targetInput];
-                    fixed = true;
-                    fixDescription = `Fixed ${targetNode}.${targetInput}: removed mismatched binding (input now unbound)`;
-                    break;
-                }
-                // === FALLBACK: Remove mismatched binding ===
-                // Don't move to named_inputs - it causes type mismatches
-                {
-                    // Remove the mismatched binding entirely
-                    delete inputs[targetInput];
-                    fixed = true;
-                    fixDescription = `Fixed ${targetNode}.${targetInput}: removed mismatched binding (${gotType} → expected ${expectedType})`;
-                }
-                break;
-            }
-            default: {
-                failReason = `Auto-fix not implemented for issue type: ${issue.type}`;
-            }
-        }
-        appliedFixes.push({
-            issue_type: issue.type,
-            description: fixed ? fixDescription : `Could not fix: ${issue.reason}`,
-            applied: fixed,
-            reason: fixed ? undefined : failReason,
-        });
-    }
-    return { fixedWorkflow, appliedFixes };
-}