@ema.co/mcp-toolkit 2026.1.27 → 2026.1.28-2

package/dist/sdk/workflow-intent.js

@@ -156,22 +156,8 @@ export function detectInputType(input) {
 // ─────────────────────────────────────────────────────────────────────────────
 // Natural Language Parsing
 // ─────────────────────────────────────────────────────────────────────────────
-const INTENT_PATTERNS = [
-    { pattern: /password\s*reset/i, name: "Password Reset", handler: "llm" },
-    { pattern: /billing|payment|invoice/i, name: "Billing", handler: "search" },
-    { pattern: /technical|support|help/i, name: "Technical Support", handler: "search" },
-    { pattern: /schedule|appointment|book/i, name: "Scheduling", handler: "tool" },
-    { pattern: /ticket|incident|request/i, name: "Ticket Creation", handler: "tool" },
-    { pattern: /status|check|lookup/i, name: "Status Check", handler: "search" },
-];
-const TOOL_PATTERNS = [
-    { pattern: /servicenow/i, namespace: "service_now", action: "Create_Incident" },
-    { pattern: /salesforce/i, namespace: "salesforce", action: "Create_Case" },
-    { pattern: /jira/i, namespace: "jira", action: "Create_Issue" },
-    { pattern: /slack/i, namespace: "slack", action: "Send_Message" },
-    { pattern: /email/i, namespace: "email", action: "Send_Email" },
-    { pattern: /calendar|schedule/i, namespace: "calendar", action: "Check_Availability" },
-];
+// INTENT_PATTERNS and TOOL_PATTERNS removed - were only used by parseNaturalLanguage()
+// which violated LLM-driven architecture. Agent should understand intent naturally.
 // ─────────────────────────────────────────────────────────────────────────────
 // Action Chain Patterns - End-to-End Semantic Flows
 // ─────────────────────────────────────────────────────────────────────────────
@@ -529,83 +515,26 @@ export function detectActionChains(text) {
     }
     return detected.filter(Boolean);
 }
