@ema.co/mcp-toolkit 1.5.1 → 1.6.0

package/dist/sdk/structural-rules.js

@@ -0,0 +1,290 @@
+/**
+ * Structural Rules for LLM Context
+ *
+ * These rules encode the validation logic from:
+ * - workflow-fixer.ts
+ * - workflow-execution-analyzer.ts
+ * - knowledge.ts (detectWorkflowIssues)
+ *
+ * PURPOSE: Feed these to the LLM so it can self-validate during generation/transformation.
+ * This is the "teach the LLM the rules" approach vs "fix after the fact".
+ */
+export const STRUCTURAL_INVARIANTS = [
+    // ═══════════════════════════════════════════════════════════════════════════
+    // GRAPH INVARIANTS (Cycles, Connectivity)
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        id: "no_cycles",
+        name: "No Circular Dependencies",
+        rule: "A workflow graph must be a DAG (Directed Acyclic Graph). No node can depend on its own output through any chain of connections.",
+        violation: "Node A → Node B → Node C → Node A creates infinite loop",
+        fix: "Break the cycle by removing one edge or restructuring the workflow",
+        severity: "critical",
+    },
+    {
+        id: "all_nodes_reachable",
+        name: "All Nodes Reachable from Trigger",
+        rule: "Every node must be reachable from the trigger node. Orphan nodes waste resources and indicate incomplete wiring.",
+        violation: "Node 'search_old' exists but has no path from trigger",
+        fix: "Either connect the node to the workflow or remove it",
+        severity: "warning",
+    },
+    {
+        id: "all_paths_reach_output",
+        name: "All Paths Must Reach WORKFLOW_OUTPUT",
+        rule: "Every execution path from trigger must eventually reach a node that's connected to WORKFLOW_OUTPUT.",
+        violation: "Branch 'billing' ends at 'search_billing' with no response node",
+        fix: "Add a response node (respond_with_sources, call_llm, fixed_response) and connect to WORKFLOW_OUTPUT",
+        severity: "critical",
+    },
+    {
+        id: "has_trigger",
+        name: "Must Have Entry Point",
+        rule: "Every workflow must have exactly one trigger node (chat_trigger, voice_trigger, etc.)",
+        violation: "Workflow has no trigger - no entry point for execution",
+        fix: "Add a trigger node at the start of the workflow",
+        severity: "critical",
+    },
+    {
+        id: "has_output",
+        name: "Must Have WORKFLOW_OUTPUT",
+        rule: "Every workflow must have at least one resultMapping to WORKFLOW_OUTPUT. This is how responses reach users.",
+        violation: "No resultMappings defined - responses go nowhere",
+        fix: "Add resultMappings: [{ nodeId: 'response_node', output: 'response_with_sources' }]",
+        severity: "critical",
+    },
+    // ═══════════════════════════════════════════════════════════════════════════
+    // BRANCHING INVARIANTS (Categorizers, Conditions)
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        id: "categorizer_has_fallback",
+        name: "Categorizers Must Have Fallback",
+        rule: "Every categorizer must have a 'Fallback' (or 'Other') category. Otherwise, unrecognized intents cause undefined behavior.",
+        violation: "Categorizer has categories [billing, technical] but no fallback",
+        fix: "Add category: { name: 'Fallback', description: 'For unclear or other requests' }",
+        severity: "critical",
+    },
+    {
+        id: "all_categories_have_handlers",
+        name: "Every Category Needs a Handler",
+        rule: "Each category in a categorizer must have at least one node with runIf condition for that category.",
+        violation: "Category 'technical' exists but no node has runIf checking for it",
+        fix: "Add a node with runIf: { sourceAction: 'categorizer', value: 'technical' }",
+        severity: "critical",
+    },
+    {
+        id: "runif_category_exists",
+        name: "RunIf Must Reference Valid Category",
+        rule: "When a runIf condition checks a category, that category must exist in the categorizer's categories array.",
+        violation: "runIf checks for 'support' but categorizer only has ['billing', 'technical']",
+        fix: "Either add 'support' to categories or update runIf to use existing category",
+        severity: "critical",
+    },
+    // ═══════════════════════════════════════════════════════════════════════════
+    // RESPONSE INVARIANTS (No duplicate responses)
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        id: "no_parallel_responders",
+        name: "No Ungated Parallel Responders",
+        rule: "If multiple response nodes can execute in the same branch (no mutually-exclusive runIf), they will ALL execute, causing duplicate responses.",
+        violation: "Both 'respond_billing' and 'respond_general' can execute when category='billing'",
+        fix: "Add runIf conditions so only ONE response node executes per path. Use catch-all for fallback.",
+        severity: "critical",
+    },
+    {
+        id: "response_after_search",
+        name: "Response Nodes Need Data",
+        rule: "Response nodes (respond_with_sources, call_llm) should receive search_results or context. Don't generate responses without data.",
+        violation: "respond_with_sources has no search_results input",
+        fix: "Connect a search node's output to the response node's search_results input",
+        severity: "warning",
+    },
+    // ═══════════════════════════════════════════════════════════════════════════
+    // HITL INVARIANTS (Human-in-the-loop)
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        id: "hitl_has_both_paths",
+        name: "HITL Must Have Success AND Failure Paths",
+        rule: "A general_hitl node has two outcomes: approval and rejection. Both MUST have downstream handlers.",
+        violation: "HITL 'approval' only has success path - rejections hang",
+        fix: "Add handler for hitl.approval_decision = 'reject' (typically fixed_response with apology)",
+        severity: "critical",
+    },
+    // ═══════════════════════════════════════════════════════════════════════════
+    // TYPE INVARIANTS (Data types must match)
+    // ═══════════════════════════════════════════════════════════════════════════
+    {
+        id: "type_compatibility",
+        name: "Input/Output Types Must Match",
+        rule: "When connecting nodes, the output type must be compatible with the input type. TEXT_WITH_SOURCES ≠ CHAT_CONVERSATION.",
+        violation: "search.query expects TEXT_WITH_SOURCES but receives trigger.chat_conversation (CHAT_CONVERSATION)",
+        fix: "Use trigger.user_query instead, or add conversation_to_search_query to convert",
+        severity: "critical",
+    },
+    {
+        id: "email_recipient_type",
+        name: "Email Recipients Must Be Email Addresses",
+        rule: "send_email.to_email must receive an actual email address, not text content (summaries, responses, etc.)",
+        violation: "to_email receives respond_with_sources.response (text, not email)",
+        fix: "Use entity_extraction to extract email_address, then connect to to_email",
+        severity: "critical",
+    },
+];
+export const EXECUTION_RULES = [
+    {
+        id: "runif_gates_execution",
+        name: "RunIf Conditions Gate Execution",
+        description: "A node with runIf only executes when the condition is true. It's like an 'if' statement.",
+        implication: "Nodes without runIf ALWAYS execute if their inputs are available",
+    },
+    {
+        id: "parallel_execution",
+        name: "Independent Nodes Execute in Parallel",
+        description: "Nodes that don't depend on each other's output can execute simultaneously.",
+        implication: "If two response nodes both get triggered, BOTH will respond (causing duplicate messages)",
+    },
+    {
+        id: "categorizer_single_output",
+        name: "Categorizers Produce Single Category",
+        description: "A categorizer evaluates input and produces ONE category value (or Fallback).",
+        implication: "Use runIf: { value: 'category_name' } to gate nodes to specific categories",
+    },
+    {
+        id: "workflow_output_aggregates",
+        name: "WORKFLOW_OUTPUT Collects All Responses",
+        description: "Multiple nodes can map to WORKFLOW_OUTPUT. ALL mapped outputs are returned.",
+        implication: "If 3 response nodes map to output and all execute, user gets 3 responses",
+    },
+    {
+        id: "dead_end_no_output",
+        name: "Dead-End Nodes Produce No User Response",
+        description: "If a node's output isn't connected to another node or WORKFLOW_OUTPUT, its result is lost.",
+        implication: "Always trace from response nodes to WORKFLOW_OUTPUT",
+    },
+];
+export const COMMON_STRUCTURAL_MISTAKES = [
+    {
+        id: "triple_response",
+        symptom: "User receives 3 identical (or similar) responses",
+        cause: "Multiple response nodes without mutually-exclusive runIf conditions all executed",
+        fix: "Add runIf conditions so only one response node fires per category. Check that response nodes are gated by the categorizer output.",
+    },
+    {
+        id: "no_response",
+        symptom: "User sends message but gets no response",
+        cause: "Response node not connected to WORKFLOW_OUTPUT, or all runIf conditions false",
+        fix: "Verify resultMappings include the response node. Add Fallback category that always responds.",
+    },
+    {
+        id: "wrong_response_branch",
+        symptom: "User asks about billing but gets technical response",
+        cause: "runIf condition checking wrong category, or categorizer misconfigured",
+        fix: "Verify runIf.value matches the exact category name (case-sensitive). Check categorizer categories.",
+    },
+    {
+        id: "email_to_garbage",
+        symptom: "Emails sent to invalid addresses or contain 'undefined'",
+        cause: "to_email connected to text output instead of entity_extraction.email_address",
+        fix: "Add entity_extraction node, extract email_address, connect to send_email.to_email",
+    },
+    {
+        id: "infinite_loop",
+        symptom: "Workflow times out or causes server error",
+        cause: "Circular dependency: Node A → B → C → A",
+        fix: "Review node connections. Use workflow tracer to visualize. Break the cycle.",
+    },
+    {
+        id: "orphan_leftover",
+        symptom: "Workflow has nodes that seem unused",
+        cause: "Nodes created but never connected, or connections removed without removing node",
+        fix: "Either connect the node or remove it. Use analyzeWorkflow to detect orphans.",
+    },
+    {
+        id: "search_no_results",
+        symptom: "Response says 'I don't have information' even when KB has data",
+        cause: "search.query receives wrong input type (CHAT_CONVERSATION instead of TEXT_WITH_SOURCES)",
+        fix: "Connect trigger.user_query (not chat_conversation) to search.query",
+    },
+];
+// ─────────────────────────────────────────────────────────────────────────────
+// Format for LLM Context
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Generate markdown documentation for LLM context.
+ * Include this in WORKFLOW_SCHEMA_FOR_LLM for self-validation.
+ */
+export const STRUCTURAL_RULES_FOR_LLM = `
+## Structural Validation Rules
+
+BEFORE finalizing any workflow modification, verify these rules:
+
+### Graph Rules (CRITICAL)
+
+1. **No Cycles**: Workflow must be a DAG. No node can depend on itself through any chain.
+   - BAD: trigger → search → llm → search (cycle!)
+   - GOOD: trigger → search → llm → output (linear)
+
+2. **All Nodes Reachable**: Every node must have a path from trigger.
+   - If a node has no incoming connections and isn't the trigger, it's orphaned.
+
+3. **All Paths Reach Output**: Every branch must eventually connect to WORKFLOW_OUTPUT.
+   - If a categorizer branch has no response node connected to output, that path is dead.
+
+### Categorizer Rules (CRITICAL)
+
+4. **Fallback Required**: Every categorizer must have a 'Fallback' category.
+   - This catches all unrecognized intents.
+
+5. **Category-Handler Mapping**: Each category needs at least one node with matching runIf.
+   - If categories are [billing, technical, Fallback], you need 3 handler paths.
+
+6. **RunIf Category Must Exist**: If runIf checks category='support', 'support' must be in categories.
+
+### Response Rules (CRITICAL)
+
+7. **One Response Per Path**: In any execution path, exactly ONE response node should execute.
+   - Multiple ungated responders = multiple responses to user (bad UX).
+   - Use mutually-exclusive runIf conditions to gate responders.
+
+8. **Response Nodes Need WORKFLOW_OUTPUT**: Response nodes must appear in resultMappings.
+   - Otherwise the response is generated but never sent to user.
+
+### Type Rules (CRITICAL)
+
+9. **Type Compatibility**:
+   | Input Expects | Can Connect From |
+   |---------------|------------------|
+   | TEXT_WITH_SOURCES | trigger.user_query, conversation_to_search_query.summarized_conversation |
+   | CHAT_CONVERSATION | trigger.chat_conversation |
+   | SEARCH_RESULT | search.search_results, combine_search_results.combined_results |
+   | EMAIL_ADDRESS | entity_extraction.email_address (NOT text outputs) |
+
+### HITL Rules
+
+10. **Both Paths Required**: general_hitl needs handlers for both approval AND rejection.
+
+### Self-Check Checklist
+
+After generating/modifying a workflow, verify:
+- [ ] Has trigger node
+- [ ] Has WORKFLOW_OUTPUT with resultMappings
+- [ ] All categories have handler nodes
+- [ ] Categorizer has Fallback
+- [ ] No orphan nodes (all reachable from trigger)
+- [ ] No dead-end paths (all reach output)
+- [ ] Response nodes are mutually exclusive (gated by runIf)
+- [ ] Email recipients come from entity_extraction
+- [ ] No circular dependencies
+`;
+// ─────────────────────────────────────────────────────────────────────────────
+// Exports
+// ─────────────────────────────────────────────────────────────────────────────
+export function getAllStructuralRules() {
+    return STRUCTURAL_RULES_FOR_LLM;
+}
+export function getInvariantById(id) {
+    return STRUCTURAL_INVARIANTS.find(i => i.id === id);
+}
+export function getCriticalInvariants() {
+    return STRUCTURAL_INVARIANTS.filter(i => i.severity === "critical");
+}

