@scout9/app 1.0.0-alpha.0.8.8 → 1.0.0-alpha.0.8.9

package/dist/spirits.cjs

@@ -2,8 +2,1104 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var spirits = require("./spirits-2d7d7919.cjs");
+var _rollupPluginBabelHelpers = require("./_rollupPluginBabelHelpers-606d8129.cjs");
 
+var _excluded = ["keywords"];
+/**
+ * @typedef {Object} Document
+ * @property {string} id
+ */
 
+/**
+ * Represents a change with before and after states of a given type.
+ * @template Type The type of the before and after properties.
+ * @typedef {Object} Change
+ * @property {Type} before - The state before the change.
+ * @property {Type} after - The state after the change.
+ */
 
-exports.Spirits = spirits.Spirits;
+/**
+ * @typedef {Object} ConversationData
+ * @property {import('@scout9/app').Scout9ProjectBuildConfig} config - used to define generation and extract persona metadata
+ * @property {import('@scout9/app').Conversation} conversation
+ * @property {Array<import('@scout9/admin').Message>} messages
+ * @property {import('@scout9/admin').Message} message - the message sent by the customer (should exist in messages)
+ * @property {import('@scout9/app').Customer} customer
+ * @property {import('@scout9/app').ConversationProgress} progress - progress checklist for manual/auto ingress workflows
+ * @property {any} context - event context
+ */
+
+/**
+ * @typedef {Object} ParseOutput
+ * @property {Array<import('@scout9/admin').Message>} messages
+ * @property {import('@scout9/app').Conversation} conversation
+ * @property {import('@scout9/admin').Message} message
+ * @property {any} context
+ */
+
+/**
+ * @typedef {Object} WorkflowOutput
+ * @property {Array<import('@scout9/app').WorkflowResponseSlot>} slots
+ * @property {Array<import('@scout9/admin').Message>} messages
+ * @property {import('@scout9/app').Conversation} conversation
+ * @property {any} context
+ */
+
+/**
+ * @typedef {Object} GenerateOutput
+ * @property {import('@scout9/admin').GenerateResponse | undefined} generate
+ * @property {Array<import('@scout9/admin').Message>} messages
+ * @property {import('@scout9/app').Conversation} conversation
+ * @property {any} context
+ */
+
+/**
+ * @callback ParseFun
+ * @param {string} message - message to send
+ * @param {string | undefined} language - language to parse in, defaults to "en" for english
+ * @returns {Promise<import('@scout9/admin').ParseResponse>}
+ */
+
+/**
+ * @callback ContextualizerFun
+ * @param {Pick<import('@scout9/app').WorkflowEvent, 'messages' | 'conversation'>} args - message to send
+ * @returns {Promise<import('@scout9/app').WorkflowEvent['messages']>}
+ */
+
+/**
+ * @callback WorkflowFun
+ * @param {import('@scout9/app').WorkflowEvent} event - conversation data
+ * @returns {Promise<import('@scout9/app').WorkflowResponse>}
+ */
+
+/**
+ * @callback GenerateFun
+ * @param {import('@scout9/admin').GenerateRequestOneOf1} data - data to generate from
+ * @returns {Promise<import('@scout9/admin').GenerateResponse>}
+ */
+
+/**
+ * @callback TransformerFun
+ * @param {import('@scout9/admin').PmtTransformRequest} data - data to generate from
+ * @returns {Promise<import('@scout9/admin').PmtTransformResponse>}
+ */
+
+/**
+ * @callback IdGeneratorFun
+ * @param {import('@scout9/admin').Message['role']} prefix
+ * @returns {string}
+ */
+
+/**
+ * @callback StatusCallback
+ * @param {string} message
+ * @param {'info' | 'warn' | 'error' | 'success' | undefined} [level]
+ * @param {string | undefined} [type]
+ * @param {any | undefined} [payload]
+ * @returns {void}
+ */
+
+/**
+ * @typedef {Object} CustomerSpiritCallbacks
+ * @property {ParseFun} parser
+ * @property {ContextualizerFun} contextualizer
+ * @property {WorkflowFun} workflow
+ * @property {GenerateFun} generator
+ * @property {TransformerFun} transformer
+ * @property {IdGeneratorFun} idGenerator
+ * @property {StatusCallback | undefined} [progress]
+ */
+
+/**
+ * @typedef {Object} ConversationEvent
+ * @property {(Change<import('@scout9/app').Conversation> & {
+ *   forwardNote?: string;
+ *   forward?: import('@scout9/app').WorkflowResponseSlot['forward'];
+ * })} conversation
+ * @property {Change<Array<import('@scout9/admin').Message>>} messages
+ * @property {Change<any>} context
+ * @property {Change<import('@scout9/admin').Message>} message
+ * @property {Array<import('@scout9/app').Followup>} followup
+ * @property {Array<import('@scout9/app').EntityContextUpsert>} entityContextUpsert
+ */
+var Spirits = {
+  /**
+   * Customer message
+   * @param {ConversationData & CustomerSpiritCallbacks} input
+   * @param {(error: Error) => void} onError
+   * @returns {Promise<ConversationEvent>}
+   */
+  customer: function () {
+    var _customer = _rollupPluginBabelHelpers._asyncToGenerator( /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _callee(input) {
+      var _recentUserMessage;
+      var onError,
+        customer,
+        config,
+        parser,
+        contextualizer,
+        workflow,
+        generator,
+        transformer,
+        idGenerator,
+        _input$progress,
+        progress,
+        messageBefore,
+        contextBefore,
+        messagesBefore,
+        conversationBefore,
+        conversation,
+        messages,
+        context,
+        message,
+        followup,
+        entityContextUpsert,
+        updateConversation,
+        updateContext,
+        userMessages,
+        recentUserMessage,
+        lockConversation,
+        incrementLockAttempt,
+        _addInstruction,
+        addInstruction,
+        persona,
+        invalidRoles,
+        parsePayload,
+        index,
+        _message,
+        previousUserMessages,
+        oldKeyCount,
+        newKeyCount,
+        noNewContext,
+        _messages2,
+        newContextMessages,
+        _iterator,
+        _step,
+        _loop,
+        slots,
+        hasNoInstructions,
+        hasNoCustomMessage,
+        messagesToTransform,
+        previousLockAttempt,
+        resettedIntent,
+        _forward,
+        _forwardNote,
+        _tasks,
+        _iterator2,
+        _step2,
+        _step2$value,
+        forward,
+        forwardNote,
+        instructions,
+        removeInstructions,
+        manualMessage,
+        scheduled,
+        resetIntent,
+        secondsDelay,
+        contextUpsert,
+        anticipate,
+        slotFollowup,
+        slotEntityContextUpsert,
+        tasks,
+        _slots,
+        map,
+        i,
+        _anticipate$i,
+        keywords,
+        _slot,
+        slotId,
+        _tasks2,
+        _iterator5,
+        _step5,
+        instruction,
+        _iterator6,
+        _step6,
+        _loop2,
+        manualMessageObj,
+        now,
+        generatorInput,
+        generatorPayload,
+        _generatorPayload$err,
+        _generatorPayload$err2,
+        _generatorPayload$err3,
+        _generatorPayload$mes,
+        agentMessages,
+        lastAgentMessage,
+        addedMessages,
+        _iterator3,
+        _step3,
+        newMessage,
+        _iterator4,
+        _step4,
+        transformResponse,
+        _agentMessages,
+        _lastAgentMessage,
+        _args3 = arguments;
+      return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _callee$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            onError = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : function () {};
+            customer = input.customer, config = input.config, parser = input.parser, contextualizer = input.contextualizer, workflow = input.workflow, generator = input.generator, transformer = input.transformer, idGenerator = input.idGenerator, _input$progress = input.progress, progress = _input$progress === void 0 ? function (message, level, type, payload) {} : _input$progress, messageBefore = input.message, contextBefore = input.context, messagesBefore = input.messages, conversationBefore = input.conversation;
+            conversation = input.conversation, messages = input.messages, context = input.context, message = input.message; // Storing post process events here
+            followup = [];
+            entityContextUpsert = []; // 0. Setup Helpers
+            updateConversation = function updateConversation(previousConversation, conversationUpdates) {
+              progress('Update conversation', 'info', 'UPDATE_CONVERSATION', conversationUpdates);
+              return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, previousConversation), conversationUpdates);
+            };
+            updateContext = function updateContext(previousContext, newContext) {
+              progress('Update context', 'info', 'UPDATE_CONTEXT', newContext);
+              return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, previousContext), newContext);
+            };
+            userMessages = function userMessages(_messages) {
+              return _messages.filter(function (m) {
+                return m.role === 'customer' || m.role === 'user';
+              });
+            };
+            recentUserMessage = function recentUserMessage(_messages) {
+              var _userMessages = userMessages(_messages);
+              return _userMessages[_userMessages.length - 1];
+            };
+            lockConversation = function lockConversation(_conversation, reason) {
+              return updateConversation(_conversation, {
+                locked: true,
+                lockedReason: conversation.lockedReason || reason || 'Unknown'
+              });
+            };
+            incrementLockAttempt = function incrementLockAttempt(_conversation, _config) {
+              if (typeof _conversation.lockAttempts !== 'number') {
+                _conversation.lockAttempts = 0;
+              }
+              _conversation.lockAttempts++;
+              if (_conversation.lockAttempts > ((_config === null || _config === void 0 ? void 0 : _config.maxLockAttempts) || 3)) {
+                _conversation.locked = true;
+                _conversation.lockedReason = "Max lock attempts exceeded (".concat(_conversation.lockAttempts, " > ").concat((_config === null || _config === void 0 ? void 0 : _config.maxLockAttempts) || 3, ")");
+              }
+              progress('Incremented lock attempt', 'info', 'UPDATE_CONVERSATION', {
+                lockAttempts: _conversation.lockAttempts,
+                locked: _conversation.locked,
+                lockedReason: _conversation.lockedReason || ''
+              });
+              return _conversation;
+            };
+            _addInstruction = function _addInstruction(instruction, _messages, _conversation, _config, previousLockAttempt, id) {
+              var systemMessages = _messages.filter(function (m) {
+                return m.role === 'system';
+              });
+              var lastSystemMessage = systemMessages[systemMessages.length - 1];
+              var addedMessage = false;
+              var changedConversation = false;
+
+              // If instruction does not equal previous system message, add it, otherwise lock attempt
+              if (!lastSystemMessage || instruction !== lastSystemMessage.content) {
+                _messages.push({
+                  id: id,
+                  role: 'system',
+                  content: instruction,
+                  time: new Date().toISOString()
+                });
+                addedMessage = true;
+              } else {
+                // Handle repeated instruction
+                // Increment lock attempt if instructions are repeated and we haven't already incremented lock attempt (for example if a forward is provided)
+                if (previousLockAttempt === (conversation.lockAttempts || 0)) {
+                  _conversation = incrementLockAttempt(_conversation, _config);
+                  changedConversation = true;
+                }
+              }
+              return {
+                conversation: _conversation,
+                messages: _messages,
+                addedMessage: addedMessage,
+                changedConversation: changedConversation
+              };
+            };
+            addInstruction = function addInstruction(instruction, previousLockAttempt) {
+              var id = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : idGenerator('sys');
+              var _addInstruction2 = _addInstruction(instruction, messages, conversation, config, previousLockAttempt, id),
+                newConversation = _addInstruction2.conversation,
+                newMessages = _addInstruction2.messages,
+                addedMessage = _addInstruction2.addedMessage,
+                changedConversation = _addInstruction2.changedConversation;
+              conversation = newConversation;
+              messages = newMessages;
+              if (addedMessage) {
+                progress('Added instruction', 'info', 'ADD_MESSAGE', newMessages[newMessages.length - 1]);
+              }
+              if (changedConversation) {
+                progress('Updated conversation', 'info', 'UPDATE_CONVERSATION', newConversation);
+              }
+            }; // 1. Check inputs
+            if (conversation.$agent) {
+              _context3.next = 15;
+              break;
+            }
+            throw new Error("SpiritsError: No agent found in conversation, must define \".$agent\" in the conversation");
+          case 15:
+            persona = (config.persona || config.personas || config.agents).find(function (p) {
+              return p.id === conversation.$agent;
+            });
+            if (persona) {
+              _context3.next = 20;
+              break;
+            }
+            if (!(config.persona || config.personas || config.agents).some(function (a) {
+              return !a.id;
+            })) {
+              _context3.next = 19;
+              break;
+            }
+            throw new Error("SpiritsError: No persona found (\"".concat(conversation.$agent, "\") in provided config, some persona's did not contain an \"id\" (Internal Mapping Error)"));
+          case 19:
+            throw new Error("SpiritsError: No persona found (\"".concat(conversation.$agent, "\") in provided config"));
+          case 20:
+            if (messages.every(function (m) {
+              return !!m.id;
+            })) {
+              _context3.next = 22;
+              break;
+            }
+            throw new Error("SpiritsError: Every message must have an \".id\", ensure all messages have an id assigned before running");
+          case 22:
+            if (messages.every(function (m) {
+              return m.role === 'customer' || m.role === 'agent' || m.role === 'system' || m.role === 'tool';
+            })) {
+              _context3.next = 25;
+              break;
+            }
+            invalidRoles = messages.filter(function (m) {
+              return m.role !== 'customer' && m.role !== 'agent' && m.role !== 'system' && m.role !== 'tool';
+            });
+            throw new Error("SpiritsError: Every message must have a role of \"customer\", \"agent\", or \"system\". Got invalid roles: ".concat(invalidRoles.map(function (m) {
+              return m.role;
+            }).join(', ')));
+          case 25:
+            // if message is not in messages, then add it
+            if (!messages.find(function (m) {
+              return m.id === input.message.id;
+            })) {
+              messages.push(input.message);
+            }
+
+            // 2. Parse the message
+            progress('Parsing message', 'info', 'SET_PROCESSING', 'user');
+            _context3.next = 29;
+            return parser(message.content, 'en');
+          case 29:
+            parsePayload = _context3.sent;
+            if (parsePayload.intent) {
+              message.intent = parsePayload.intent;
+            }
+            if (typeof parsePayload.intentScore === 'number') {
+              message.intentScore = parsePayload.intentScore;
+            }
+            message.context = parsePayload.context;
+            message.entities = parsePayload.entities;
+            index = messages.findIndex(function (m) {
+              return m.content === message.content || m.id === message.id;
+            });
+            if (index === -1) {
+              _message = {
+                id: idGenerator('customer'),
+                role: 'customer',
+                content: message,
+                context: parsePayload.context,
+                entities: parsePayload.entities,
+                time: new Date().toISOString()
+              };
+              if (parsePayload.intent) {
+                _message.intent = parsePayload.intent;
+              }
+              if (typeof parsePayload.intentScore === 'number') {
+                _message.intentScore = parsePayload.intentScore;
+              }
+              message = _message;
+              messages.push(_message);
+              progress('Added message', 'info', 'ADD_MESSAGE', _message);
+            } else {
+              messages[index].context = parsePayload.context;
+              messages[index].entities = parsePayload.entities;
+              if (parsePayload.intent) {
+                messages[index].intent = parsePayload.intent;
+              }
+              if (typeof parsePayload.intentScore === 'number') {
+                messages[index].intentScore = parsePayload.intentScore;
+              }
+              message = messages[index];
+              progress('Parsed message', 'success', 'UPDATE_MESSAGE', message);
+            }
+            // If this is the first user message, then update conversations intent
+            previousUserMessages = messages.filter(function (m) {
+              return m.role === 'customer' && m.content !== message.content;
+            });
+            if (!conversation.intent || previousUserMessages.length === 0 && parsePayload.intent) {
+              conversation.intent = parsePayload.intent;
+              conversation.intentScore = (parsePayload === null || parsePayload === void 0 ? void 0 : parsePayload.intentScore) || 0;
+              progress('Updated conversation intent', 'info', 'UPDATE_CONVERSATION', {
+                intent: parsePayload.intent,
+                intentScore: (parsePayload === null || parsePayload === void 0 ? void 0 : parsePayload.intentScore) || 0
+              });
+            }
+            oldKeyCount = Object.keys(context).length;
+            context = updateContext(context, parsePayload.context);
+            newKeyCount = Object.keys(context).length;
+            if (!conversation.locked && newKeyCount > oldKeyCount) {
+              // Reset lock attempts
+              conversation.locked = false;
+              conversation.lockAttempts = 0;
+              conversation.lockedReason = '';
+              progress('Reset lock', 'info', 'UPDATE_CONVERSATION', {
+                locked: false,
+                lockAttempts: 0,
+                lockedReason: ''
+              });
+            }
+            noNewContext = Object.keys(parsePayload.context).length === 0; // upsert parse system messages
+            if (parsePayload.contextMessages.length) {
+              (_messages2 = messages).push.apply(_messages2, _rollupPluginBabelHelpers._toConsumableArray(parsePayload.contextMessages.reduce(function (accumulator, text) {
+                if (!messages.find(function (mes) {
+                  return mes.content === text;
+                })) {
+                  accumulator.push({
+                    id: idGenerator('sys'),
+                    role: 'system',
+                    content: text,
+                    time: new Date().toISOString()
+                  });
+                } else {
+                  progress("Already have system context, skipping", 'info');
+                }
+                return accumulator;
+              }, [])));
+            }
+
+            // 3. Run the contextualizer
+            progress('Running contextualizer', 'info', 'SET_PROCESSING', 'system');
+            _context3.next = 47;
+            return contextualizer({
+              conversation: conversation,
+              messages: messages
+            });
+          case 47:
+            newContextMessages = _context3.sent;
+            _iterator = _rollupPluginBabelHelpers._createForOfIteratorHelper(newContextMessages);
+            _context3.prev = 49;
+            _loop = /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _loop() {
+              var contextMessage;
+              return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _loop$(_context) {
+                while (1) switch (_context.prev = _context.next) {
+                  case 0:
+                    contextMessage = _step.value;
+                    if (!messages.find(function (mes) {
+                      return mes.content === contextMessage.content;
+                    })) {
+                      messages.push(contextMessage);
+                      progress("Added context", 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
+                    } else {
+                      progress("Already have system context, skipping", 'info');
+                    }
+                  case 2:
+                  case "end":
+                    return _context.stop();
+                }
+              }, _loop);
+            });
+            _iterator.s();
+          case 52:
+            if ((_step = _iterator.n()).done) {
+              _context3.next = 56;
+              break;
+            }
+            return _context3.delegateYield(_loop(), "t0", 54);
+          case 54:
+            _context3.next = 52;
+            break;
+          case 56:
+            _context3.next = 61;
+            break;
+          case 58:
+            _context3.prev = 58;
+            _context3.t1 = _context3["catch"](49);
+            _iterator.e(_context3.t1);
+          case 61:
+            _context3.prev = 61;
+            _iterator.f();
+            return _context3.finish(61);
+          case 64:
+            // 4. Run the workflow
+            progress('Running workflow', 'info', 'SET_PROCESSING', 'system');
+            _context3.next = 67;
+            return workflow({
+              messages: messages,
+              conversation: conversation,
+              context: context,
+              message: message,
+              agent: persona,
+              customer: customer,
+              intent: {
+                current: ((_recentUserMessage = recentUserMessage(messages)) === null || _recentUserMessage === void 0 ? void 0 : _recentUserMessage.intent) || null,
+                flow: messages.map(function (m) {
+                  return m.intent;
+                }).filter(Boolean),
+                initial: conversation.intent || null
+              },
+              stagnationCount: conversation.lockAttempts || 0
+            }).then(function (res) {
+              return Array.isArray(res) ? res : [res];
+            }).then(function (slots) {
+              return slots.reduce(function (accumulator, slot) {
+                if ('toJSON' in slot) {
+                  var slotJson = slot.toJSON();
+                  accumulator.push.apply(accumulator, _rollupPluginBabelHelpers._toConsumableArray(Array.isArray(slotJson) ? slotJson : [slotJson]));
+                } else {
+                  accumulator.push(slot);
+                }
+                return accumulator;
+              }, []);
+            });
+          case 67:
+            slots = _context3.sent;
+            hasNoInstructions = slots.every(function (s) {
+              return !s.instructions || Array.isArray(s.instructions) && s.instructions.length === 0;
+            });
+            hasNoCustomMessage = slots.every(function (s) {
+              return !s.message;
+            });
+            messagesToTransform = slots.filter(function (s) {
+              return !!s.message && _rollupPluginBabelHelpers._typeof(s.message) === 'object' && !!s.message.transform;
+            });
+            previousLockAttempt = conversation.lockAttempts || 0; // Used to track
+            if (hasNoInstructions && noNewContext) {
+              conversation = incrementLockAttempt(conversation, config);
+            } else {
+              conversation.lockAttempts = 0;
+              conversation.locked = false;
+              conversation.lockedReason = '';
+              progress('Reset lock', 'info', 'UPDATE_CONVERSATION', {
+                lockAttempts: 0,
+                locked: false,
+                lockedReason: ''
+              });
+            }
+            resettedIntent = false;
+            /** @type {Array<string> | undefined} */
+            _iterator2 = _rollupPluginBabelHelpers._createForOfIteratorHelper(slots);
+            _context3.prev = 75;
+            _iterator2.s();
+          case 77:
+            if ((_step2 = _iterator2.n()).done) {
+              _context3.next = 148;
+              break;
+            }
+            _step2$value = _step2.value, forward = _step2$value.forward, forwardNote = _step2$value.forwardNote, instructions = _step2$value.instructions, removeInstructions = _step2$value.removeInstructions, manualMessage = _step2$value.message, scheduled = _step2$value.scheduled, resetIntent = _step2$value.resetIntent, secondsDelay = _step2$value.secondsDelay, contextUpsert = _step2$value.contextUpsert, anticipate = _step2$value.anticipate, slotFollowup = _step2$value.followup, slotEntityContextUpsert = _step2$value.entityContextUpsert, tasks = _step2$value.tasks;
+            if (!anticipate) {
+              _context3.next = 92;
+              break;
+            }
+            if (!Array.isArray(anticipate)) {
+              _context3.next = 87;
+              break;
+            }
+            // 'literal' anticipation
+            _slots = {};
+            map = [];
+            for (i = 0; i < anticipate.length; i++) {
+              _anticipate$i = anticipate[i], keywords = _anticipate$i.keywords, _slot = _rollupPluginBabelHelpers._objectWithoutProperties(_anticipate$i, _excluded);
+              slotId = "".concat(i);
+              _slots[slotId] = _slot;
+              map.push({
+                slot: slotId,
+                keywords: keywords
+              });
+            }
+            updateConversation(conversation, {
+              type: 'literal',
+              slots: _slots,
+              map: map
+            });
+            _context3.next = 92;
+            break;
+          case 87:
+            if (!('yes' in anticipate && 'no' in anticipate && 'did' in anticipate)) {
+              _context3.next = 91;
+              break;
+            }
+            // "did" anticipation
+            updateConversation(conversation, {
+              type: 'did',
+              slots: {
+                yes: anticipate.yes,
+                no: anticipate.no
+              },
+              did: anticipate.did
+            });
+            _context3.next = 92;
+            break;
+          case 91:
+            throw new Error("Invalid anticipate payload \"".concat(JSON.stringify(anticipate), "\""));
+          case 92:
+            // tasks from auto/manual ingress to execute
+            if (!!tasks && Array.isArray(tasks) && !!tasks.length) {
+              if (!_tasks) _tasks = [];
+              (_tasks2 = _tasks).push.apply(_tasks2, _rollupPluginBabelHelpers._toConsumableArray(tasks));
+            }
+            if (slotFollowup) {
+              followup.push(slotFollowup);
+            }
+            if (slotEntityContextUpsert && slotEntityContextUpsert.length) {
+              entityContextUpsert.push.apply(entityContextUpsert, _rollupPluginBabelHelpers._toConsumableArray(slotEntityContextUpsert));
+            }
+
+            // Forward to agent or other agent
+            if (forward) {
+              conversation = lockConversation(conversation, 'App instructed forward');
+              _forward = forward;
+              _forwardNote = forwardNote;
+              if (typeof forward === 'string') {
+                updateConversation(conversation, {
+                  forwarded: forward
+                });
+                messages.push({
+                  id: idGenerator('sys'),
+                  role: 'system',
+                  content: "forwarded to \"".concat(forward, "\""),
+                  time: new Date().toISOString()
+                });
+                progress("Forwarded to \"".concat(forward, "\""), 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
+              } else if (typeof forward === 'boolean') {
+                updateConversation(conversation, {
+                  forwarded: conversation.$agent
+                });
+                messages.push({
+                  id: idGenerator('sys'),
+                  role: 'system',
+                  content: "forwarded to \"".concat(forward, "\""),
+                  time: new Date().toISOString()
+                });
+                progress("Forwarded to agent", 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
+              } else {
+                messages.push({
+                  id: idGenerator('sys'),
+                  role: 'system',
+                  content: "forwarded to \"".concat(forward.to, "\" ").concat(forward.mode ? ' (' + forward.mode + ')' : ''),
+                  time: new Date().toISOString()
+                });
+                progress("Forwarded to \"".concat(forward.to, "\" ").concat(forward.mode ? ' (' + forward.mode + ')' : ''), 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
+                updateConversation(conversation, {
+                  forwarded: forward.to
+                });
+              }
+            }
+
+            // Insert instructions context
+            if (!instructions) {
+              _context3.next = 111;
+              break;
+            }
+            if (!(typeof instructions === 'string')) {
+              _context3.next = 101;
+              break;
+            }
+            addInstruction(instructions, previousLockAttempt);
+            _context3.next = 111;
+            break;
+          case 101:
+            if (!Array.isArray(instructions)) {
+              _context3.next = 106;
+              break;
+            }
+            _iterator5 = _rollupPluginBabelHelpers._createForOfIteratorHelper(instructions);
+            try {
+              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                instruction = _step5.value;
+                if (typeof instruction === 'string') {
+                  addInstruction(instruction, previousLockAttempt);
+                } else {
+                  addInstruction(instruction.content, previousLockAttempt, instruction.id);
+                }
+              }
+            } catch (err) {
+              _iterator5.e(err);
+            } finally {
+              _iterator5.f();
+            }
+            _context3.next = 111;
+            break;
+          case 106:
+            if (!(_rollupPluginBabelHelpers._typeof(instructions) === 'object' && 'content' in instructions)) {
+              _context3.next = 110;
+              break;
+            }
+            addInstruction(instructions.content, previousLockAttempt, instructions.id);
+            _context3.next = 111;
+            break;
+          case 110:
+            throw new Error("SpiritsError: instructions must be a string or array or {content: \"<instruction>\"}, got: ".concat(JSON.stringify(instructions)));
+          case 111:
+            if (!removeInstructions) {
+              _context3.next = 128;
+              break;
+            }
+            _iterator6 = _rollupPluginBabelHelpers._createForOfIteratorHelper(removeInstructions);
+            _context3.prev = 113;
+            _loop2 = /*#__PURE__*/_rollupPluginBabelHelpers._regeneratorRuntime().mark(function _loop2() {
+              var instructionId, index;
+              return _rollupPluginBabelHelpers._regeneratorRuntime().wrap(function _loop2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    instructionId = _step6.value;
+                    index = messages.findIndex(function (m) {
+                      return m.id === instructionId;
+                    });
+                    if (index > -1) {
+                      messages.splice(index, 1);
+                      progress('Remove instruction', 'info', 'REMOVE_MESSAGE', instructionId);
+                    } else {
+                      console.log("Instruction not found \"".concat(instructionId, "\", other ids: ").concat(messages.map(function (m) {
+                        return "\"".concat(m.id, "\"");
+                      }).join(', ')));
+                    }
+                  case 3:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _loop2);
+            });
+            _iterator6.s();
+          case 116:
+            if ((_step6 = _iterator6.n()).done) {
+              _context3.next = 120;
+              break;
+            }
+            return _context3.delegateYield(_loop2(), "t2", 118);
+          case 118:
+            _context3.next = 116;
+            break;
+          case 120:
+            _context3.next = 125;
+            break;
+          case 122:
+            _context3.prev = 122;
+            _context3.t3 = _context3["catch"](113);
+            _iterator6.e(_context3.t3);
+          case 125:
+            _context3.prev = 125;
+            _iterator6.f();
+            return _context3.finish(125);
+          case 128:
+            if (!manualMessage) {
+              _context3.next = 144;
+              break;
+            }
+            /** @type {import('@scout9/admin').Message} */
+            manualMessageObj = {
+              id: idGenerator('persona'),
+              role: 'agent',
+              // @TODO switch role to persona
+              content: '',
+              time: new Date().toISOString()
+            };
+            if (!(_rollupPluginBabelHelpers._typeof(manualMessage) === 'object')) {
+              _context3.next = 136;
+              break;
+            }
+            Object.assign(manualMessageObj, manualMessage);
+            manualMessageObj.role = 'agent';
+            manualMessageObj.time = new Date().toISOString();
+            _context3.next = 141;
+            break;
+          case 136:
+            if (!(typeof manualMessage === 'string')) {
+              _context3.next = 140;
+              break;
+            }
+            manualMessageObj.content = manualMessage;
+            _context3.next = 141;
+            break;
+          case 140:
+            throw new Error('Manual message must be of type "string" or "DirectMessage"');
+          case 141:
+            if (scheduled) {
+              manualMessageObj.time = new Date(scheduled * 1000).toISOString();
+              manualMessageObj.scheduled = manualMessageObj.time;
+            } else if (secondsDelay) {
+              now = new Date();
+              now.setSeconds(now.getSeconds() + secondsDelay);
+              manualMessageObj.time = now.toISOString();
+              manualMessageObj.delayInSeconds = secondsDelay;
+            }
+            messages.push(manualMessageObj);
+            progress('Added manual message', 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
+          case 144:
+            if (contextUpsert) {
+              context = updateContext(context, contextUpsert);
+              progress('Upserted context', 'info', 'UPDATE_CONTEXT', contextUpsert);
+            }
+            if (resetIntent) {
+              resettedIntent = true;
+            }
+          case 146:
+            _context3.next = 77;
+            break;
+          case 148:
+            _context3.next = 153;
+            break;
+          case 150:
+            _context3.prev = 150;
+            _context3.t4 = _context3["catch"](75);
+            _iterator2.e(_context3.t4);
+          case 153:
+            _context3.prev = 153;
+            _iterator2.f();
+            return _context3.finish(153);
+          case 156:
+            if (resettedIntent && !_forward) {
+              conversation.intent = null;
+              conversation.intentScore = null;
+              conversation.locked = false;
+              conversation.lockedReason = '';
+              conversation.lockAttempts = 0;
+              progress('Reset conversation intent', 'info', 'UPDATE_CONVERSATION', {
+                intent: null,
+                intentScore: null,
+                locked: false,
+                lockAttempts: 0,
+                lockedReason: ''
+              });
+            }
+
+            // 5. Generate response
+            // If conversation previously locked, don't generate
+            if (input.conversation.locked) {
+              _context3.next = 208;
+              break;
+            }
+            if (!((!conversation.locked || !hasNoInstructions) && !!hasNoCustomMessage)) {
+              _context3.next = 174;
+              break;
+            }
+            _context3.prev = 159;
+            progress('Generating message', 'info', 'SET_PROCESSING', 'system');
+
+            /** @type {import('@scout9/admin').GenerateRequestOneOf1} */
+            generatorInput = {
+              messages: messages,
+              persona: persona,
+              context: context,
+              llm: config.llm,
+              pmt: config.pmt
+            };
+            if (!!_tasks && Array.isArray(_tasks) && !!_tasks.length) {
+              generatorInput.tasks = _tasks;
+            }
+            _context3.next = 165;
+            return generator(generatorInput);
+          case 165:
+            generatorPayload = _context3.sent;
+            if (!generatorPayload.send) {
+              progress('Generated response', 'failed', undefined, {
+                error: ((_generatorPayload$err = generatorPayload.errors) === null || _generatorPayload$err === void 0 ? void 0 : _generatorPayload$err.join('\n\n')) || 'Unknown Reason'
+              });
+              console.error("Locking conversation, api returned send false: ".concat(generatorPayload.messages), ((_generatorPayload$err2 = generatorPayload.errors) === null || _generatorPayload$err2 === void 0 ? void 0 : _generatorPayload$err2.join('\n\n')) || generatorPayload.forwardNote || 'Unknown Reason');
+              conversation = lockConversation(conversation, 'API: ' + ((_generatorPayload$err3 = generatorPayload.errors) === null || _generatorPayload$err3 === void 0 ? void 0 : _generatorPayload$err3.join('\n\n')) || generatorPayload.forwardNote || 'Unknown Reason');
+            } else {
+              progress('Generated response', 'success', undefined, undefined);
+              // Check if already had message
+              agentMessages = messages.filter(function (m) {
+                return m.role === 'agent';
+              });
+              lastAgentMessage = agentMessages[agentMessages.length - 1]; // Build addedMessages from generatorPayload.messages
+              addedMessages = ((_generatorPayload$mes = generatorPayload === null || generatorPayload === void 0 ? void 0 : generatorPayload.messages) !== null && _generatorPayload$mes !== void 0 ? _generatorPayload$mes : []).map(function (message) {
+                // Normalize time → ISO string
+                var t = message.time;
+                var isoTime;
+                if (typeof t === "string") {
+                  isoTime = t;
+                } else if (t instanceof Date) {
+                  isoTime = t.toISOString();
+                } else if (t && typeof t.toDate === "function") {
+                  // Firestore Timestamp
+                  isoTime = t.toDate().toISOString();
+                } else {
+                  progress("Message \"".concat(message.content, "\" wasn't given a usable timestamp (").concat(JSON.stringify(t), "), defaulting to now"));
+                  isoTime = new Date().toISOString();
+                }
+
+                // Base fields we guarantee
+                var base = {
+                  role: message.role,
+                  content: message.content,
+                  id: idGenerator(message.role),
+                  time: isoTime
+                };
+
+                // Copy any other non-nullish fields without overwriting base
+                return Object.entries(message).reduce(function (acc, _ref) {
+                  var _ref2 = _rollupPluginBabelHelpers._slicedToArray(_ref, 2),
+                    key = _ref2[0],
+                    value = _ref2[1];
+                  if (!Object.prototype.hasOwnProperty.call(acc, key) && value != null) {
+                    acc[key] = value;
+                  }
+                  return acc;
+                }, base);
+              })
+              // De-dupe by content (change the key if you want stricter uniqueness)
+              .reduce(function (acc, msg) {
+                var key = String(msg.content); // e.g. `${msg.role}::${msg.content}` for stronger uniqueness
+                if (!acc.seen.has(key)) {
+                  acc.seen.add(key);
+                  acc.items.push(msg);
+                }
+                return acc;
+              }, {
+                seen: new Set(),
+                items: []
+              }).items;
+              if (lastAgentMessage && lastAgentMessage.content && addedMessages.some(function (message) {
+                return message.content === lastAgentMessage.content;
+              })) {
+                // Error should not have happened
+                conversation = lockConversation(conversation, 'Duplicate message');
+              } else {
+                _iterator3 = _rollupPluginBabelHelpers._createForOfIteratorHelper(addedMessages);
+                try {
+                  for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                    newMessage = _step3.value;
+                    messages.push(newMessage);
+                    progress('Added agent message', 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
+                  }
+                } catch (err) {
+                  _iterator3.e(err);
+                } finally {
+                  _iterator3.f();
+                }
+              }
+
+              // Check if conversation was marked for forward (generator message still allowed to be sent)
+              if (generatorPayload.forward) {
+                conversation = lockConversation(conversation, 'API: ' + generatorPayload.forwardNote || 'Forwarded by API');
+                if (!_forward) {
+                  _forward = generatorPayload.forward;
+                  _forwardNote = generatorPayload.forwardNote;
+                }
+              }
+            }
+            _context3.next = 174;
+            break;
+          case 169:
+            _context3.prev = 169;
+            _context3.t5 = _context3["catch"](159);
+            onError(_context3.t5);
+            console.error("Spirits: Locking conversation, error generating response: ".concat(_context3.t5.message));
+            conversation = lockConversation(conversation, 'API: ' + _context3.t5.message);
+          case 174:
+            if (!(messagesToTransform.length && transformer)) {
+              _context3.next = 207;
+              break;
+            }
+            _context3.prev = 175;
+            _iterator4 = _rollupPluginBabelHelpers._createForOfIteratorHelper(messagesToTransform);
+            _context3.prev = 177;
+            _iterator4.s();
+          case 179:
+            if ((_step4 = _iterator4.n()).done) {
+              _context3.next = 190;
+              break;
+            }
+            _step4.value;
+            _context3.next = 183;
+            return transformer({
+              message: messagesToTransform,
+              persona: persona,
+              customer: customer.id,
+              messages: messages,
+              context: context
+            });
+          case 183:
+            transformResponse = _context3.sent;
+            progress('Generated response', 'success', undefined, undefined);
+            // Check if already had message
+            _agentMessages = messages.filter(function (m) {
+              return m.role === 'agent';
+            });
+            _lastAgentMessage = _agentMessages[_agentMessages.length - 1];
+            if (_lastAgentMessage && _lastAgentMessage.content === transformResponse.message) {
+              // Error should not have happened
+              conversation = lockConversation(conversation, 'Duplicate message');
+            } else {
+              messages.push({
+                id: idGenerator('agent'),
+                role: 'agent',
+                content: transformResponse.message,
+                time: new Date().toISOString()
+              });
+              progress('Added agent message', 'info', 'ADD_MESSAGE', messages[messages.length - 1]);
+            }
+          case 188:
+            _context3.next = 179;
+            break;
+          case 190:
+            _context3.next = 195;
+            break;
+          case 192:
+            _context3.prev = 192;
+            _context3.t6 = _context3["catch"](177);
+            _iterator4.e(_context3.t6);
+          case 195:
+            _context3.prev = 195;
+            _iterator4.f();
+            return _context3.finish(195);
+          case 198:
+            _context3.next = 205;
+            break;
+          case 200:
+            _context3.prev = 200;
+            _context3.t7 = _context3["catch"](175);
+            console.error("Locking conversation, error transforming response: ".concat(_context3.t7.message));
+            conversation = lockConversation(conversation, 'API: ' + _context3.t7.message);
+            onError(_context3.t7);
+          case 205:
+            _context3.next = 208;
+            break;
+          case 207:
+            if (messagesToTransform.length) {
+              console.warn("No transformer provided");
+            }
+          case 208:
+            progress('Parsing message', 'info', 'SET_PROCESSING', null);
+            return _context3.abrupt("return", {
+              conversation: {
+                before: conversationBefore,
+                after: conversation,
+                forward: _forward || null,
+                forwardNote: _forwardNote || ''
+              },
+              messages: {
+                before: messagesBefore,
+                after: messages
+              },
+              message: {
+                before: messageBefore,
+                after: message
+              },
+              context: {
+                before: contextBefore,
+                after: context
+              },
+              followup: followup,
+              entityContextUpsert: entityContextUpsert
+            });
+          case 210:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee, null, [[49, 58, 61, 64], [75, 150, 153, 156], [113, 122, 125, 128], [159, 169], [175, 200], [177, 192, 195, 198]]);
+    }));
+    function customer(_x) {
+      return _customer.apply(this, arguments);
+    }
+    return customer;
+  }()
+};
+
+exports.Spirits = Spirits;