@ema.co/mcp-toolkit 0.2.0

package/dist/sdk/validation-rules.js

@@ -0,0 +1,355 @@
+/**
+ * Validation Rules - Single Source of Truth
+ *
+ * This file defines all workflow validation rules in a structured format.
+ * These rules are used by:
+ * 1. knowledge.ts - Runtime validation in detectWorkflowIssues()
+ * 2. MCP tools - analyze_workflow, suggest_workflow_fixes
+ * 3. Documentation generation - Can be exported to update RULE.md
+ *
+ * To avoid duplication, all rule definitions should live HERE and be
+ * imported/referenced elsewhere.
+ */
+// NOTE: More specific patterns MUST come before less specific ones!
+// The matching uses `includes()`, so "conversation_to_search_query" would match "search" if "search" comes first.
+export const INPUT_SOURCE_RULES = [
+    // Most specific patterns first
+    {
+        actionPattern: "conversation_to_search_query",
+        recommended: "chat_conversation",
+        avoid: ["user_query"],
+        reason: "conversation_to_search_query needs CHAT_CONVERSATION to summarize. user_query is already TEXT_WITH_SOURCES.",
+        severity: "critical",
+        fix: "Connect trigger.chat_conversation → conversation_to_search_query.conversation",
+    },
+    {
+        actionPattern: "chat_categorizer",
+        recommended: "chat_conversation",
+        avoid: ["user_query", "summarized_conversation"],
+        reason: "Categorizers need full conversation history for accurate intent classification. Using user_query loses multi-turn context and causes misclassification.",
+        severity: "critical",
+        fix: "Connect trigger.chat_conversation → chat_categorizer.conversation",
+    },
+    {
+        actionPattern: "text_categorizer",
+        recommended: "user_query",
+        avoid: ["chat_conversation"],
+        reason: "text_categorizer expects TEXT_WITH_SOURCES, not CHAT_CONVERSATION. Use chat_categorizer instead for conversations.",
+        severity: "critical",
+        fix: "Use chat_categorizer for conversation routing, or use user_query/summarized_conversation for text_categorizer",
+    },
+    {
+        actionPattern: "respond_with_sources",
+        recommended: "user_query",
+        avoid: ["chat_conversation"],
+        reason: "respond_with_sources.query expects TEXT_WITH_SOURCES. For conversation context, use named_inputs.",
+        severity: "critical",
+        fix: "Use trigger.user_query for query input",
+    },
+    {
+        actionPattern: "live_web_search",
+        recommended: "user_query",
+        avoid: ["chat_conversation"],
+        reason: "Web search expects TEXT_WITH_SOURCES query. Use conversation_to_search_query first if you need conversation context.",
+        severity: "critical",
+        fix: "Use trigger.user_query or summarized_conversation from conversation_to_search_query",
+    },
+    {
+        actionPattern: "call_llm",
+        recommended: "user_query",
+        avoid: [],
+        reason: "call_llm.query expects TEXT_WITH_SOURCES. For conversation context, pass chat_conversation via named_inputs instead.",
+        severity: "warning",
+        fix: "Use user_query for query, pass chat_conversation via named_inputs if needed",
+    },
+    // Email-specific rules
+    {
+        actionPattern: "send_email",
+        recommended: "entity_extraction.email_address",
+        avoid: ["summarized_conversation", "response_with_sources", "search_results", "generated_content"],
+        reason: "email_to field requires an EMAIL ADDRESS, not summarized text or generated content. " +
+            "Using text outputs will cause invalid emails or send to wrong recipients.",
+        severity: "critical",
+        fix: "Use entity_extraction to extract email_address from conversation, then connect to send_email.email_to. " +
+            "Add HITL confirmation before sending to verify recipient.",
+    },
+    // Template and fixed response patterns
+    {
+        actionPattern: "fixed_response",
+        recommended: "named_inputs with {{variable}} syntax",
+        avoid: ["hardcoded long text", "embedded templates without variables"],
+        reason: "fixed_response supports {{variable_name}} syntax for dynamic content. " +
+            "Variables come from named_inputs (preferred) or extracted_variables (JSON). " +
+            "Use for short, structured messages - NOT for long templates.",
+        severity: "info",
+        fix: "For short confirmations: Use fixed_response with {{Customer_Name}}, {{Order_ID}} variables. " +
+            "For email/document templates: Use data source templates with fill_document_template or generate_document.",
+    },
+    {
+        actionPattern: "generate_document",
+        recommended: "LLM templating (call_llm with structured prompt) → generate_document",
+        avoid: ["hardcoded template content", "inline template text", "skipping LLM formatting step"],
+        reason: "For dynamic, context-dependent content: Use LLM templating with structured prompts. " +
+            "Only use data source templates for strict regulatory/pixel-perfect formats.",
+        severity: "info",
+        fix: "RECOMMENDED: call_llm (with structured ## section headers - LLM determines appropriate sections) → generate_document. " +
+            "Pass data via named_inputs. Set temperature 0.3-0.5 for consistent formatting. " +
+            "ONLY use template engine for strict compliance documents.",
+    },
+    {
+        actionPattern: "send_email",
+        recommended: "entity_extraction.email_address for recipients, template from data source for body",
+        avoid: ["hardcoded email text", "inline HTML templates", "text outputs as recipients"],
+        reason: "Email templates should be stored in data sources for maintainability. " +
+            "Recipients must come from entity_extraction, NOT from text generation outputs.",
+        severity: "critical",
+        fix: "For recipient: entity_extraction.email_address. " +
+            "For body: Use fixed_response with {{variables}} for simple emails, " +
+            "or fill_document_template for complex HTML templates from data sources.",
+    },
+    // Generic patterns last (least specific)
+    {
+        actionPattern: "search",
+        recommended: "user_query",
+        avoid: ["chat_conversation"],
+        reason: "Search expects TEXT_WITH_SOURCES query, not CHAT_CONVERSATION. Use conversation_to_search_query first if you need conversation context.",
+        severity: "critical",
+        fix: "Use trigger.user_query for simple searches, or add conversation_to_search_query to convert chat history",
+    },
+];
+export const ANTI_PATTERNS = [
+    {
+        id: "text-to-email-recipient",
+        name: "Text Content as Email Recipient",
+        pattern: "Connecting summarized_conversation, response_with_sources, or other text outputs to send_email.email_to",
+        problem: "email_to expects an EMAIL ADDRESS string. Connecting text outputs (summaries, responses, search results) will cause email failures or send to garbage addresses.",
+        solution: "Use entity_extraction to extract the email address from conversation, then connect entity_extraction.email_address to send_email.email_to. Add HITL confirmation before sending.",
+        detection: {
+            issueType: "wrong_input_source",
+            condition: "send_email_agent.email_to connected to summarized_conversation, response_with_sources, search_results, or any TEXT_WITH_SOURCES output",
+        },
+        severity: "critical",
+    },
+    {
+        id: "email-without-validation",
+        name: "Email Without Input Validation",
+        pattern: "send_email_agent without entity_extraction and HITL confirmation",
+        problem: "Sending emails without extracting and validating recipient data risks sending to wrong people or with wrong content. Emails are high-impact actions with external side effects.",
+        solution: "Always: 1) Extract required fields (email_address, subject) via entity_extraction, 2) Validate completeness via categorizer, 3) Ask user if missing, 4) Confirm via HITL before sending.",
+        detection: {
+            issueType: "incomplete_hitl",
+            condition: "send_email_agent without preceding entity_extraction AND hitl nodes",
+        },
+        severity: "critical",
+    },
+    {
+        id: "redundant-search",
+        name: "Redundant Search Nodes",
+        pattern: "Multiple conditional search nodes with same query source",
+        problem: "Only one branch executes at a time, so multiple searches add complexity without benefit.",
+        solution: "Use a SINGLE search node, pass results to all response branches via named_inputs.",
+        detection: {
+            issueType: "redundant_search",
+            condition: "Multiple search nodes using the same query source (e.g., summarized_conversation)",
+        },
+        severity: "warning",
+    },
+    {
+        id: "sequential-llm",
+        name: "Sequential LLM Calls",
+        pattern: "Multiple sequential LLM calls for simple tasks",
+        problem: "Adds latency and reduces coherence. Each LLM call has overhead.",
+        solution: "Single call_llm with comprehensive instructions and all context via named_inputs.",
+        detection: {
+            issueType: "duplicate_llm_processing",
+            condition: "Multiple LLM nodes processing same search results sequentially",
+        },
+        severity: "info",
+    },
+    {
+        id: "llm-for-static",
+        name: "LLM for Static Content",
+        pattern: "Using call_llm for static responses",
+        problem: "Unnecessary cost and latency for content that never changes.",
+        solution: "Use fixed_response for templates, disclaimers, error messages.",
+        detection: {
+            issueType: "unnecessary_llm",
+            condition: "call_llm with hardcoded instructions and no dynamic inputs",
+        },
+        severity: "info",
+    },
+    {
+        id: "missing-fallback",
+        name: "Missing Fallback Category",
+        pattern: "Categorizer without Fallback category",
+        problem: "Unrecognized intents have nowhere to go, causing undefined behavior.",
+        solution: "ALWAYS include Fallback category with clarifying question and examples.",
+        detection: {
+            issueType: "missing_fallback",
+            condition: "Categorizer enumType.options does not include 'Fallback'",
+        },
+        severity: "critical",
+    },
+    {
+        id: "incomplete-hitl",
+        name: "Incomplete HITL Paths",
+        pattern: "HITL with only success path",
+        problem: "Rejected requests have no handling, leaving users without response.",
+        solution: "ALWAYS implement both success AND failure paths for general_hitl.",
+        detection: {
+            issueType: "incomplete_hitl",
+            condition: "HITL node missing 'hitl_status_HITL Success' or 'hitl_status_HITL Failure' edge (note: space, not underscore)",
+        },
+        severity: "critical",
+    },
+    {
+        id: "orphan-nodes",
+        name: "Orphan Nodes",
+        pattern: "Nodes not connected to workflow (for 'future use')",
+        problem: "Adds confusion, maintenance burden, and can cause validation errors.",
+        solution: "Remove unused nodes. Add them when actually needed.",
+        detection: {
+            issueType: "orphan",
+            condition: "Node not reachable from trigger via edges",
+        },
+        severity: "warning",
+    },
+    {
+        id: "unused-output",
+        name: "Unused Output",
+        pattern: "Node produces output that is not consumed by any downstream node",
+        problem: "Node is doing work that goes nowhere. Common with combine_search_results where combined_results isn't wired. Wastes compute and indicates incomplete wiring.",
+        solution: "Connect the output to a downstream node that needs it, or remove the node if not needed.",
+        detection: {
+            issueType: "unused_output",
+            condition: "Node output not consumed by any other node's inputs or WORKFLOW_OUTPUT",
+        },
+        severity: "warning",
+    },
+    {
+        id: "web-search-primary",
+        name: "Web Search as Primary",
+        pattern: "Using web search as primary/only data source",
+        problem: "Web search is slower, less reliable, and content is uncontrolled.",
+        solution: "Internal KB should be primary, web search should supplement.",
+        detection: {
+            issueType: "web_search_only",
+            condition: "live_web_search without accompanying search (KB) node",
+        },
+        severity: "warning",
+    },
+    {
+        id: "missing-category-edge",
+        name: "Missing Category Edges",
+        pattern: "Categorizer with categories but no outgoing edges",
+        problem: "Categories have nowhere to route to, causing dead workflow.",
+        solution: "Add edge for EACH category: category_<Name> → handler.trigger_when",
+        detection: {
+            issueType: "missing_category_edge",
+            condition: "Categorizer has enumType.options but no outgoing edges matching category_*",
+        },
+        severity: "critical",
+    },
+    {
+        id: "missing-workflow-output",
+        name: "Missing WORKFLOW_OUTPUT",
+        pattern: "Response nodes not connected to WORKFLOW_OUTPUT",
+        problem: "Responses never reach the user.",
+        solution: "Connect all terminal response nodes to WORKFLOW_OUTPUT.",
+        detection: {
+            issueType: "missing_workflow_output",
+            condition: "No WORKFLOW_OUTPUT node, or response nodes not connected to it",
+        },
+        severity: "critical",
+    },
+];
+export const OPTIMIZATION_RULES = [
+    {
+        id: "consolidate-searches",
+        name: "Consolidate Redundant Searches",
+        currentState: "Multiple search nodes using same query source with different file filters",
+        recommendation: "Replace with single search node, remove file filters, let LLM filter results",
+        benefit: "Simpler workflow, consistent results, easier maintenance",
+        priority: "high",
+    },
+    {
+        id: "parallelize-independent",
+        name: "Parallelize Independent Operations",
+        currentState: "Sequential nodes that don't depend on each other's output",
+        recommendation: "Restructure to branch from same source so they run in parallel",
+        benefit: "Reduced latency, faster response times",
+        priority: "medium",
+    },
+    {
+        id: "use-purpose-built",
+        name: "Use Purpose-Built Response Nodes",
+        currentState: "Using call_llm for search-based responses",
+        recommendation: "Use respond_with_sources instead - it has built-in citation handling",
+        benefit: "Better citations, grounded responses, less configuration",
+        priority: "medium",
+    },
+    {
+        id: "reduce-context-window",
+        name: "Optimize Context Window",
+        currentState: "Default or excessive context_window settings",
+        recommendation: "Set context_window based on actual needs (typically 5-10 turns)",
+        benefit: "Reduced token usage, faster processing",
+        priority: "low",
+    },
+];
+// ─────────────────────────────────────────────────────────────────────────────
+// Helper Functions
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Find input source rule for a given action
+ */
+export function findInputSourceRule(actionName) {
+    return INPUT_SOURCE_RULES.find(rule => actionName.toLowerCase().includes(rule.actionPattern.toLowerCase()));
+}
+/**
+ * Find anti-pattern by issue type
+ */
+export function findAntiPatternByIssueType(issueType) {
+    return ANTI_PATTERNS.find(ap => ap.detection.issueType === issueType);
+}
+/**
+ * Get all rules as formatted markdown (for documentation generation)
+ */
+export function generateMarkdownDocumentation() {
+    let md = "## Auto-Generated Validation Rules\n\n";
+    md += "> This section is generated from `src/sdk/validation-rules.ts`\n\n";
+    md += "### Input Source Rules\n\n";
+    md += "| Action | Recommended | Avoid | Severity |\n";
+    md += "|--------|-------------|-------|----------|\n";
+    for (const rule of INPUT_SOURCE_RULES) {
+        md += `| \`${rule.actionPattern}\` | \`${rule.recommended}\` | ${rule.avoid.map(a => `\`${a}\``).join(", ") || "-"} | ${rule.severity} |\n`;
+    }
+    md += "\n### Anti-Patterns\n\n";
+    for (const ap of ANTI_PATTERNS) {
+        md += `#### ❌ ${ap.name}\n\n`;
+        md += `**Pattern**: ${ap.pattern}\n\n`;
+        md += `**Problem**: ${ap.problem}\n\n`;
+        md += `**Solution**: ${ap.solution}\n\n`;
+        md += `**Severity**: ${ap.severity}\n\n`;
+    }
+    md += "### Optimization Opportunities\n\n";
+    for (const opt of OPTIMIZATION_RULES) {
+        md += `#### ${opt.name} (${opt.priority})\n\n`;
+        md += `- **Current**: ${opt.currentState}\n`;
+        md += `- **Recommendation**: ${opt.recommendation}\n`;
+        md += `- **Benefit**: ${opt.benefit}\n\n`;
+    }
+    return md;
+}
+/**
+ * Export rules in JSON format (for external tools or caching)
+ */
+export function exportRulesAsJSON() {
+    return {
+        version: "1.0.0",
+        generatedAt: new Date().toISOString(),
+        inputSourceRules: INPUT_SOURCE_RULES,
+        antiPatterns: ANTI_PATTERNS,
+        optimizationRules: OPTIMIZATION_RULES,
+    };
+}

