@ema.co/mcp-toolkit 2026.1.25 → 2026.1.26-4

package/dist/sdk/knowledge.js

@@ -920,90 +920,15 @@ export const QUALIFYING_QUESTIONS = [
     { category: "Guardrails", question: "Are there compliance requirements? (regulations, policies)", whyItMatters: "May need response_validator or compliance_document_analyzer", required: false },
 ];
 // ─────────────────────────────────────────────────────────────────────────────
-// Voice AI Templates
+// Voice AI Templates - REMOVED
+// ─────────────────────────────────────────────────────────────────────────────
+// VOICE_PERSONA_TEMPLATE has been removed.
+// Use the API-first approach instead:
+// 1. client.getPersonaTemplates() - source of truth from API
+// 2. getTemplateFallback("voice") from src/sdk/generated/template-fallbacks.ts
+// 
+// See: scripts/generate-templates.ts for how fallbacks are generated from protos.
 // ─────────────────────────────────────────────────────────────────────────────
-export const VOICE_PERSONA_TEMPLATE = {
-    welcomeMessage: "Hello, thank you for calling {Company}. This is {AI Name}. How can I help you today?",
-    identityAndPurpose: `You are {AI Name}, a Voice AI assistant for {Company}.
-
-Primary responsibility: {Main purpose}
-
-Your responsibilities:
-1. {Responsibility 1}
-2. {Responsibility 2}
-3. {Responsibility 3}
-
-Rules:
-- {Rule 1}
-- {Rule 2}
-- Always be professional and helpful
-- Never provide information you're not certain about`,
-    takeActionInstructions: `</Case 1>
-{Action 1 Name}
-
-Trigger When:
-{Condition that triggers this action}
-
-Intent for tool call: "{Tool Intent Name}"
-
-Required parameters:
-{ "{param1}": "", "{param2}": "" }
-</Case 1>
-
-</Case 2>
-{Action 2 Name}
-
-Trigger When:
-{Condition that triggers this action}
-
-Intent for tool call: "{Tool Intent Name}"
-
-Required parameters:
-{ "{param1}": "" }
-</Case 2>`,
-    hangupInstructions: `End the call when:
-- The caller explicitly says goodbye or asks to hang up
-- The caller confirms they have no more questions
-- {Additional hangup conditions}
-
-Before ending:
-- Confirm all issues are resolved
-- Offer any follow-up information
-- Thank the caller`,
-    transferCallInstructions: `Transfer the call when:
-- The caller explicitly requests a human agent
-- The issue is beyond AI capabilities
-- {Complex scenario requiring human}
-
-Before transferring:
-- Inform the caller you're transferring them
-- Summarize the issue for the human agent`,
-    speechCharacteristics: `**Conversational Style:**
-- Keep responses brief (2-3 sentences per turn)
-- Use warm, professional tone
-- Speak clearly at moderate pace
-
-**Natural Speech:**
-- Use brief pauses between sentences
-- Acknowledge with 'I understand', 'Of course', 'Certainly'
-- Avoid robotic language
-
-**TTS Pronunciation Rules:**
-- Spell out IDs: 'A-B-C-1-2-3'
-- Pause between numbers: 'Your code is... 1... 2... 3... 4'
-- {Domain-specific pronunciation rules}`,
-    systemPrompt: `Tool Calling Instructions:
-
-1. Always collect ALL required parameters before calling a tool
-2. Confirm parameter values with the caller before executing
-3. Wait for tool response before calling another tool
-4. NEVER mention tool names to the user
-5. NEVER guess parameter values - always ask
-6. Use plain language: "Let me look that up" not "Calling the API"
-7. Handle delays with wait message: "One moment while I check..."
-8. Handle errors gracefully, offer alternatives`,
-    waitMessage: "One moment while I look that up for you...",
-};
 // ─────────────────────────────────────────────────────────────────────────────
 // Common Mistakes & Debugging
 // ─────────────────────────────────────────────────────────────────────────────
