@tiledesk/tiledesk-server 2.28.2 → 3.0.0

package/services/v3FlowService.js

@@ -0,0 +1,416 @@
+const uuidv4 = require('uuid/v4');
+const winston = require('../config/winston');
+
+/**
+ * The V3 shape of an agent's flow (Design Studio V3, since 15/10/2026).
+ *
+ * A V3 agent (`faq_kb.ds_version === 'v3'`) keeps its links in the bot-level list
+ * `faq_kb.connectors`, not in the destination fields of its actions (`intentName`,
+ * `trueIntent`, `goToIntent`, `cases[].intent`, `attributes.nextBlockAction.intentName`, ...).
+ * Those fields are empty in the stored blocks: the list is the only truth, and both the
+ * Design Studio V3 and the engine (tiledesk-chatbot, ConnectorsV3) read it from there.
+ *
+ * This module is the server's own knowledge of that shape, so an agent born here (from a
+ * template) or coming in (import, fork, restore) is already in V3 form:
+ * - `toV3Flow(intents)`: the blocks of a template, written the V2 way, become V3 blocks plus
+ *   their connectors list (technical ids filled in, list built from the fields, fields cleared);
+ * - `validateConnectors(collection)`: the checks the dedicated endpoint and the import apply;
+ * - `promoteLegacyJson(json)`: a JSON exported before the two fields existed carried them
+ *   inside `attributes`; they are moved to the fields.
+ *
+ * The output catalog is a copy of `connectors/connector-catalog.ts` of the Design Studio and of
+ * `utils/ConnectorsV3.js` of the engine: same types, same fields, same id suffixes. A record is
+ * `{ id, from: { intentId, actionId, slot }, to: { intentId }, kind, props? }` and its id is
+ * `${intentId}/${actionId}${suffix}/${toIntentId}`. If the catalog changes there, it changes here.
+ *
+ * A V2 agent never passes through here: every caller checks `ds_version` first.
+ */
+
+const DS_VERSION_V3 = 'v3';
+const COLLECTION_VERSION = 1;
+const RECORD_KINDS = ['block', 'action', 'button', 'case', 'branch'];
+const RETURN_STACK = 'returnstack';
+const BUTTON_URL = 'url';
+const BUTTON_ACTION = 'action';
+
+const field = (key, suffix, name) => ({ key, kind: 'action', path: 'field', suffix, field: name });
+const nested = (key, suffix, path) => ({ key, kind: 'action', path: 'nested', suffix, steps: path });
+const lastCommand = (key, suffix, name) => ({ key, kind: 'action', path: 'lastCommandSetting', suffix, field: name });
+const BUTTONS = { key: 'button', kind: 'button', path: 'buttons' };
+const array = (key, kind, suffixOf, arrayName, idField, name) => ({ key, kind, path: 'array', suffixOf, array: arrayName, idField, field: name });
+
+const TRUE_FALSE = [field('true', '/true', 'trueIntent'), field('false', '/false', 'falseIntent')];
+const VOICE_SETTINGS = [nested('noInput', '/noInput', ['settings', 'noInputIntent']), nested('noMatch', '/noMatch', ['settings', 'noMatchIntent'])];
+const REPLY_V1 = [BUTTONS, ...VOICE_SETTINGS];
+
+const OUTPUT_CATALOG = {
+  intent:              [field('default', '', 'intentName')],
+  connect_block:       [field('default', '', 'intentName')],
+  reply:               REPLY_V1,
+  randomreply:         REPLY_V1,
+  replyv2:             [BUTTONS, field('noInput', '/noInput', 'noInputIntent'), field('noMatch', '/noMatch', 'noMatchIntent')],
+  ifonlineagents:      TRUE_FALSE,
+  ifonlineagentsv2:    TRUE_FALSE,
+  ifopenhours:         TRUE_FALSE,
+  jsonconditionmulti:  [array('case', 'case', (c) => '/case/' + c._tdCaseId, 'cases', '_tdCaseId', 'intent'), field('else', '/else', 'elseIntent')],
+  jsoncondition:       TRUE_FALSE,
+  jsoncondition2:      TRUE_FALSE,
+  invoke_subagent:     TRUE_FALSE,
+  askgpt:              TRUE_FALSE,
+  askgptv2:            TRUE_FALSE,
+  gpt_task:            TRUE_FALSE,
+  gpt_assistant:       TRUE_FALSE,
+  ai_prompt:           TRUE_FALSE,
+  ai_condition:        [array('branch', 'branch', (b) => '/' + b.label + '/true', 'intents', 'label', 'conditionIntentId'), field('fallback', '/fallback', 'fallbackIntent'), field('error', '/error', 'errorIntent')],
+  webrequestv2:        TRUE_FALSE,
+  data_table:          TRUE_FALSE,
+  make:                TRUE_FALSE,
+  hubspot:             TRUE_FALSE,
+  customerio:          TRUE_FALSE,
+  brevo:               TRUE_FALSE,
+  n8n:                 TRUE_FALSE,
+  qapla:               TRUE_FALSE,
+  capture_user_reply:  [field('default', '', 'goToIntent')],
+  iteration:           [field('goto', '/goto', 'goToIntent'), field('fallback', '/fallback', 'fallbackIntent')],
+  dtmf_menu:           [BUTTONS, ...VOICE_SETTINGS, lastCommand('noInput', '/noInput', 'noInputIntent'), lastCommand('noMatch', '/noMatch', 'noMatchIntent')],
+  dtmf_form:           [BUTTONS, ...VOICE_SETTINGS, lastCommand('noInput', '/noInput', 'noInputIntent'), lastCommand('noMatch', '/noMatch', 'noMatchIntent')],
+  speech_form:         [lastCommand('noInput', '/noInput', 'noInputIntent'), lastCommand('noMatch', '/noMatch', 'noMatchIntent')],
+  blind_transfer:      [BUTTONS, ...VOICE_SETTINGS, lastCommand('true', '/true', 'trueIntent'), lastCommand('false', '/false', 'falseIntent')],
+  send_whatsapp:       TRUE_FALSE,
+};
+
+/** The block's own exit (the dot), stored in `attributes.nextBlockAction.intentName`. */
+const BLOCK_SLOT = { key: 'next', kind: 'block', path: 'block', suffix: '' };
+
+function isSet(value) {
+  return typeof value === 'string' && value !== '';
+}
+
+function hasValidUid(uid) {
+  return typeof uid === 'string' && uid !== '' && uid !== 'UUIDV4';
+}
+
+/** Every `buttons[]` inside the object, at any depth, in visiting order (as the Design Studio's `findButtons`). */
+function findButtons(obj) {
+  let buttons = [];
+  if (Array.isArray(obj)) {
+    for (const element of obj) { buttons = buttons.concat(findButtons(element)); }
+  } else if (obj && typeof obj === 'object') {
+    if (Array.isArray(obj.buttons)) { buttons = buttons.concat(obj.buttons); }
+    for (const key in obj) { if (key !== 'buttons') { buttons = buttons.concat(findButtons(obj[key])); } }
+  }
+  return buttons;
+}
+
+function isReturnStackIntent(intent) {
+  const actions = intent && intent.actions;
+  return Array.isArray(actions) && actions.length === 1 && actions[0] && actions[0]._tdActionType === RETURN_STACK;
+}
+
+/** A button's target is `#<id>` or `#<id>{...params}`; a field's target is `#<id>` (a bare id in old flows). */
+function parseTarget(raw, isButton) {
+  if (!isSet(raw)) { return { toId: null, attrs: null, hasHash: false }; }
+  if (isButton) {
+    const start = raw.indexOf('#') + 1;
+    const end = raw.indexOf('{');
+    const toId = end > -1 ? raw.substring(start, end) : raw.substring(start);
+    return { toId: toId !== '' ? toId : null, attrs: end > -1 ? raw.substring(end) : null, hasHash: raw.trim().startsWith('#') };
+  }
+  const toId = raw.replace('#', '');
+  return { toId: toId !== '' ? toId : null, attrs: null, hasHash: raw.trim().startsWith('#') };
+}
+
+function makeSlot(spec, intentId, actionId, holder, fieldName, item, keyOverride) {
+  const isButton = spec.path === 'buttons';
+  const raw = holder && isSet(holder[fieldName]) ? holder[fieldName] : '';
+  const suffix = spec.path === 'array' ? spec.suffixOf(item) : (isButton ? '/' + item.uid : spec.suffix);
+  return {
+    key: keyOverride || spec.key, kind: spec.kind,
+    intentId, actionId, fromId: intentId + '/' + actionId + suffix,
+    holder, field: fieldName, item, raw, ...parseTarget(raw, isButton)
+  };
+}
+
+/** The exits of one action, connected or empty, in catalog order. Never throws: a malformed action just has fewer exits. */
+function outputsOf(intentId, action) {
+  const out = [];
+  if (!action || typeof action !== 'object') { return out; }
+  const actionId = action._tdActionId;
+  for (const spec of OUTPUT_CATALOG[action._tdActionType] || []) {
+    switch (spec.path) {
+      case 'field':
+        out.push(makeSlot(spec, intentId, actionId, action, spec.field));
+        break;
+      case 'nested': {
+        let holder = action;
+        for (let i = 0; i < spec.steps.length - 1 && holder; i++) { holder = holder[spec.steps[i]]; }
+        if (holder && typeof holder === 'object') { out.push(makeSlot(spec, intentId, actionId, holder, spec.steps[spec.steps.length - 1])); }
+        break;
+      }
+      case 'lastCommandSetting': {
+        const commands = action.attributes && action.attributes.commands;
+        const settings = Array.isArray(commands) && commands.length > 0 && commands[commands.length - 1] ? commands[commands.length - 1].settings : null;
+        if (settings && typeof settings === 'object') { out.push(makeSlot(spec, intentId, actionId, settings, spec.field)); }
+        break;
+      }
+      case 'buttons':
+        // A text button has an empty exit; only an `action` button with a target yields a record. A url button has no exit.
+        for (const button of findButtons(action)) {
+          if (!button || typeof button !== 'object' || button.type === BUTTON_URL) { continue; }
+          const slot = makeSlot(spec, intentId, actionId, button, 'action', button, 'button:' + (button.uid == null ? '' : button.uid));
+          if (button.type !== BUTTON_ACTION) { slot.raw = ''; slot.toId = null; slot.attrs = null; slot.hasHash = false; }
+          out.push(slot);
+        }
+        break;
+      case 'array': {
+        const list = action[spec.array];
+        if (!Array.isArray(list)) { break; }
+        for (const item of list) {
+          if (!item || typeof item !== 'object') { continue; }
+          out.push(makeSlot(spec, intentId, actionId, item, spec.field, item, spec.key + ':' + item[spec.idField]));
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return out;
+}
+
+function blockOutputOf(intent) {
+  const next = intent && intent.attributes && intent.attributes.nextBlockAction;
+  if (!next || typeof next !== 'object' || isReturnStackIntent(intent)) { return null; }
+  const slot = makeSlot(BLOCK_SLOT, intent.intent_id, next._tdActionId, next, 'intentName');
+  slot.fromId = intent.intent_id + '/' + next._tdActionId;
+  return slot;
+}
+
+/** Every exit of a block: the dot first, then the actions in their order. */
+function slotsOfIntent(intent) {
+  const out = [];
+  const block = blockOutputOf(intent);
+  if (block) { out.push(block); }
+  for (const action of (intent && intent.actions) || []) { out.push(...outputsOf(intent.intent_id, action)); }
+  return out;
+}
+
+/**
+ * Fills in the technical ids a template may leave out: `intent_id`, `_tdActionId` of actions and of
+ * the block's dot, `uid` of buttons, `_tdCaseId` of the cases of a multi condition. The Design Studio
+ * did the same on open; a V3 block must have them before its list is built. Mutates; returns how many.
+ */
+function ensureTechnicalIds(intents) {
+  let filled = 0;
+  for (const intent of intents || []) {
+    if (!intent || typeof intent !== 'object') { continue; }
+    if (!isSet(intent.intent_id)) { intent.intent_id = uuidv4(); filled++; }
+    const next = intent.attributes && intent.attributes.nextBlockAction;
+    if (next && typeof next === 'object' && !isSet(next._tdActionId)) { next._tdActionId = uuidv4(); filled++; }
+    for (const action of intent.actions || []) {
+      if (!action || typeof action !== 'object') { continue; }
+      if (!isSet(action._tdActionId)) { action._tdActionId = uuidv4(); filled++; }
+      for (const button of findButtons(action)) {
+        if (button && typeof button === 'object' && !hasValidUid(button.uid)) { button.uid = uuidv4(); filled++; }
+      }
+      if (Array.isArray(action.cases)) {
+        for (const c of action.cases) {
+          if (c && typeof c === 'object' && !isSet(c._tdCaseId)) { c._tdCaseId = uuidv4(); filled++; }
+        }
+      }
+    }
+  }
+  return filled;
+}
+
+function indexFlow(intents) {
+  const ids = new Set();
+  for (const intent of intents || []) { if (intent && isSet(intent.intent_id)) { ids.add(intent.intent_id); } }
+  return ids;
+}
+
+/** A target that the list can hold: `#<id>` of an existing block, or a bare id that is one (the Design Studio added the `#`). */
+function resolvedTarget(slot, ids) {
+  if (!slot.toId) { return null; }
+  if (slot.hasHash) { return ids.has(slot.toId) ? slot.toId : null; }
+  return ids.has(slot.toId) ? slot.toId : null;
+}
+
+/** A destination written the V2 way: the key exists and holds '' or a `#id` (a bare block name of old flows is left alone). */
+function isV2Trace(slot, ids) {
+  if (!slot.holder || !Object.prototype.hasOwnProperty.call(slot.holder, slot.field)) { return false; }
+  if (slot.raw === '' || slot.hasHash) { return true; }
+  return !!slot.toId && ids.has(slot.toId);
+}
+
+function propsOf(slot, intent) {
+  const props = {};
+  if (slot.kind === 'button' && isSet(slot.attrs)) { props.params = slot.attrs; }
+  const looks = intent && intent.attributes && intent.attributes.connectors && intent.attributes.connectors[slot.fromId];
+  if (looks && typeof looks === 'object') {
+    if (looks.display !== undefined) { props.display = looks.display; }
+    if (looks.label !== undefined) { props.label = looks.label; }
+    if (looks.color !== undefined) { props.color = looks.color; }
+  }
+  return Object.keys(props).length > 0 ? props : null;
+}
+
+/**
+ * The connectors list the blocks describe: one record per connected exit towards a block that
+ * exists. Same ids and same order as the Design Studio's `buildCollection`.
+ */
+function buildConnectors(intents, now) {
+  const ids = indexFlow(intents);
+  const items = [];
+  const seen = new Set();
+  for (const intent of intents || []) {
+    if (!intent) { continue; }
+    for (const slot of slotsOfIntent(intent)) {
+      const toId = resolvedTarget(slot, ids);
+      if (!toId) { continue; }
+      const id = slot.fromId + '/' + toId;
+      if (seen.has(id)) { continue; }
+      seen.add(id);
+      const record = { id, from: { intentId: slot.intentId, actionId: slot.actionId, slot: slot.key }, to: { intentId: toId }, kind: slot.kind };
+      const props = propsOf(slot, intent);
+      if (props) { record.props = props; }
+      items.push(record);
+    }
+  }
+  return { version: COLLECTION_VERSION, updatedAt: now ? now() : new Date().toISOString(), items };
+}
+
+/**
+ * Clears every V2 trace of the connectors from the blocks: destination keys of actions and of the
+ * dot, `button.action`, and the per-block visual attributes (`attributes.connectors`). Mirrors the
+ * Design Studio's `stripV2Connectors`. Mutates; returns how many it removed.
+ */
+function stripDestinations(intents) {
+  const ids = indexFlow(intents);
+  let stripped = 0;
+  for (const intent of intents || []) {
+    if (!intent) { continue; }
+    for (const slot of slotsOfIntent(intent)) {
+      if (!isV2Trace(slot, ids)) { continue; }
+      delete slot.holder[slot.field];
+      stripped++;
+    }
+    if (intent.attributes && Object.prototype.hasOwnProperty.call(intent.attributes, 'connectors')) {
+      delete intent.attributes.connectors;
+      stripped++;
+    }
+  }
+  return stripped;
+}
+
+/**
+ * Blocks written the V2 way (a template, an old JSON) become V3 blocks plus their list.
+ * Mutates the intents it receives and returns `{ intents, connectors }`.
+ */
+function toV3Flow(intents, now) {
+  const list = Array.isArray(intents) ? intents : [];
+  ensureTechnicalIds(list);
+  const connectors = buildConnectors(list, now);
+  stripDestinations(list);
+  return { intents: list, connectors };
+}
+
+/** The errors a connectors list has; empty when it is good. Shape only: targets are not checked against the blocks. */
+function validateConnectors(collection) {
+  const errors = [];
+  if (!collection || typeof collection !== 'object' || Array.isArray(collection)) { return ['connectors must be an object']; }
+  if (collection.version !== COLLECTION_VERSION) { errors.push('connectors.version must be ' + COLLECTION_VERSION); }
+  if (collection.updatedAt !== undefined && collection.updatedAt !== null && isNaN(new Date(collection.updatedAt).getTime())) { errors.push('connectors.updatedAt must be a date'); }
+  if (!Array.isArray(collection.items)) { errors.push('connectors.items must be an array'); return errors; }
+  const ids = new Set();
+  collection.items.forEach((record, i) => {
+    const at = 'connectors.items[' + i + ']';
+    if (!record || typeof record !== 'object') { errors.push(at + ' must be an object'); return; }
+    if (!isSet(record.id)) { errors.push(at + '.id is required'); }
+    const from = record.from && typeof record.from === 'object' ? record.from : null;
+    if (!from || !isSet(from.intentId) || !isSet(from.actionId) || !isSet(from.slot)) { errors.push(at + '.from needs intentId, actionId and slot'); }
+    const to = record.to && typeof record.to === 'object' ? record.to : null;
+    if (!to || !isSet(to.intentId)) { errors.push(at + '.to.intentId is required'); }
+    if (!RECORD_KINDS.includes(record.kind)) { errors.push(at + '.kind must be one of ' + RECORD_KINDS.join(', ')); }
+    if (record.props !== undefined && (record.props === null || typeof record.props !== 'object' || Array.isArray(record.props))) { errors.push(at + '.props must be an object'); }
+    if (isSet(record.id) && from && to && isSet(from.intentId) && isSet(to.intentId)) {
+      if (!record.id.startsWith(from.intentId + '/') || !record.id.endsWith('/' + to.intentId)) { errors.push(at + '.id does not match from.intentId and to.intentId'); }
+    }
+    if (isSet(record.id)) {
+      if (ids.has(record.id)) { errors.push(at + '.id is duplicated: ' + record.id); }
+      ids.add(record.id);
+    }
+  });
+  return errors;
+}
+
+/** 'v3' for any spelling of the V3 label, otherwise undefined. */
+function normalizeDsVersion(value) {
+  if (typeof value !== 'string') { return undefined; }
+  const label = value.trim().toLowerCase();
+  return label === DS_VERSION_V3 ? DS_VERSION_V3 : undefined;
+}
+
+function isV3(bot) {
+  return !!bot && bot.ds_version === DS_VERSION_V3;
+}
+
+/** The legacy keys a PATCH of the attributes must not carry any more. */
+function legacyAttributeKeys(attributes) {
+  if (!attributes || typeof attributes !== 'object') { return []; }
+  return ['dsVersion', 'connectors'].filter((key) => Object.prototype.hasOwnProperty.call(attributes, key));
+}
+
+/**
+ * A JSON exported before 15/10/2026 carries `attributes.dsVersion` and `attributes.connectors`:
+ * they move to `ds_version` and `connectors` (the fields win if both are present). Applies to the
+ * sub agents too. Mutates; returns true if it moved anything.
+ */
+function promoteLegacyJson(json) {
+  if (!json || typeof json !== 'object') { return false; }
+  let moved = false;
+  const attributes = json.attributes;
+  if (attributes && typeof attributes === 'object') {
+    if (Object.prototype.hasOwnProperty.call(attributes, 'dsVersion')) {
+      if (json.ds_version === undefined) {
+        const label = normalizeDsVersion(attributes.dsVersion);
+        if (label) { json.ds_version = label; }
+      }
+      delete attributes.dsVersion;
+      moved = true;
+    }
+    if (Object.prototype.hasOwnProperty.call(attributes, 'connectors')) {
+      if (json.connectors === undefined && attributes.connectors && typeof attributes.connectors === 'object') {
+        json.connectors = attributes.connectors;
+      }
+      delete attributes.connectors;
+      moved = true;
+    }
+  }
+  if (json.ds_version !== undefined) {
+    const label = normalizeDsVersion(json.ds_version);
+    if (label) { json.ds_version = label; } else { delete json.ds_version; }
+  }
+  for (const subagent of Array.isArray(json.subagents) ? json.subagents : []) {
+    if (promoteLegacyJson(subagent)) { moved = true; }
+  }
+  if (moved) { winston.verbose('(V3FlowService) legacy dsVersion/connectors moved out of attributes'); }
+  return moved;
+}
+
+module.exports = {
+  DS_VERSION_V3,
+  COLLECTION_VERSION,
+  RECORD_KINDS,
+  OUTPUT_CATALOG,
+  slotsOfIntent,
+  ensureTechnicalIds,
+  buildConnectors,
+  stripDestinations,
+  toV3Flow,
+  validateConnectors,
+  normalizeDsVersion,
+  isV3,
+  legacyAttributeKeys,
+  promoteLegacyJson
+};

package/template/chatbot/blank.js

@@ -3,9 +3,26 @@ const uuidv4 = require('uuid/v4');
 module.exports = function generateTemplate(options) {
     
     const custom_intent_id = uuidv4();
-
+    const default_fallback_intent_id = uuidv4();
+    
     return [
         {
+            "webhook_enabled": false,
+            "enabled": true,
+            "actions": [],
+            "intent_display_name": "defaultFallback",
+            "attributes": {
+                "position": {
+                    "x": 714,
+                    "y": 528
+                },
+                "nextBlockAction": {
+                    "_tdActionId": "5b689996-317b-4761-9bc0-cc78d1f390cb",
+                    "_tdActionType": "intent",
+                    "intentName": "#" + default_fallback_intent_id
+                }
+            }
+        }, {
             "webhook_enabled": false,
             "enabled": true,
             "actions": [{
@@ -24,10 +41,11 @@ module.exports = function generateTemplate(options) {
                     }]
                 }
             }],
-            "intent_display_name": "defaultFallback",
+            "intent_display_name": "untitled_block_2",
+            "intent_id": default_fallback_intent_id,
             "attributes": {
                 "position": {
-                    "x": 714,
+                    "x": 1114,
                     "y": 528
                 }
             }

package/template/chatbot/blank_subagent.js

@@ -0,0 +1,139 @@
+const uuidv4 = require('uuid/v4');
+
+module.exports = function generateTemplate(options) {
+
+    const custom_intent_id = uuidv4();
+    const return_custom_intent_id = uuidv4();
+    const default_fallback_intent_id = uuidv4();
+
+    return [
+        {
+            "webhook_enabled": false,
+            "enabled": true,
+            "actions": [{
+                "_tdActionType": "intent",
+                "intentName": "#" + custom_intent_id
+            }],
+            "question": "",
+            "intent_display_name": "start",
+            "attributes": {
+                "position": {
+                    "x": 172,
+                    "y": 384
+                }
+            },
+            "agents_available": false,
+        },
+        {
+            "webhook_enabled": false,
+            "enabled": true,
+            "actions": [{
+                "_tdActionTitle": "",
+                "_tdActionType": "reply",
+                "attributes": {
+                    "disableInputMessage": false,
+                    "commands": [
+                        {
+                            "type": "wait",
+                            "time": 500
+                        },
+                        {
+                            "type": "message",
+                            "message": {
+                                "type": "text",
+                                "text": "A chat message will be sent to the visitor",
+                                "attributes": {
+                                    "attachment": {
+                                        "type": "template",
+                                        "buttons": [],
+                                        "json_buttons": "",
+                                        "json_gallery": ""
+                                    }
+                                }
+                            }
+                        }
+                    ]
+                },
+
+            }],
+            "intent_display_name": "untitled_block_1",
+            "intent_id": custom_intent_id,
+            "agents_available": false,
+            "attributes": {
+                "position": {
+                    "x": 612,
+                    "y": 312
+                },
+                "nextBlockAction": {
+                    "_tdActionId": "5b689996-317b-4761-9bc0-cc78d1f390ca",
+                    "_tdActionType": "intent",
+                    "intentName": "#" + return_custom_intent_id
+                },
+                "connectors": {},
+                "color": "156,163,205",
+                "readonly": false
+            },
+        },
+        {
+            "webhook_enabled": false,
+            "enabled": true,
+            "actions": [{
+                "_tdActionType": "returnstack",
+            }],
+            "intent_display_name": "return",
+            "agents_available": false,
+            "intent_id": return_custom_intent_id,
+            "attributes": {
+                "position": {
+                    "x": 1129,
+                    "y": 361
+                }
+            },
+            "agents_available": false,
+        },
+        {
+            "webhook_enabled": false,
+            "enabled": true,
+            "actions": [],
+            "intent_display_name": "defaultFallback",
+            "attributes": {
+                "position": {
+                    "x": 315,
+                    "y": 699
+                },
+                "nextBlockAction": {
+                    "_tdActionId": "5b689996-317b-4761-9bc0-cc78d1f390cb",
+                    "_tdActionType": "intent",
+                    "intentName": "#" + default_fallback_intent_id
+                }
+            }
+        }, {
+            "webhook_enabled": false,
+            "enabled": true,
+            "actions": [{
+                "_tdActionType": "reply",
+                "text": "I didn't understand. Can you rephrase your question?",
+                "attributes": {
+                    "commands": [{
+                        "type": "wait",
+                        "time": 500
+                    }, {
+                        "type": "message",
+                        "message": {
+                            "type": "text",
+                            "text": "I didn't understand. Can you rephrase your question?"
+                        }
+                    }]
+                }
+            }],
+            "intent_display_name": "untitled_block_2",
+            "intent_id": default_fallback_intent_id,
+            "attributes": {
+                "position": {
+                    "x": 721,
+                    "y": 699
+                }
+            }
+        }
+    ]
+}

package/template/chatbot/blank_voice.js

@@ -3,6 +3,7 @@ const uuidv4 = require('uuid/v4');
 module.exports = function generateTemplate(options) {
 
     const custom_intent_id = uuidv4();
+    const default_fallback_intent_id = uuidv4();
 
     return [
         {
@@ -24,6 +25,22 @@ module.exports = function generateTemplate(options) {
             }
         },
         {
+            "webhook_enabled": false,
+            "enabled": true,
+            "actions": [],
+            "intent_display_name": "defaultFallback",
+            "attributes": {
+                "position": {
+                    "x": 714,
+                    "y": 528
+                },
+                "nextBlockAction": {
+                    "_tdActionId": "5b689996-317b-4761-9bc0-cc78d1f390cb",
+                    "_tdActionType": "intent",
+                    "intentName": "#" + default_fallback_intent_id
+                }
+            }
+        }, {
             "webhook_enabled": false,
             "enabled": true,
             "actions": [{
@@ -40,13 +57,13 @@ module.exports = function generateTemplate(options) {
                             "text": "I didn't understand. Can you rephrase your question?"
                         }
                     }]
-                },
+                }
             }],
-            "intent_display_name": "defaultFallback",
+            "intent_display_name": "untitled_block_2",
+            "intent_id": default_fallback_intent_id,
             "attributes": {
-                "readonly": true,
                 "position": {
-                    "x": 714,
+                    "x": 1114,
                     "y": 528
                 }
             }