@ema.co/mcp-toolkit 2026.2.13 → 2026.2.23-1

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

@@ -1,384 +0,0 @@
-/**
- * Workflow Generate Handler
- *
- * Handles greenfield workflow generation from natural language input.
- * Supports:
- * - Simple workflows (direct generation)
- * - Complex workflows (returns LLM prompt for agent to complete)
- * - Intent Architect integration for qualification questions
- * - Auto-deploy to new or existing personas
- */
-import { parseInput, intentToSpec, generateWorkflow } from "../../domain/workflow-intent.js";
-import { compileWorkflow } from "../../domain/workflow-generator.js";
-// Detection removed - LLM analyzes with rules from ema://rules/*
-import { runIntentArchitect } from "../../domain/intent-architect.js";
-import { ensureActionRegistry } from "../../../sdk/action-registry.js";
-import { ensureSchemaRegistry, validateWorkflowSpec, generateActionCatalogForLLM } from "../../domain/workflow-validator.js";
-import { getTemplates, normalizeTriggerType } from "../../handlers/index.js";
-import { validateSearchDataSourceConsistency, validationToHandlerResult } from "./validation.js";
-/**
- * Get persona widget context for workflow bindings
- */
-async function getPersonaWidgets(personaId, client) {
-    if (!personaId)
-        return [];
-    try {
-        const persona = await client.getPersonaById(personaId);
-        const protoConfig = persona?.proto_config;
-        if (protoConfig?.widgets) {
-            return protoConfig.widgets
-                .filter(w => typeof w.name === "string" && w.name.trim().length > 0)
-                .map(w => ({
-                name: w.name,
-                type: String(w.type ?? "unknown"),
-                title: w.title,
-            }));
-        }
-    }
-    catch {
-        // Persona not found or no widgets - continue without context
-    }
-    return [];
-}
-/**
- * Enhance an LLM prompt with action catalog and widget context
- */
-function enhancePromptWithContext(prompt, schemaRegistry, personaWidgets) {
-    let enhancedPrompt = prompt;
-    let availableActions = [];
-    let availableTemplates = [];
-    if (!prompt) {
-        return { prompt: enhancedPrompt, availableActions, availableTemplates };
-    }
-    let systemAdditions = "";
-    // Add action catalog if available
-    if (schemaRegistry) {
-        const actionCatalog = generateActionCatalogForLLM(schemaRegistry);
-        systemAdditions += "\n\n## Available Actions\n" + actionCatalog;
-        availableActions = schemaRegistry.getAllActions().map((a) => a.name);
-        availableTemplates = schemaRegistry.getAllTemplates().map((t) => ({ id: t.id, name: t.name, type: t.type }));
-    }
-    // Add persona widget context if available
-    if (personaWidgets.length > 0) {
-        systemAdditions += "\n\n## Available Persona Widgets\n";
-        systemAdditions += "Use these exact widget names in workflow bindings (widgetName field):\n";
-        for (const w of personaWidgets) {
-            systemAdditions += `- \`${w.name}\` (${w.type})${w.title ? ` - "${w.title}"` : ""}\n`;
-        }
-    }
-    if (systemAdditions) {
-        enhancedPrompt = {
-            system: prompt.system + systemAdditions,
-            user: prompt.user,
-        };
-    }
-    return { prompt: enhancedPrompt, availableActions, availableTemplates };
-}
-/**
- * Deploy workflow to a new persona (greenfield creation)
- */
-async function deployToNewPersona(args, client, compiled, actionRegistry, getTemplateId) {
-    const personaName = args.name;
-    if (!personaName) {
-        return { success: false, hint: "Provide name to create new persona, or persona_id to deploy to existing persona" };
-    }
-    const personaType = args.type || "chat";
-    // Dynamic template lookup
-    const templates = await getTemplates(client);
-    const matchingTemplate = templates.find(t => normalizeTriggerType(t.trigger_type) === personaType.toLowerCase());
-    const templateFromRegistry = actionRegistry.getTemplateForType(personaType);
-    const templateId = getTemplateId?.(personaType) || templateFromRegistry?.id || matchingTemplate?.id;
-    if (!templateId) {
-        const availableTypes = [...new Set(templates.map(t => normalizeTriggerType(t.trigger_type)).filter(Boolean))];
-        return {
-            success: false,
-            error: `No template found for type "${personaType}".`,
-            hint: `Available types: ${availableTypes.join(", ")}. Provide template_id directly or use one of the available types.`,
-        };
-    }
-    // Step 1: Create the persona from template
-    const createResult = await client.createAiEmployee({
-        name: personaName,
-        description: args.description,
-        template_id: templateId,
-    });
-    const newPersonaId = createResult.persona_id ?? createResult.id;
-    if (!newPersonaId) {
-        return { success: false, error: "Failed to create persona: no ID returned" };
-    }
-    // Step 2: Fetch the newly created persona
-    const newPersona = await client.getPersonaById(newPersonaId);
-    if (!newPersona) {
-        return { success: false, error: `Failed to fetch newly created persona: ${newPersonaId}` };
-    }
-    // Step 3: Merge proto_config
-    const existingProtoConfig = (newPersona.proto_config ?? {});
-    const generatedProtoConfig = args.proto_config || compiled.proto_config || {};
-    const existingWidgets = (existingProtoConfig.widgets ?? []);
-    const generatedWidgets = (generatedProtoConfig.widgets ?? []);
-    const widgetMap = new Map();
-    for (const w of existingWidgets) {
-        if (typeof w.name === "string" && w.name.trim().length > 0) {
-            widgetMap.set(w.name, w);
-        }
-    }
-    for (const genWidget of generatedWidgets) {
-        const widgetName = genWidget.name;
-        if (typeof widgetName === "string" && widgetName.trim().length > 0) {
-            const existing = widgetMap.get(widgetName);
-            if (existing) {
-                const merged = { ...existing };
-                if (genWidget[widgetName]) {
-                    merged[widgetName] = { ...(existing[widgetName] || {}), ...genWidget[widgetName] };
-                }
-                widgetMap.set(widgetName, merged);
-            }
-            else {
-                widgetMap.set(widgetName, genWidget);
-            }
-        }
-    }
-    const mergedProtoConfig = {
-        ...existingProtoConfig,
-        widgets: Array.from(widgetMap.values()),
-    };
-    // Step 4: Validate and Deploy workflow
-    // Validate search/data source consistency before deployment
-    const validation = await validateSearchDataSourceConsistency(compiled.workflow_def, newPersonaId, client);
-    if (!validation.valid) {
-        // Return validation error but keep persona (user can fix and retry)
-        return {
-            success: false,
-            personaId: newPersonaId,
-            personaName,
-            validationError: validation.error,
-            _fix: validation._fix,
-            workflowAttempted: compiled.workflow_def,
-        };
-    }
-    // NOTE: The SDK's updateAiEmployee() handles workflowName namespace automatically.
-    // It will copy from existing workflow if present, or generate a valid namespace if not.
-    // It also fixes the results format. No need to manually manipulate these here.
-    try {
-        await client.updateAiEmployee({
-            persona_id: newPersonaId,
-            workflow: compiled.workflow_def,
-            proto_config: mergedProtoConfig,
-        }, { verbose: true });
-        return { success: true, personaId: newPersonaId, personaName };
-    }
-    catch (deployError) {
-        const errMsg = deployError instanceof Error ? deployError.message : String(deployError);
-        // Still set proto_config
-        await client.updateAiEmployee({
-            persona_id: newPersonaId,
-            proto_config: mergedProtoConfig,
-        });
-        return {
-            success: false,
-            personaId: newPersonaId,
-            personaName,
-            workflowDeployError: errMsg,
-            workflowAttempted: compiled.workflow_def,
-        };
-    }
-}
-/**
- * Handle workflow generate mode
- */
-export async function handleWorkflowGenerate(args, client, getTemplateId) {
-    const personaId = args.persona_id;
-    const input = args.input;
-    const preview = args.preview !== false;
-    if (!input) {
-        return { error: "input required for generate mode" };
-    }
-    // Load action registry
-    const actionRegistry = await ensureActionRegistry(client);
-    // Parse input
-    const parseResult = parseInput(input);
-    if (!parseResult.validation.complete) {
-        return {
-            status: "incomplete",
-            input_type: parseResult.input_type,
-            missing: parseResult.validation.missing,
-            questions: parseResult.validation.questions,
-        };
-    }
-    // Override persona_type from args.type if provided
-    if (args.type) {
-        parseResult.intent.persona_type = args.type;
-    }
-    // Load schema registry
-    let schemaRegistry = null;
-    try {
-        schemaRegistry = await ensureSchemaRegistry(client);
-    }
-    catch {
-        // Schema registry unavailable - skip API validation
-    }
-    // Get persona widgets for context
-    const personaWidgets = await getPersonaWidgets(personaId, client);
-    // Run Intent Architect for complexity assessment
-    const maxComplexity = args.max_complexity || undefined;
-    const architectResult = runIntentArchitect(input, {
-        persona_type: parseResult.intent.persona_type,
-        available_integrations: schemaRegistry?.getAllActions().slice(0, 20).map((a) => a.displayName || a.name),
-    }, { max_complexity: maxComplexity });
-    // For moderate/complex: return Intent Architect result
-    if (!architectResult.strategy.can_proceed) {
-        const enhanced = enhancePromptWithContext(architectResult.prompt_package, schemaRegistry, personaWidgets);
-        return {
-            status: "needs_intent_architect",
-            available_widgets: personaWidgets.length > 0 ? personaWidgets : undefined,
-            assessment: architectResult.assessment,
-            strategy: architectResult.strategy,
-            questions: architectResult.questions,
-            llm_prompt: enhanced.prompt,
-            hint: architectResult.strategy.next_step,
-            reason: architectResult.legacy?.signals.reason,
-            complexity: architectResult.legacy?.complexity,
-            approach: architectResult.strategy.approach,
-            gates_to_ask: architectResult.strategy.gates_to_ask,
-            fallback_spec: intentToSpec(parseResult.intent),
-            available_actions: enhanced.availableActions,
-            available_templates: enhanced.availableTemplates,
-        };
-    }
-    // SIMPLE complexity: generate directly
-    const genResult = generateWorkflow(parseResult.intent);
-    if (genResult.needs_llm) {
-        const enhanced = enhancePromptWithContext(genResult.llm_prompt, schemaRegistry, personaWidgets);
-        return {
-            status: "needs_llm_generation",
-            reason: genResult.reason,
-            complexity: genResult.complexity,
-            llm_prompt: enhanced.prompt,
-            hint: "Send llm_prompt to an LLM, then call persona(workflow_def=<parsed_response>) to deploy.",
-            fallback_spec: intentToSpec(parseResult.intent),
-            available_actions: enhanced.availableActions,
-            available_templates: enhanced.availableTemplates,
-            available_widgets: personaWidgets.length > 0 ? personaWidgets : undefined,
-        };
-    }
-    // Simple workflow - compile
-    const spec = genResult.spec;
-    if (args.name) {
-        spec.name = args.name;
-    }
-    if (args.description) {
-        spec.description = args.description;
-    }
-    // Validate spec before compiling
-    let specValidation = null;
-    if (schemaRegistry) {
-        specValidation = validateWorkflowSpec(spec, schemaRegistry);
-        if (!specValidation.valid) {
-            return {
-                status: "validation_failed",
-                errors: specValidation.errors,
-                warnings: specValidation.warnings,
-                action_coverage: specValidation.action_coverage,
-                hint: "Fix the validation errors and try again. Unknown actions may need to be checked against ListActions.",
-                spec_attempted: spec,
-            };
-        }
-    }
-    const compiled = compileWorkflow(spec, { registry: actionRegistry });
-    const result = {
-        mode: "generate",
-        status: preview ? "preview" : "deployed",
-        workflow_def: compiled.workflow_def,
-        proto_config: compiled.proto_config,
-        validation: parseResult.validation,
-        // LLM should analyze with ema://rules/anti-patterns
-        _analysis_hint: "Use ema://rules/anti-patterns to check for issues",
-    };
-    if (specValidation) {
-        result.api_validation = {
-            valid: specValidation.valid,
-            warnings: specValidation.warnings,
-            action_coverage: specValidation.action_coverage,
-        };
-    }
-    // Deploy if not preview
-    if (!preview && personaId) {
-        const persona = await client.getPersonaById(personaId);
-        if (!persona) {
-            return { error: `Persona not found: ${personaId}` };
-        }
-        // Validate search/data source consistency before deployment
-        const validation = await validateSearchDataSourceConsistency(compiled.workflow_def, personaId, client);
-        if (!validation.valid) {
-            return validationToHandlerResult(validation, {
-                mode: "generate",
-                persona_id: personaId,
-                persona_name: persona.name,
-                workflow_preview: compiled.workflow_def,
-            });
-        }
-        await client.updateAiEmployee({
-            persona_id: personaId,
-            workflow: compiled.workflow_def,
-            proto_config: args.proto_config || compiled.proto_config || persona.proto_config,
-        });
-        result.deployed_to = { persona_id: personaId, persona_name: persona.name };
-    }
-    else if (!preview && !personaId) {
-        // Greenfield: create new persona
-        const deployResult = await deployToNewPersona(args, client, compiled, actionRegistry, getTemplateId);
-        if (deployResult.validationError) {
-            // Validation failed - persona created but workflow not deployed
-            return {
-                error: deployResult.validationError,
-                _fix: deployResult._fix,
-                persona_id: deployResult.personaId,
-                persona_name: deployResult.personaName,
-                persona_created: true,
-                workflow_deployed: false,
-                workflow_attempted: deployResult.workflowAttempted,
-                hint: "Persona created, but workflow validation failed. Fix the issue and retry deployment.",
-            };
-        }
-        else if (deployResult.workflowDeployError) {
-            result.workflow_deploy_error = deployResult.workflowDeployError;
-            result.workflow_attempted = deployResult.workflowAttempted;
-            result.status = "partial";
-            result.hint = "Persona created, config set, but workflow deploy failed. Check workflow_attempted for details.";
-            result.deployed_to = {
-                persona_id: deployResult.personaId,
-                persona_name: deployResult.personaName,
-                created: true,
-                workflow_deployed: false,
-            };
-            return result;
-        }
-        else if (deployResult.success) {
-            result.deployed_to = {
-                persona_id: deployResult.personaId,
-                persona_name: deployResult.personaName,
-                created: true,
-            };
-            result.status = "deployed";
-            result.next_steps = [
-                `Persona "${deployResult.personaName}" created with template workflow.`,
-                `To customize: workflow(mode="get", persona_id="${deployResult.personaId}") → modify workflow_def → workflow(mode="deploy", ...)`,
-            ];
-        }
-        else if (deployResult.error) {
-            return { error: deployResult.error, hint: deployResult.hint };
-        }
-        else {
-            result.hint = deployResult.hint;
-        }
-    }
-    if (preview) {
-        result.next_steps = [
-            "Review the generated workflow_def",
-            personaId
-                ? `Deploy with: workflow(mode="get", persona_id="${personaId}") → workflow(mode="deploy", persona_id="${personaId}", base_fingerprint="<fingerprint>", workflow_def={...}) (or workflow_def_path="/path/to/wf.json")`
-                : "Create persona first: persona(method='create', name='...', type='...')",
-        ];
-    }
-    return result;
-}