@@ -2592,13 +2517,18 @@ function detectUnusedCategories(nodes, workflowDef) {
     const categorizers = nodes.filter(n => n.action_name === "chat_categorizer" ||
         n.action_name === "intent_classifier");
     for (const categorizer of categorizers) {
-        // Find the enumType for this categorizer
-        const enumTypeName = categorizer.id + "_enumType";
+        // Find the enumType for this categorizer using typeArguments reference (robust)
+        // The action's typeArguments.categories.enumType points to the correct enumType
+        const categorizerAction = actions.find(a => a.name === categorizer.id);
+        const typeArgs = categorizerAction?.typeArguments;
+        const enumTypeRefName = typeArgs?.categories?.enumType?.name?.name;
         const enumType = enumTypes.find(e => {
             const name = e.name;
             const innerName = name?.name;
             const nameStr = String(innerName?.name ?? name?.name ?? "");
-            return nameStr.includes(categorizer.id) || nameStr.includes("enumType");
+            // Match by typeArguments reference (preferred) or by categorizer ID (fallback)
+            // DO NOT use generic "enumType" fallback - that causes cross-categorizer pollution
+            return (enumTypeRefName && nameStr === enumTypeRefName) || nameStr.includes(categorizer.id);
         });
         if (!enumType)
             continue;
@@ -3768,3 +3698,126 @@ ${issue.missing?.includes("failure") || issue.missing?.includes("both") ? `
     }
     return fixes;
 }
+// ─────────────────────────────────────────────────────────────────────────────
+// Deprecated Actions Registry (GENERATED - DO NOT EDIT)
+// 
+// PRIMARY SOURCE: API via client.listActions() where action.deprecated === true
+// FALLBACK: Generated from ema repo via: npm run generate:deprecated-actions
+// 
+// The generated file is synced automatically by GH Actions from ema repo.
+// To manually regenerate: npm run generate:deprecated-actions -- --path /path/to/ema
+// ─────────────────────────────────────────────────────────────────────────────
+// Re-export from generated file (maintains backwards compatibility)
+export { DEPRECATED_ACTIONS_WITH_REPLACEMENT, DEPRECATED_ACTIONS_NO_REPLACEMENT, ALL_DEPRECATED_ACTIONS, DEPRECATED_AGENT_TYPES, DEPRECATED_ACTIONS_MAP, isActionDeprecated, getActionReplacement, } from "./generated/deprecated-actions.js";
+/**
+ * Constraints that must be satisfied for a workflow to be enabled.
+ * These are checked by the Ema backend when attempting to enable a persona.
+ */
+export const WORKFLOW_ENABLING_CONSTRAINTS = [
+    {
+        id: 1,
+        name: "has_outputs",
+        description: "Workflow must have at least one output wired to WORKFLOW_OUTPUT",
+        errorState: "WORKFLOW_CONTEXT_MISMATCH",
+        errorMessage: "Workflow has no outputs",
+        fix: "Add results.WORKFLOW_OUTPUT = { actionName: '<response_node>', outputName: '<output_field>' }",
+        critical: true,
+    },
+    {
+        id: 2,
+        name: "is_runnable",
+        description: "Workflow must have no missing inputs (all required inputs must be wired)",
+        errorState: "WORKFLOW_INVALID",
+        errorMessage: "Workflow has missing inputs",
+        fix: "Wire all required inputs for each action. Check action schemas for required fields.",
+        critical: true,
+    },
+    {
+        id: 3,
+        name: "no_type_mismatches",
+        description: "All input bindings must have compatible types with their source outputs",
+        errorState: "WORKFLOW_INVALID",
+        errorMessage: "Type mismatch in input bindings",
+        fix: "Ensure source output types match target input types (e.g., TEXT_WITH_SOURCES → TEXT_WITH_SOURCES)",
+        critical: true,
+    },
+    {
+        id: 4,
+        name: "no_cycles",
+        description: "Workflow graph must be acyclic (no circular dependencies)",
+        errorState: "WORKFLOW_INVALID",
+        errorMessage: "Workflow contains cycles",
+        fix: "Remove circular dependencies between nodes. Use parallel branches instead.",
+        critical: true,
+    },
+    {
+        id: 5,
+        name: "no_named_result_errors",
+        description: "All named results must reference valid action outputs",
+        errorState: "WORKFLOW_INVALID",
+        errorMessage: "Named result references invalid action or output",
+        fix: "Verify WORKFLOW_OUTPUT references an existing action name and output field",
+        critical: true,
+    },
+    {
+        id: 6,
+        name: "widgets_exist",
+        description: "All widgets required by actions must exist in persona config",
+        errorState: "WORKFLOW_CONTEXT_MISMATCH",
+        errorMessage: "Missing required widgets",
+        fix: "Add required widgets to proto_config (e.g., conversationSettings for voice)",
+        critical: false,
+    },
+    {
+        id: 7,
+        name: "widgets_ready",
+        description: "FILE_UPLOAD widgets must have ready=true (files processed)",
+        errorState: "WORKFLOW_CONTEXT_MISMATCH",
+        errorMessage: "Widgets not ready",
+        fix: "Wait for file upload processing to complete before enabling",
+        critical: false,
+    },
+];
+/**
+ * Minimum viable workflow structure by trigger type.
+ * Source: ema/ema_backend/db/system_values/persona_templates/
+ */
+export const MINIMUM_VIABLE_WORKFLOWS = {
+    CHAT: {
+        triggerType: "CHAT",
+        requiredNodes: ["chat_trigger"],
+        requiredOutputs: ["WORKFLOW_OUTPUT"],
+        exampleStructure: "chat_trigger → call_llm/custom_agent → WORKFLOW_OUTPUT",
+        notes: "Minimal chat requires trigger and one response-producing action",
+    },
+    CHATBOT: {
+        triggerType: "CHATBOT",
+        requiredNodes: ["chat_trigger"],
+        requiredOutputs: ["WORKFLOW_OUTPUT"],
+        requiredWidgets: ["chatbotSdkConfig"],
+        exampleStructure: "chat_trigger → call_llm/custom_agent → WORKFLOW_OUTPUT",
+        notes: "Same as CHAT but requires chatbotSdkConfig widget for branding",
+    },
+    VOICE: {
+        triggerType: "CHAT", // Voice uses CHAT trigger type
+        requiredNodes: ["chat_trigger"],
+        requiredOutputs: ["WORKFLOW_OUTPUT"],
+        requiredWidgets: ["conversationSettings", "voiceSettings", "callSettings", "vadSettings"],
+        exampleStructure: "chat_trigger → call_llm/custom_agent → WORKFLOW_OUTPUT",
+        notes: "Voice uses CHAT trigger but requires voice-specific widgets for call handling",
+    },
+    DASHBOARD: {
+        triggerType: "DASHBOARD",
+        requiredNodes: ["multi-trigger-doc"],
+        requiredOutputs: ["WORKFLOW_OUTPUT"],
+        exampleStructure: "multi-trigger-doc → custom_agent/extraction → WORKFLOW_OUTPUT",
+        notes: "Dashboard workflows process documents, typically with extraction or analysis",
+    },
+    THREAD: {
+        triggerType: "THREAD",
+        requiredNodes: ["thread_trigger"],
+        requiredOutputs: ["WORKFLOW_OUTPUT"],
+        exampleStructure: "thread_trigger → handler → WORKFLOW_OUTPUT",
+        notes: "Thread workflows handle ticket/agent assist scenarios",
+    },
+};

package/dist/sdk/workflow-intent.js

@@ -528,7 +528,25 @@ const PERSONA_TYPE_PATTERNS = [
     { pattern: /voice|call|phone/i, type: "voice" },
     { pattern: /document|batch|upload/i, type: "dashboard" },
 ];
+/**
+ * @deprecated Use LLM-based intent extraction instead of regex parsing.
+ *
+ * This function uses regex patterns to parse natural language, which is an
+ * anti-pattern. The LLM (Agent) should understand user intent naturally
+ * and provide structured data directly.
+ *
+ * For greenfield workflow generation, consider using:
+ * - Intent Architect for complex requirements analysis
+ * - Direct structured input (WorkflowSpec) from the Agent
+ *
+ * This function is retained for backward compatibility but should not be
+ * used in new code paths.
+ *
+ * @see src/mcp/AGENTS.md for the LLM-driven architecture guidelines
+ */
 export function parseNaturalLanguage(text) {
+    console.warn("[DEPRECATED] parseNaturalLanguage() uses regex parsing which is an anti-pattern. " +
+        "Consider using LLM-based intent extraction or structured input instead.");
     // Detect persona type (default: chat)
     let personaType = "chat";
     for (const { pattern, type } of PERSONA_TYPE_PATTERNS) {
@@ -1457,11 +1475,20 @@ export function intentToSpec(intent) {
         ...(intent.persona_type === "chat" && { chatConfig: { name: intent.name } }),
     };
 }
+/**
+ * Parse input and extract workflow intent.
+ *
+ * Note: The "natural_language" path uses deprecated regex-based parsing.
+ * For new code, prefer providing structured input (partial_spec or full_spec)
+ * directly from the Agent, which understands user intent naturally.
+ */
 export function parseInput(input) {
     const inputType = detectInputType(input);
     let intent;
     switch (inputType) {
         case "natural_language":
+            // DEPRECATED: This path uses regex-based parsing.
+            // Prefer structured input from the Agent instead.
             intent = parseNaturalLanguage(String(input));
             break;
         case "partial_spec":

package/dist/sdk/workflow-transformer.js

@@ -655,345 +655,3 @@ Return ONLY the modified WorkflowSpec JSON, no explanation needed:
 \`\`\`json
 `;
 }
-/**
- * @deprecated MCP should not parse natural language - the Agent IS the LLM.
- * Use agent reasoning instead. Will be removed in future version.
- *
- * Parse natural language intent into deterministic operations.
- * Returns operations that can be executed directly, or indicates LLM is needed.
- */
-export function parseIntent(input, spec) {
-    const ops = [];
-    const lowerInput = input.toLowerCase();
-    const nodeIds = spec.nodes.map(n => n.id);
-    // ─────────────────────────────────────────────────────────────────────────
-    // REMOVE NODE: "remove node X", "delete X", "remove X"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("remove") || lowerInput.includes("delete")) {
-        // Strategy 1: Exact node ID in input
-        for (const nodeId of nodeIds) {
-            if (input.includes(nodeId)) {
-                ops.push({ type: "remove", nodeId });
-            }
-        }
-        // Strategy 2: "remove the node X" pattern
-        if (ops.length === 0) {
-            const match = input.match(/(?:remove|delete)\s+(?:the\s+)?node\s+["']?([a-zA-Z0-9_]+)["']?/i);
-            if (match) {
-                const nodeId = nodeIds.find(id => id.toLowerCase() === match[1].toLowerCase());
-                if (nodeId) {
-                    ops.push({ type: "remove", nodeId });
-                }
-            }
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // RENAME NODE: "rename X to Y", "change displayName of X to Y"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("rename") || lowerInput.includes("displayname")) {
-        const match = input.match(/(?:rename|change\s+displayName\s+of)\s+["']?([a-zA-Z0-9_]+)["']?\s+to\s+["']?([^"'\n]+)["']?/i);
-        if (match) {
-            const nodeId = nodeIds.find(id => id.toLowerCase() === match[1].toLowerCase());
-            if (nodeId) {
-                ops.push({ type: "rename", nodeId, newDisplayName: match[2].trim() });
-            }
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // ADD RUNIF: "add runIf to X when Y.Z equals V"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("runif") || lowerInput.includes("conditional") ||
-        (lowerInput.includes("only run") && lowerInput.includes("when"))) {
-        // Pattern: "add runIf to NODE when SOURCE.OUTPUT equals VALUE"
-        const match = input.match(/(?:add\s+)?runIf\s+to\s+["']?([a-zA-Z0-9_]+)["']?\s+when\s+["']?([a-zA-Z0-9_]+)["']?\.["']?([a-zA-Z0-9_]+)["']?\s+(?:equals?|==|eq)\s+["']?([^"'\n]+)["']?/i);
-        if (match) {
-            const nodeId = nodeIds.find(id => id.toLowerCase() === match[1].toLowerCase());
-            const sourceAction = nodeIds.find(id => id.toLowerCase() === match[2].toLowerCase());
-            if (nodeId && sourceAction) {
-                ops.push({
-                    type: "add_runif",
-                    nodeId,
-                    condition: {
-                        sourceAction,
-                        sourceOutput: match[3],
-                        operator: "eq",
-                        value: match[4].trim(),
-                    },
-                });
-            }
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────────────
-    // ADD TO RESULTS: "add X to results", "include X in output"
-    // ─────────────────────────────────────────────────────────────────────────
-    if (lowerInput.includes("add") && (lowerInput.includes("result") || lowerInput.includes("output"))) {
-        for (const nodeId of nodeIds) {
-            if (input.includes(nodeId)) {
-                // Determine output name based on node type
-                const node = spec.nodes.find(n => n.id === nodeId);
-                const output = node?.actionType === "search" ? "search_results" : "response_with_sources";
-                ops.push({ type: "add_to_results", nodeId, output });
-            }
-        }
-    }
-    // If we found deterministic ops, return them
-    if (ops.length > 0) {
-        return { ops, needs_llm: false };
-    }
-    // Otherwise, this needs LLM for complex interpretation
-    return {
-        ops: [],
-        needs_llm: true,
-        reason: "Could not parse deterministic operations from input. LLM interpretation needed."
-    };
-}
-/**
- * @deprecated MCP should not apply operations - the Agent builds workflow_spec.
- * Will be removed in future version.
- *
- * Apply deterministic modifications to a WorkflowSpec.
- */
-export function applyOperations(spec, ops) {
-    // Deep clone to avoid mutations
-    const newSpec = JSON.parse(JSON.stringify(spec));
-    const changes = [];
-    const errors = [];
-    for (const op of ops) {
-        switch (op.type) {
-            case "remove": {
-                const idx = newSpec.nodes.findIndex(n => n.id === op.nodeId);
-                if (idx >= 0) {
-                    newSpec.nodes.splice(idx, 1);
-                    // Also remove from resultMappings
-                    newSpec.resultMappings = newSpec.resultMappings.filter(rm => rm.nodeId !== op.nodeId);
-                    // Clean up any references in other nodes' inputs - REMOVE them, don't just warn
-                    for (const node of newSpec.nodes) {
-                        if (node.inputs) {
-                            for (const [key, binding] of Object.entries(node.inputs)) {
-                                if (binding.actionName === op.nodeId) {
-                                    // Remove the dangling reference to prevent API errors
-                                    delete node.inputs[key];
-                                    errors.push(`Warning: Removed dangling reference ${node.id}.${key} → ${op.nodeId}`);
-                                }
-                                // Also check namedInputs for dangling refs
-                                if (binding.namedInputs) {
-                                    const originalLen = binding.namedInputs.length;
-                                    binding.namedInputs = binding.namedInputs.filter(ni => ni.binding?.actionName !== op.nodeId);
-                                    if (binding.namedInputs.length < originalLen) {
-                                        errors.push(`Warning: Removed dangling namedInput reference in ${node.id}.${key} → ${op.nodeId}`);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    changes.push(`Removed node: ${op.nodeId}`);
-                }
-                else {
-                    errors.push(`Node not found: ${op.nodeId}`);
-                }
-                break;
-            }
-            case "rename": {
-                const node = newSpec.nodes.find(n => n.id === op.nodeId);
-                if (node) {
-                    const oldName = node.displayName;
-                    node.displayName = op.newDisplayName;
-                    changes.push(`Renamed ${op.nodeId}: "${oldName}" → "${op.newDisplayName}"`);
-                }
-                else {
-                    errors.push(`Node not found: ${op.nodeId}`);
-                }
-                break;
-            }
-            case "add_runif": {
-                const node = newSpec.nodes.find(n => n.id === op.nodeId);
-                if (node) {
-                    node.runIf = op.condition;
-                    changes.push(`Added runIf to ${op.nodeId}: when ${op.condition.sourceAction}.${op.condition.sourceOutput} ${op.condition.operator} "${op.condition.value}"`);
-                }
-                else {
-                    errors.push(`Node not found: ${op.nodeId}`);
-                }
-                break;
-            }
-            case "remove_runif": {
-                const node = newSpec.nodes.find(n => n.id === op.nodeId);
-                if (node) {
-                    delete node.runIf;
-                    changes.push(`Removed runIf from ${op.nodeId}`);
-                }
-                else {
-                    errors.push(`Node not found: ${op.nodeId}`);
-                }
-                break;
-            }
-            case "add_to_results": {
-                const exists = newSpec.resultMappings.some(rm => rm.nodeId === op.nodeId);
-                if (!exists) {
-                    newSpec.resultMappings.push({ nodeId: op.nodeId, output: op.output });
-                    changes.push(`Added ${op.nodeId}.${op.output} to results`);
-                }
-                else {
-                    changes.push(`${op.nodeId} already in results`);
-                }
-                break;
-            }
-            case "remove_from_results": {
-                const idx = newSpec.resultMappings.findIndex(rm => rm.nodeId === op.nodeId);
-                if (idx >= 0) {
-                    newSpec.resultMappings.splice(idx, 1);
-                    changes.push(`Removed ${op.nodeId} from results`);
-                }
-                break;
-            }
-        }
-    }
-    return { spec: newSpec, changes, errors };
-}
-/**
- * Directly patch a workflow_def without recompilation.
- * This preserves ALL original fields and only modifies what's necessary.
- *
- * Use this for simple operations like remove/rename that don't need full recompile.
- */
-function patchWorkflowDef(workflowDef, ops) {
-    const patched = JSON.parse(JSON.stringify(workflowDef));
-    const actions = patched.actions;
-    const results = patched.results;
-    const changes = [];
-    const errors = [];
-    for (const op of ops) {
-        switch (op.type) {
-            case "remove": {
-                const idx = actions.findIndex((a) => a.name === op.nodeId);
-                if (idx >= 0) {
-                    actions.splice(idx, 1);
-                    changes.push(`Removed node: ${op.nodeId}`);
-                    // Remove from results
-                    for (const key of Object.keys(results)) {
-                        if (results[key].actionName === op.nodeId) {
-                            delete results[key];
-                            changes.push(`Removed result mapping: ${key}`);
-                        }
-                    }
-                    // Clean up dangling input references
-                    for (const action of actions) {
-                        const inputs = action.inputs;
-                        if (inputs) {
-                            for (const [inputKey, inputVal] of Object.entries(inputs)) {
-                                const actionOutput = inputVal.actionOutput;
-                                if (actionOutput?.actionName === op.nodeId) {
-                                    delete inputs[inputKey];
-                                    errors.push(`Warning: Removed dangling reference ${action.name}.${inputKey} → ${op.nodeId}`);
-                                }
-                            }
-                        }
-                    }
-                }
-                else {
-                    errors.push(`Node not found: ${op.nodeId}`);
-                }
-                break;
-            }
-            case "rename": {
-                const action = actions.find((a) => a.name === op.nodeId);
-                if (action) {
-                    const displaySettings = action.displaySettings;
-                    if (displaySettings) {
-                        displaySettings.displayName = op.newDisplayName;
-                        changes.push(`Renamed ${op.nodeId} to "${op.newDisplayName}"`);
-                    }
-                }
-                else {
-                    errors.push(`Node not found for rename: ${op.nodeId}`);
-                }
-                break;
-            }
-            // For other operations, we'd need full recompile
-            default:
-                errors.push(`Direct patch not supported for operation: ${op.type}`);
-        }
-    }
-    return { workflow_def: patched, changes, errors };
-}
-/**
- * @deprecated MCP should not transform from intent - the Agent builds workflow_spec.
- * The agent uses analyze to get current spec, reasons about changes, and calls
- * update with the new workflow_spec it built.
- * Will be removed in future version.
- *
- * Transform a workflow based on natural language intent.
- *
- * @param workflowDef - The existing workflow_def JSON
- * @param input - Natural language modification request
- * @param personaType - The persona type (voice, chat, dashboard)
- * @returns IntentTransformResult with modified workflow or LLM prompt
- */
-export function transformWorkflowFromIntent(workflowDef, input, personaType = "chat") {
-    // Step 1: Decompile to spec (for parsing)
-    const spec = decompileWorkflow(workflowDef, personaType);
-    // Step 2: Parse intent into operations
-    const { ops, needs_llm, reason } = parseIntent(input, spec);
-    if (needs_llm) {
-        // Complex modification - return LLM prompt
-        return {
-            success: false,
-            needs_llm: true,
-            llm_prompt: createModificationPrompt(spec, input),
-            changes: [],
-            errors: [reason || "LLM interpretation needed"],
-        };
-    }
-    // Step 3: Check if we can use direct patching (simpler, preserves all fields)
-    const simpleOps = ["remove", "rename"];
-    const allSimple = ops.every(op => simpleOps.includes(op.type));
-    if (allSimple && ops.length > 0) {
-        // Use direct patching - no recompilation needed
-        const { workflow_def, changes, errors } = patchWorkflowDef(workflowDef, ops);
-        if (errors.some(e => !e.startsWith("Warning"))) {
-            return {
-                success: false,
-                workflow_def,
-                changes,
-                errors,
-            };
-        }
-        return {
-            success: true,
-            workflow_def,
-            changes,
-            errors,
-        };
-    }
-    // Step 4: Complex operations - use full decompile → transform → compile
-    const { spec: modifiedSpec, changes, errors } = applyOperations(spec, ops);
-    if (errors.some(e => !e.startsWith("Warning"))) {
-        return {
-            success: false,
-            spec: modifiedSpec,
-            changes,
-            errors,
-        };
-    }
-    // Step 5: Compile back to workflow_def
-    try {
-        const compiled = compileWorkflow(modifiedSpec);
-        // Preserve original workflowName
-        compiled.workflow_def.workflowName = workflowDef.workflowName;
-        return {
-            success: true,
-            spec: modifiedSpec,
-            workflow_def: compiled.workflow_def,
-            changes,
-            errors,
-        };
-    }
-    catch (e) {
-        return {
-            success: false,
-            spec: modifiedSpec,
-            changes,
-            errors: [...errors, `Compilation failed: ${e instanceof Error ? e.message : String(e)}`],
-        };
-    }
-}