package/dist/sdk/workflow-generator.js

@@ -0,0 +1,291 @@
+/**
+ * Workflow Compiler
+ *
+ * Compiles workflow specifications into Ema workflow_def and proto_config.
+ * This is a pure compiler - no hardcoded patterns or biased generators.
+ *
+ * The AI assistant should:
+ * 1. Read patterns from ema://catalog/patterns for reference
+ * 2. Construct nodes based on user requirements
+ * 3. Pass to compileWorkflow() to generate deployment-ready JSON
+ */
+// ─────────────────────────────────────────────────────────────────────────────
+// Namespace mappings
+// ─────────────────────────────────────────────────────────────────────────────
+const ACTION_NAMESPACES = {
+    chat_trigger: ["triggers", "emainternal"],
+    document_trigger: ["triggers", "emainternal"],
+    chat_categorizer: ["routing", "emainternal"],
+    text_categorizer: ["routing", "emainternal"],
+    search: ["search", "emainternal"],
+    live_web_search: ["search", "emainternal"],
+    respond_with_sources: ["generation", "emainternal"],
+    call_llm: ["generation", "emainternal"],
+    fixed_response: ["generation", "emainternal"],
+    external_action_caller: ["external", "emainternal"],
+    general_hitl: ["collaboration", "emainternal"],
+    send_email_agent: ["external", "emainternal"],
+    conversation_to_search_query: ["search", "emainternal"],
+    entity_extraction: ["entity", "emainternal"],
+    combine_search_results: ["search", "emainternal"],
+    response_validator: ["validation", "emainternal"],
+};
+const OPERATOR_MAP = {
+    eq: 1,
+    neq: 2,
+    gt: 3,
+    lt: 4,
+    gte: 5,
+    lte: 6,
+};
+// ─────────────────────────────────────────────────────────────────────────────
+// Compiler
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Compile a workflow specification into deployment-ready JSON.
+ *
+ * @param spec - The workflow specification with nodes and result mappings
+ * @returns Compiled workflow_def and proto_config
+ */
+export function compileWorkflow(spec) {
+    const actions = [];
+    const enumTypes = [];
+    const enumTypeName = spec.nodes.some((n) => n.actionType.includes("categorizer"))
+        ? `${spec.name.replace(/\s+/g, "_")}_Categories`
+        : undefined;
+    // Build actions from nodes
+    for (const node of spec.nodes) {
+        const action = buildAction(node, enumTypeName);
+        actions.push(action);
+        // Build enum type for categorizer
+        if (node.categories && enumTypeName) {
+            const values = node.categories.map((cat, idx) => ({
+                name: cat.name,
+                number: idx + 1,
+                options: {},
+            }));
+            // Always include Fallback
+            if (!node.categories.some((c) => c.name === "Fallback")) {
+                values.push({ name: "Fallback", number: values.length + 1, options: {} });
+            }
+            enumTypes.push({
+                name: enumTypeName,
+                values,
+                options: { allowAlias: true },
+            });
+        }
+    }
+    // Build results mapping
+    const results = {};
+    for (const mapping of spec.resultMappings) {
+        const key = `WORKFLOW_OUTPUT_${Object.keys(results).length}`;
+        results[key] = {
+            actionName: mapping.nodeId,
+            outputName: mapping.output,
+        };
+    }
+    // Build workflow_def
+    // CRITICAL: Only include enumTypes if there are valid entries with proper names
+    // Empty or malformed enumTypes causes workflow engine to crash
+    const validEnumTypes = enumTypes.filter((e) => typeof e.name === "string" && e.name.length > 0);
+    const workflowDef = {
+        workflowName: {
+            name: {
+                namespaces: ["ema", "workflows"],
+                name: spec.name.toLowerCase().replace(/\s+/g, "_"),
+            },
+        },
+        actions,
+        results,
+    };
+    // Only add enumTypes if there are valid ones
+    if (validEnumTypes.length > 0) {
+        workflowDef.enumTypes = validEnumTypes;
+    }
+    // Build proto_config
+    const protoConfig = buildProtoConfig(spec);
+    return { workflow_def: workflowDef, proto_config: protoConfig };
+}
+function buildAction(node, enumTypeName) {
+    const namespaces = ACTION_NAMESPACES[node.actionType] ?? ["custom", "emainternal"];
+    const action = {
+        // CRITICAL: Use "name" not "actionName" - this is the node identifier in the workflow
+        name: node.id,
+        actionDisplayName: node.displayName,
+        actionDescription: node.description ?? "",
+        action: {
+            name: { namespaces, name: node.actionType },
+        },
+        inputs: {},
+        disableHumanInteraction: node.disableHitl ?? false,
+    };
+    // Build inputs
+    if (node.inputs) {
+        const inputs = {};
+        for (const [inputName, binding] of Object.entries(node.inputs)) {
+            inputs[inputName] = buildInputBinding(binding);
+        }
+        action.inputs = inputs;
+    }
+    // Build runIf condition
+    if (node.runIf) {
+        action.runIf = {
+            lhs: {
+                actionOutput: {
+                    actionName: node.runIf.sourceAction,
+                    output: node.runIf.sourceOutput,
+                },
+                autoDetectedBinding: false,
+            },
+            operator: OPERATOR_MAP[node.runIf.operator] ?? 1,
+            rhs: {
+                inline: { enumValue: node.runIf.value },
+                autoDetectedBinding: false,
+            },
+        };
+    }
+    // Build categories for categorizer
+    if (node.categories && enumTypeName) {
+        const categories = node.categories.map((cat) => ({
+            category: cat.name,
+            conditionDescription: cat.description,
+            examplePhrases: cat.examples ?? [],
+        }));
+        // Always add Fallback
+        if (!node.categories.some((c) => c.name === "Fallback")) {
+            categories.push({
+                category: "Fallback",
+                conditionDescription: "User request doesn't match other categories",
+                examplePhrases: [],
+            });
+        }
+        action.inputs = {
+            ...action.inputs,
+            categories: { inline: { array: { value: categories.map((c) => ({ message: c })) } } },
+        };
+        action.outputType = enumTypeName;
+    }
+    // Build tools for external_action_caller
+    if (node.tools) {
+        const toolInputs = {};
+        for (const tool of node.tools) {
+            const toolKey = `${tool.namespace}/${tool.name}`;
+            if (tool.inputs) {
+                const toolBindings = {};
+                for (const [k, v] of Object.entries(tool.inputs)) {
+                    toolBindings[k] = buildInputBinding(v);
+                }
+                toolInputs[toolKey] = { multiBinding: { bindings: toolBindings } };
+            }
+            else {
+                toolInputs[toolKey] = { llmInferred: {} };
+            }
+        }
+        action.inputs = {
+            ...action.inputs,
+            tools: {
+                multiBinding: {
+                    bindings: toolInputs,
+                },
+            },
+        };
+    }
+    return action;
+}
+function buildInputBinding(binding) {
+    switch (binding.type) {
+        case "action_output":
+            return {
+                actionOutput: {
+                    actionName: binding.actionName,
+                    output: binding.output,
+                },
+                autoDetectedBinding: false,
+            };
+        case "inline_string":
+            return { inline: { string: binding.value }, autoDetectedBinding: false };
+        case "inline_number":
+            return { inline: { number: binding.value }, autoDetectedBinding: false };
+        case "inline_bool":
+            return { inline: { bool: binding.value }, autoDetectedBinding: false };
+        case "widget_config":
+            return { widgetConfig: { widgetName: binding.widgetName }, autoDetectedBinding: false };
+        case "llm_inferred":
+            return { llmInferred: {} };
+        default:
+            return { llmInferred: {} };
+    }
+}
+function buildProtoConfig(spec) {
+    const projectType = spec.personaType === "voice" ? 5 : spec.personaType === "chat" ? 4 : 2;
+    const widgets = [
+        { widget_type_id: 6, widget_name: "fusionModel", widget_config: { selectedModels: ["gpt-4.1"] } },
+        { widget_type_id: 8, widget_name: "dataProtection", widget_config: { enabled: true } },
+    ];
+    if (spec.personaType === "voice") {
+        widgets.push({ widget_type_id: 38, widget_name: "voiceSettings", widget_config: { languageHints: ["en-US"], voiceModel: "default" } }, { widget_type_id: 39, widget_name: "conversationSettings", widget_config: {} }, { widget_type_id: 43, widget_name: "vadSettings", widget_config: { turnTimeout: 5, silenceEndCallTimeout: 30, maxConversationDuration: 300 } });
+    }
+    if (spec.personaType === "chat") {
+        widgets.push({ widget_type_id: 28, widget_name: "chatbotSdkConfig", widget_config: { name: spec.name, theme: { primaryColor: "#0066cc" }, allowedDomains: ["*"] } }, { widget_type_id: 33, widget_name: "feedbackMessage", widget_config: { message: { question: "Was this response helpful?" }, feedbackFrequency: "always" } });
+    }
+    widgets.push({ widget_type_id: 3, widget_name: "fileUpload", widget_config: { useChunking: true } });
+    return {
+        project_type: projectType,
+        name: spec.name,
+        description: spec.description,
+        widgets,
+    };
+}
+/**
+ * Generate voice-specific proto_config widgets
+ */
+export function buildVoiceConfig(settings) {
+    return [
+        {
+            widget_type_id: 39,
+            widget_name: "conversationSettings",
+            widget_config: {
+                welcomeMessage: settings.welcomeMessage,
+                identityAndPurpose: settings.identityAndPurpose,
+                takeActionInstructions: settings.takeActionInstructions,
+                hangupInstructions: settings.hangupInstructions,
+                transferCallInstructions: settings.transferInstructions ?? "",
+                speechCharacteristics: settings.speechCharacteristics ?? "",
+                systemPrompt: settings.systemPrompt ?? "",
+                waitMessage: settings.waitMessage ?? "One moment please...",
+            },
+        },
+        {
+            widget_type_id: 38,
+            widget_name: "voiceSettings",
+            widget_config: {
+                languageHints: settings.languageHints ?? ["en-US"],
+                voiceModel: "default",
+            },
+        },
+    ];
+}
+/**
+ * Generate chat-specific proto_config widgets
+ */
+export function buildChatConfig(settings) {
+    return [
+        {
+            widget_type_id: 28,
+            widget_name: "chatbotSdkConfig",
+            widget_config: {
+                name: settings.name,
+                theme: { primaryColor: settings.primaryColor ?? "#0066cc" },
+                allowedDomains: settings.allowedDomains ?? ["*"],
+            },
+        },
+        {
+            widget_type_id: 33,
+            widget_name: "feedbackMessage",
+            widget_config: {
+                message: { question: settings.feedbackQuestion ?? "Was this response helpful?" },
+                feedbackFrequency: "always",
+            },
+        },
+    ];
+}