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

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)}`],
-        };
-    }
-}