package/dist/sdk/workflow-generator.js

@@ -9,28 +9,91 @@
  * 2. Construct nodes based on user requirements
  * 3. Pass to compileWorkflow() to generate deployment-ready JSON
  */
-// ─────────────────────────────────────────────────────────────────────────────
-// Namespace mappings
-// ─────────────────────────────────────────────────────────────────────────────
-const ACTION_NAMESPACES = {
+/**
+ * FALLBACK VALUES - Used only when ActionRegistry is not available.
+ * These are based on API data as of 2026-01-16.
+ *
+ * ⚠️ PREFER USING ActionRegistry.load() TO GET CURRENT VALUES FROM API
+ */
+const FALLBACK_NAMESPACES = {
     chat_trigger: ["triggers", "emainternal"],
-    voice_trigger: ["triggers", "emainternal"],
+    // voice_trigger doesn't exist in API - Voice AI uses chat_trigger
     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"],
+    chat_categorizer: ["actions", "emainternal"], // Fixed: was "routing"
+    text_categorizer: ["actions", "emainternal"],
+    search: ["actions", "emainternal"],
+    live_web_search: ["actions", "emainternal"],
+    call_llm: ["actions", "emainternal"],
+    respond_with_sources: ["actions", "emainternal"], // Maps to call_llm
+    fixed_response: ["actions", "emainternal"],
+    external_action_caller: ["actions", "emainternal"],
+    general_hitl: ["actions", "emainternal"],
+    send_email_agent: ["actions", "emainternal"],
+    conversation_to_search_query: ["actions", "emainternal"],
+    entity_extraction: ["actions", "emainternal"],
+    combine_search_results: ["actions", "emainternal"],
+    response_validator: ["actions", "emainternal"],
 };
+/**
+ * FALLBACK VERSIONS - Based on API ListActions response 2026-01-16
+ *
+ * ⚠️ CRITICAL: These must match what the API actually expects!
+ * Many actions are v0, not v1 as previously hardcoded.
+ */
+const FALLBACK_VERSIONS = {
+    chat_trigger: "v1",
+    // voice_trigger doesn't exist in API - Voice AI uses chat_trigger
+    document_trigger: "v0",
+    chat_categorizer: "v0", // Fixed: was v1
+    text_categorizer: "v1",
+    search: "v2",
+    live_web_search: "v0", // Fixed: was v1
+    call_llm: "v2", // Fixed: was v1
+    respond_with_sources: "v2", // Maps to call_llm:v2
+    fixed_response: "v1", // API has both v0 and v1
+    external_action_caller: "v0", // Fixed: was v1
+    general_hitl: "v0", // Assumed v0
+    send_email_agent: "v0", // Fixed: was v1
+    conversation_to_search_query: "v0", // Fixed: was v1
+    entity_extraction: "v0", // entity_extraction_with_documents is v0
+    combine_search_results: "v0", // combine_and_rerank_search_results is v0
+    response_validator: "v0", // Fixed: was v1
+};
+/**
+ * Map our ActionType to actual API action names.
+ * Some names differ between our types and the API.
+ */
+const ACTION_TYPE_TO_API_NAME = {
+    entity_extraction: "entity_extraction_with_documents",
+    combine_search_results: "combine_and_rerank_search_results",
+    general_hitl: "hitl",
+    // CRITICAL: respond_with_sources doesn't exist in API - map to call_llm
+    respond_with_sources: "call_llm",
+};
+/**
+ * Get namespaces for an action, using registry if available.
+ */
+function getNamespaces(actionType, registry) {
+    const apiName = ACTION_TYPE_TO_API_NAME[actionType] ?? actionType;
+    if (registry?.isLoaded()) {
+        const def = registry.getAction(apiName);
+        if (def)
+            return def.namespaces;
+    }
+    return FALLBACK_NAMESPACES[actionType] ?? ["actions", "emainternal"];
+}
+/**
+ * Get version for an action, using registry if available.
+ */
+function getVersion(actionType, registry) {
+    const apiName = ACTION_TYPE_TO_API_NAME[actionType] ?? actionType;
+    if (registry?.isLoaded()) {
+        const def = registry.getAction(apiName);
+        if (def)
+            return def.version;
+    }
+    return FALLBACK_VERSIONS[actionType] ?? "v0";
+}
 const OPERATOR_MAP = {
     eq: 1,
     neq: 2,
@@ -39,16 +102,15 @@ const OPERATOR_MAP = {
     gte: 5,
     lte: 6,
 };
-// ─────────────────────────────────────────────────────────────────────────────
-// Compiler
-// ─────────────────────────────────────────────────────────────────────────────
 /**
  * Compile a workflow specification into deployment-ready JSON.
  *
  * @param spec - The workflow specification with nodes and result mappings
+ * @param options - Optional compilation options (registry for API-driven values)
  * @returns Compiled workflow_def and proto_config
  */
-export function compileWorkflow(spec) {
+export function compileWorkflow(spec, options) {
+    const registry = options?.registry;
     const actions = [];
     const enumTypes = [];
     const enumTypeName = spec.nodes.some((n) => n.actionType?.includes("categorizer"))
@@ -56,7 +118,7 @@ export function compileWorkflow(spec) {
         : undefined;
     // Build actions from nodes
     for (const node of spec.nodes) {
-        const action = buildAction(node, enumTypeName);
+        const action = buildAction(node, enumTypeName, registry);
         actions.push(action);
         // Build enum type for categorizer
         if (node.categories && enumTypeName) {
@@ -93,31 +155,45 @@ export function compileWorkflow(spec) {
         workflowName: {
             name: {
                 namespaces: ["ema", "workflows"],
-                name: spec.name.toLowerCase().replace(/\s+/g, "_"),
+                name: spec.name.toLowerCase().replace(/\s+/g, "_").slice(0, 50), // Limit name length
             },
         },
         actions,
+        enumTypes: validEnumTypes.length > 0 ? validEnumTypes : [], // Always include, even if empty
+        workflowInputs: {},
         results,
+        namedResults: {},
+        displayName: spec.name,
+        description: spec.description || "",
+        namedResultsEditable: false,
+        namedResultsEnabled: false,
     };
-    // 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"];
+function buildAction(node, enumTypeName, registry) {
+    // Use registry for API-driven values, fallback to static values
+    const namespaces = getNamespaces(node.actionType, registry);
+    const version = getVersion(node.actionType, registry);
+    // Map our ActionType to actual API action name if different
+    const apiActionName = ACTION_TYPE_TO_API_NAME[node.actionType] ?? node.actionType;
     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 },
+            name: { namespaces, name: apiActionName },
+            version,
         },
         inputs: {},
+        displaySettings: {
+            displayName: node.displayName ?? "",
+            description: node.description ?? "",
+            coordinates: { x: 800, y: 200 }, // Default position
+            showConfig: 0,
+        },
+        typeArguments: {},
+        tools: [],
         disableHumanInteraction: node.disableHitl ?? false,
     };
     // Build inputs
@@ -211,6 +287,15 @@ function buildInputBinding(binding) {
             return { inline: { bool: binding.value }, autoDetectedBinding: false };
         case "widget_config":
             return { widgetConfig: { widgetName: binding.widgetName }, autoDetectedBinding: false };
+        case "widget_config_array":
+            // For datastore_configs that needs multiBinding with elements array
+            return {
+                multiBinding: {
+                    elements: (binding.widgetNames || [binding.widgetName]).map(name => ({
+                        widgetConfig: { widgetName: name }
+                    }))
+                }
+            };
         case "llm_inferred":
             return { llmInferred: {} };
         default:
@@ -219,17 +304,80 @@ function buildInputBinding(binding) {
 }
 function buildProtoConfig(spec) {
     const projectType = spec.personaType === "voice" ? 5 : spec.personaType === "chat" ? 4 : 2;
+    // Widget format expected by Ema API:
+    // { name: "widgetName", type: <type_id>, widgetName: { ...config... } }
+    // The config is stored under a key matching the widget's name
     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 } },
+        {
+            name: "fusionModel",
+            type: 6,
+            fusionModel: { selectedModels: ["gpt-4.1"] }
+        },
+        {
+            name: "dataProtection",
+            type: 8,
+            dataProtection: { 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 } });
+        // Build voice settings from spec.voiceConfig with sensible defaults
+        const vc = spec.voiceConfig ?? {};
+        const defaultIdentity = `You are ${spec.name}. ${spec.description}`;
+        widgets.push({
+            name: "voiceSettings",
+            type: 38,
+            voiceSettings: {
+                languageHints: vc.languageHints ?? ["en-US"],
+                voiceModel: "default"
+            }
+        }, {
+            name: "conversationSettings",
+            type: 39,
+            conversationSettings: {
+                welcomeMessage: vc.welcomeMessage ?? `Hello, this is ${spec.name}. How can I help you today?`,
+                identityAndPurpose: vc.identityAndPurpose ?? defaultIdentity,
+                takeActionInstructions: vc.takeActionInstructions ?? "Take appropriate actions based on the user's request. Always confirm before making changes.",
+                hangupInstructions: vc.hangupInstructions ?? "End the call politely when the user's request is complete or they ask to hang up.",
+                transferCallInstructions: vc.transferInstructions ?? "",
+                speechCharacteristics: vc.speechCharacteristics ?? "Professional, friendly, and helpful",
+                systemPrompt: vc.systemPrompt ?? "",
+                waitMessage: vc.waitMessage ?? "One moment please while I look that up...",
+            }
+        }, {
+            name: "vadSettings",
+            type: 43,
+            vadSettings: {
+                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" } });
+        // Build chat settings from spec.chatConfig with sensible defaults
+        const cc = spec.chatConfig ?? {};
+        widgets.push({
+            name: "chatbotSdkConfig",
+            type: 28,
+            chatbotSdkConfig: {
+                name: cc.name ?? spec.name,
+                theme: { primaryColor: cc.primaryColor ?? "#0066cc" },
+                allowedDomains: cc.allowedDomains ?? ["*"]
+            }
+        }, {
+            name: "feedbackMessage",
+            type: 33,
+            feedbackMessage: {
+                message: { question: cc.feedbackQuestion ?? "Was this response helpful?" },
+                feedbackFrequency: "always"
+            }
+        });
     }
-    widgets.push({ widget_type_id: 3, widget_name: "fileUpload", widget_config: { useChunking: true } });
+    widgets.push({
+        name: "fileUpload",
+        type: 3,
+        fileUpload: { useChunking: true }
+    });
     return {
         project_type: projectType,
         name: spec.name,