-const PERSONA_TYPE_PATTERNS = [
-    { pattern: /voice|call|phone/i, type: "voice" },
-    { pattern: /document|batch|upload/i, type: "dashboard" },
-];
+// PERSONA_TYPE_PATTERNS removed - no longer used after parseNaturalLanguage() removal
 /**
- * @deprecated Use LLM-based intent extraction instead of regex parsing.
+ * REMOVED: parseNaturalLanguage() - regex-based NL parsing violates LLM-driven architecture
  *
- * 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.
+ * This function was removed because it violates the core principle:
+ * "THE AGENT (LLM) DOES THE THINKING. THE MCP PROVIDES CONTEXT AND EXECUTES."
  *
- * For greenfield workflow generation, consider using:
- * - Intent Architect for complex requirements analysis
- * - Direct structured input (WorkflowSpec) from the Agent
+ * Natural language input should be handled by:
+ * 1. Intent Architect (runIntentArchitect) - analyzes complexity and returns LLM prompts
+ * 2. generateWorkflow() - takes WorkflowIntent and returns LLM prompts for complex cases
+ * 3. Direct structured input (WorkflowSpec) from the Agent
  *
- * This function is retained for backward compatibility but should not be
- * used in new code paths.
+ * For natural language input, create a minimal WorkflowIntent and let Intent Architect
+ * or generateWorkflow() handle the complexity analysis.
  *
  * @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) {
-        if (pattern.test(text)) {
-            personaType = type;
-            break;
-        }
-    }
-    // Detect intents
-    const intents = [];
-    const seenIntents = new Set();
-    for (const { pattern, name, handler } of INTENT_PATTERNS) {
-        if (pattern.test(text) && !seenIntents.has(name)) {
-            seenIntents.add(name);
-            intents.push({
-                name,
-                description: `User requests ${name.toLowerCase()}`,
-                handler,
-            });
-        }
-    }
-    // Detect tools from text
-    const tools = [];
-    for (const { pattern, namespace, action } of TOOL_PATTERNS) {
-        if (pattern.test(text)) {
-            tools.push({ namespace, action });
-        }
-    }
-    // Detect data sources
-    const dataSources = [];
-    if (/search|knowledge|faq|document|lookup|kb/i.test(text)) {
-        dataSources.push({ type: "knowledge_base" });
-    }
-    if (/web|internet|online|live/i.test(text)) {
-        dataSources.push({ type: "web_search" });
-    }
-    if (dataSources.length === 0) {
-        // Default to KB search for most use cases
-        dataSources.push({ type: "knowledge_base" });
-    }
-    // Detect constraints
-    const constraints = {};
-    if (/approv|human|review|escalat|hitl/i.test(text)) {
-        constraints.require_hitl = true;
-    }
-    if (/validat|check|verify/i.test(text)) {
-        constraints.require_validation = true;
-    }
-    // Detect action chains - end-to-end semantic flows
-    const actionChains = detectActionChains(text);
-    // Detect entities to extract
-    const entities = detectEntities(text);
-    // Detect delivery configuration
-    const deliveryConfig = detectDeliveryConfig(text);
+function createMinimalIntentFromText(text, personaType = "chat") {
+    // Create minimal intent - no regex parsing
+    // Intent Architect and generateWorkflow() will handle complexity analysis
     // Extract a name from the text (first sentence or first N words)
     const sentences = text.split(/[.!?]/);
     const name = sentences[0].trim().slice(0, 50) || "AI Employee";
@@ -613,13 +542,6 @@ export function parseNaturalLanguage(text) {
         name,
         description: text,
         persona_type: personaType,
-        intents: intents.length > 0 ? intents : undefined,
-        tools: tools.length > 0 ? tools : undefined,
-        data_sources: dataSources,
-        constraints: Object.keys(constraints).length > 0 ? constraints : undefined,
-        action_chains: actionChains.length > 0 ? actionChains : undefined,
-        entities: entities.length > 0 ? entities : undefined,
-        delivery_config: deliveryConfig,
     };
 }
 /**
@@ -1527,9 +1449,19 @@ export function parseInput(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));
+            // Create minimal intent - no regex parsing
+            // Intent Architect and generateWorkflow() will handle complexity
+            const text = String(input);
+            // Detect persona type from args if available, otherwise default to chat
+            let personaType = "chat";
+            // Simple detection - can be overridden by args.type in handler
+            if (/voice|call|phone/i.test(text)) {
+                personaType = "voice";
+            }
+            else if (/document|batch|upload/i.test(text)) {
+                personaType = "dashboard";
+            }
+            intent = createMinimalIntentFromText(text, personaType);
             break;
         case "partial_spec":
             intent = parsePartialSpec(input);

package/dist/sdk/workflow-path-enumerator.js

@@ -0,0 +1,278 @@
+/**
+ * Workflow Path Enumeration
+ *
+ * Implements the Go validator's path enumeration algorithm for static validation.
+ * Enumerates all possible execution paths in a workflow by:
+ * 1. Traversing workflow graph topologically
+ * 2. Forking sessions on branching actions (categorizers, enums, booleans)
+ * 3. Tracking completed paths with their outputs
+ *
+ * Based on: workflow-engine/pkg/engine/validator.go
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Path Enumeration
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Enumerate all possible execution paths in a workflow.
+ *
+ * Algorithm:
+ * 1. Create initial session
+ * 2. Queue initial session
+ * 3. While queue not empty:
+ *    a. Dequeue session
+ *    b. Run validation on session
+ *    c. If branching: fork for each possible value, queue forked sessions
+ *    d. If completed: validate named results, store path info
+ * 4. Return completed paths
+ */
+export function enumeratePaths(workflow, options) {
+    const maxPaths = options?.max_paths ?? 1000;
+    const timeout = options?.timeout_ms ?? 100;
+    const startTime = Date.now();
+    const completedPaths = [];
+    const sessionsToProcess = [createInitialSession(workflow)];
+    while (sessionsToProcess.length > 0) {
+        // Check timeout
+        if (Date.now() - startTime > timeout) {
+            throw new Error(`Path enumeration timeout after ${timeout}ms`);
+        }
+        // Check max paths
+        if (completedPaths.length >= maxPaths) {
+            throw new Error(`Path enumeration exceeded max paths limit: ${maxPaths}`);
+        }
+        // Dequeue session
+        const session = sessionsToProcess.shift();
+        // Run validation on session
+        const result = runValidationOnSession(session, workflow);
+        if (result.outcome === "branch") {
+            // Fork session for each possible value
+            if (!result.branch_point) {
+                throw new Error("Branch outcome without branch_point");
+            }
+            for (const value of result.branch_point.possible_values) {
+                const forkedSession = forkSessionForBranching(session, result.branch_point, value);
+                sessionsToProcess.push(forkedSession);
+            }
+        }
+        else if (result.outcome === "completed") {
+            // Store completed path
+            const pathInfo = {
+                completed_actions: result.completed_actions || [],
+                final_outputs: result.final_outputs || {},
+                action_name: session.last_branching_action?.action_that_branched ||
+                    (result.completed_actions?.[result.completed_actions.length - 1] || ""),
+                enumerable_output: session.last_branching_action?.branching_output_name,
+                chosen_enumerable_value: session.last_branching_action?.chosen_value,
+                validation_failed: result.validation_failed || false,
+            };
+            completedPaths.push(pathInfo);
+        }
+    }
+    return completedPaths;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Session Management
+// ─────────────────────────────────────────────────────────────────────────────
+function createInitialSession(workflow) {
+    return {
+        completed_actions: [],
+        available_outputs: new Map(),
+        action_states: new Map(),
+    };
+}
+function forkSessionForBranching(session, branchInfo, chosenValue) {
+    // Deep copy session
+    const forked = {
+        completed_actions: [...session.completed_actions],
+        available_outputs: new Map(session.available_outputs),
+        action_states: new Map(session.action_states),
+        last_branching_action: {
+            action_that_branched: branchInfo.action_that_branched,
+            branching_output_name: branchInfo.branching_output_name,
+            possible_values: branchInfo.possible_values,
+            chosen_value: chosenValue,
+        },
+    };
+    // Mark branching action as completed
+    forked.action_states.set(branchInfo.action_that_branched, "completed");
+    forked.completed_actions.push(branchInfo.action_that_branched);
+    // Add branching output to available outputs
+    const outputKey = `${branchInfo.action_that_branched}.${branchInfo.branching_output_name}`;
+    forked.available_outputs.set(outputKey, {
+        node_id: branchInfo.action_that_branched,
+        output_name: branchInfo.branching_output_name,
+    });
+    // TODO: Generate dummy outputs for other outputs of branching action
+    // TODO: Generate dummy outputs for non-branching actions
+    return forked;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Validation Execution
+// ─────────────────────────────────────────────────────────────────────────────
+function runValidationOnSession(session, workflow) {
+    // Find next actions to execute (topological order)
+    const nextActions = findExecutableActions(session, workflow);
+    if (nextActions.length === 0) {
+        // No more actions to execute - path is complete
+        return {
+            outcome: "completed",
+            completed_actions: session.completed_actions,
+            final_outputs: extractFinalOutputs(session),
+            validation_failed: false,
+        };
+    }
+    // Check for branching actions
+    for (const action of nextActions) {
+        const branchInfo = detectBranchingAction(action, workflow);
+        if (branchInfo) {
+            return {
+                outcome: "branch",
+                branch_point: branchInfo,
+            };
+        }
+    }
+    // Execute non-branching actions and track outputs
+    for (const action of nextActions) {
+        session.action_states.set(action.id, "completed");
+        session.completed_actions.push(action.id);
+        // Track outputs from this action
+        // For validation, we mark that this node produces outputs
+        // The actual output name depends on action type - use common patterns
+        addActionOutputs(session, action);
+    }
+    // Continue traversal
+    return runValidationOnSession(session, workflow);
+}
+/**
+ * Add outputs from an action to the session's available_outputs.
+ * Maps action types to their known outputs.
+ */
+function addActionOutputs(session, action) {
+    // Common outputs by action type (simplified - LLM knows the full schema)
+    const outputsByType = {
+        chat_trigger: ["user_query", "conversation_id"],
+        document_trigger: ["document_content"],
+        search: ["search_results", "sources"],
+        call_llm: ["llm_response", "response"],
+        respond_with_sources: ["response_with_sources"],
+        fixed_response: ["response"],
+        external_action_caller: ["action_result"],
+        chat_categorizer: ["category", "confidence"],
+        text_categorizer: ["category", "confidence"],
+    };
+    const outputs = outputsByType[action.actionType] || ["output"];
+    for (const outputName of outputs) {
+        const key = `${action.id}.${outputName}`;
+        session.available_outputs.set(key, {
+            node_id: action.id,
+            output_name: outputName,
+        });
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Helper Functions
+// ─────────────────────────────────────────────────────────────────────────────
+function findExecutableActions(session, workflow) {
+    // Find actions whose inputs are all satisfied
+    const executable = [];
+    for (const node of workflow.nodes || []) {
+        if (session.action_states.get(node.id) === "completed") {
+            continue; // Already executed
+        }
+        // Check if all inputs are available
+        const allInputsSatisfied = checkInputsSatisfied(node, session, workflow);
+        if (allInputsSatisfied) {
+            executable.push(node);
+        }
+    }
+    return executable;
+}
+function checkInputsSatisfied(node, session, _workflow) {
+    // Triggers have no dependencies - always executable first
+    if (node.actionType.includes("trigger")) {
+        return session.completed_actions.length === 0; // Only at start
+    }
+    // Check if all input sources are completed
+    if (!node.inputs) {
+        return true; // No inputs required
+    }
+    for (const [_inputName, binding] of Object.entries(node.inputs)) {
+        // Literal/inline inputs are always available
+        if (binding.type === "literal" ||
+            binding.type === "inline_string" ||
+            binding.type === "inline_number" ||
+            binding.type === "inline_bool" ||
+            binding.type === "llm_inferred") {
+            continue;
+        }
+        // Action output - check if source action is completed
+        if (binding.type === "action_output" && binding.actionName) {
+            if (session.action_states.get(binding.actionName) !== "completed") {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function detectBranchingAction(node, _workflow) {
+    // Categorizers branch based on category selection
+    // LLM already knows this from rules - this is just the automated check
+    if (node.actionType === "chat_categorizer" ||
+        node.actionType === "text_categorizer") {
+        const categories = node.categories || [];
+        if (categories.length > 0) {
+            return {
+                action_that_branched: node.id,
+                branching_output_name: "category",
+                possible_values: categories.map((c) => c.name),
+                chosen_value: undefined,
+            };
+        }
+    }
+    // Note: Boolean/enum outputs could also branch, but categorizers are the
+    // primary branching mechanism in workflows. LLM handles other cases via rules.
+    return null;
+}
+function extractFinalOutputs(session) {
+    const outputs = {};
+    // Keys are already in "nodeId.outputName" format from addActionOutputs
+    for (const [key, value] of session.available_outputs.entries()) {
+        outputs[key] = { node_id: value.node_id, output_name: value.output_name };
+    }
+    return outputs;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Branching Detection
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Check if an output type is enumerable (can be used for branching).
+ * Enumerable types: enum, boolean
+ */
+export function isOutputTypeEnumerable(outputType) {
+    // Enum types
+    if (outputType.includes("enum") || outputType.includes("Enum")) {
+        return true;
+    }
+    // Boolean types
+    if (outputType === "WELL_KNOWN_TYPE_BOOL" || outputType === "bool" || outputType === "boolean") {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get all possible values for an enumerable output.
+ * For enums: all enum options
+ * For booleans: [true, false]
+ */
+export function getAllPossibleValuesForEnumerableOutput(outputType, enumType) {
+    if (outputType.includes("enum") || outputType.includes("Enum")) {
+        if (enumType?.options) {
+            return enumType.options.map(opt => opt.name);
+        }
+        return [];
+    }
+    if (outputType === "WELL_KNOWN_TYPE_BOOL" || outputType === "bool" || outputType === "boolean") {
+        return [true, false];
+    }
+    return [];
+}