@carbon/ai-chat 0.4.0-rc.2 → 0.4.0-rc.3

package/dist/es/chat/shared/events/ChatActionsImpl.js

@@ -1,783 +0,0 @@
-import cloneDeep from "lodash-es/cloneDeep.js";
-
-import isEqual from "lodash-es/isEqual.js";
-
-import merge from "lodash-es/merge.js";
-
-import inputItemToLocalItem from "../schema/inputItemToLocalItem.js";
-
-import { outputItemToLocalItem, createLocalMessageItemsForNestedMessageItems } from "../schema/outputItemToLocalItem.js";
-
-import { AgentsOnlineStatus } from "../../../types/config/ServiceDeskConfig.js";
-
-import actions from "../store/actions.js";
-
-import { agentUpdateIsSuspended } from "../store/agentActions.js";
-
-import { DEFAULT_PERSISTED_TO_BROWSER, VIEW_STATE_LAUNCHER_OPEN } from "../store/reducerUtils.js";
-
-import "../../../types/state/AppState.js";
-
-import { arrayLastValue, asyncForEach } from "../utils/lang/arrayUtils.js";
-
-import { deepFreeze } from "../utils/lang/objectUtils.js";
-
-import { sleep } from "../utils/lang/promiseUtils.js";
-
-import { uuid } from "../utils/lang/uuid.js";
-
-import { createWelcomeRequest, isLiveAgentMessage, isRequest, createMessageRequestForText, addDefaultsToMessage, isResponse, createMessageResponseForText, isStreamCompleteItem, isStreamPartialItem, isStreamFinalResponse, renderAsUserDefinedMessage, isResponseWithNestedItems, streamItemID, isPause, isConnectToAgent, hasTourUserDefinedType, hasServiceDesk, isTyping } from "../utils/messageUtils.js";
-
-import { debugLog, isEnableDebugLog, consoleError, consoleWarn, callOnError } from "../utils/miscUtils.js";
-
-import { resolvablePromise } from "../utils/resolvablePromise.js";
-
-import { mergeCSSVariables } from "../utils/styleUtils.js";
-
-import { constructViewState, validateViewState } from "../utils/viewStateUtils.js";
-
-import { MessageResponseTypes } from "../../../types/messaging/Messages.js";
-
-import { BusEventType, MessageSendSource, TourStartReason, MainWindowCloseReason, ViewChangeReason, MainWindowOpenReason } from "../../../types/events/eventBusTypes.js";
-
-import { CSSVariable } from "../../../types/instance/ChatInstance.js";
-
-import { OnErrorType } from "../../../types/config/PublicConfig.js";
-
-import { setIntl } from "../utils/intlUtils.js";
-
-import { UUIDType } from "../utils/lang/UUIDType.js";
-
-import { ViewType } from "../../../types/instance/apiTypes.js";
-
-/*
- *  Copyright IBM Corp. 2025
- *
- *  This source code is licensed under the Apache-2.0 license found in the
- *  LICENSE file in the root directory of this source tree.
- *
- *  @license
- */ const VALID_PUBLIC_VARS_IN_AI_THEME_SET = new Set(Object.values(CSSVariable));
-
-const UPDATE_CSS_VARS_AI_THEME_WARNING_MESSAGE = `[updateCSSVariables] The AI theme is enabled and only ${Object.values(CSSVariable).join(", ")} can be updated.`;
-
-class ChatActionsImpl {
-  constructor(serviceManager) {
-    this.hydrating = false;
-    this.restarting = false;
-    this.alreadyHydrated = false;
-    this.chunkQueue = [];
-    this.serviceManager = serviceManager;
-  }
-  async hydrateChat(alternateWelcomeRequest, alternateWelcomeRequestSource, alternateOptions) {
-    let fireReady = false;
-    try {
-      if (!this.hydrationPromise) {
-        this.hydrating = true;
-        this.hydrationPromise = this.doHydrateChat(alternateWelcomeRequest, alternateWelcomeRequestSource, alternateOptions);
-        fireReady = true;
-      }
-      await this.hydrationPromise;
-    } finally {
-      this.hydrating = false;
-    }
-    if (fireReady) {
-      await this.serviceManager.fire({
-        type: BusEventType.CHAT_READY
-      });
-    }
-  }
-  async doHydrateChat(alternateWelcomeRequest, alternateWelcomeRequestSource, alternateOptions) {
-    debugLog("Hydrating Carbon AI chat", alternateWelcomeRequest, alternateWelcomeRequestSource, alternateOptions);
-    let history;
-    const {serviceManager: serviceManager} = this;
-    serviceManager.store.dispatch(actions.addIsHydratingCounter(1));
-    if (!this.alreadyHydrated) {
-      history = await this.serviceManager.historyService.loadHistory();
-      if (serviceManager.humanAgentService) {
-        debugLog("Initializing the human agent service");
-        await serviceManager.humanAgentService.initialize();
-      } else {
-        debugLog("No service desk integrations present");
-      }
-    }
-    const {config: config} = serviceManager.store.getState();
-    if (!history) {
-      if (!alternateWelcomeRequest) {
-        const state = serviceManager.store.getState();
-        if (state.homeScreenConfig?.is_on) {
-          serviceManager.store.dispatch(actions.setHomeScreenIsOpen(true));
-        } else if (!config.public.messaging?.skipWelcome) {
-          await serviceManager.actions.send(createWelcomeRequest(), MessageSendSource.WELCOME_REQUEST, {
-            returnBeforeStreaming: true
-          }, true);
-        }
-      }
-    } else {
-      serviceManager.store.dispatch(actions.hydrateMessageHistory(history.messageHistory));
-      await this.createElementsForUserDefinedResponses(history.messageHistory);
-      if (history.latestPanelLocalMessageItem) {
-        this.openResponsePanel(history.latestPanelLocalMessageItem, true);
-      }
-    }
-    if (alternateWelcomeRequest) {
-      serviceManager.store.dispatch(actions.setHomeScreenIsOpen(false));
-      await serviceManager.actions.send(alternateWelcomeRequest, alternateWelcomeRequestSource, alternateOptions, true);
-    }
-    serviceManager.store.dispatch(actions.chatWasHydrated());
-    serviceManager.store.dispatch(actions.addIsHydratingCounter(-1));
-    if (history) {
-      const lastMessageID = arrayLastValue(history.messageHistory.botMessageState.localMessageIDs);
-      const lastMessage = history.messageHistory.allMessageItemsByID[lastMessageID];
-      const lastOriginalMessage = history.messageHistory.allMessagesByID[lastMessage?.fullMessageID];
-      if (!isLiveAgentMessage(lastMessage) && isRequest(lastOriginalMessage)) {
-        serviceManager.messageService.resendMessage(lastOriginalMessage, lastMessage.ui_state.id);
-      }
-    }
-    const allowReconnect = config.public.serviceDesk.allowReconnect ?? true;
-    this.serviceManager?.humanAgentService?.handleHydration(allowReconnect, Boolean(history));
-    this.alreadyHydrated = true;
-  }
-  getPublicWebChatState() {
-    const state = this.serviceManager.store.getState();
-    const {persistedToBrowserStorage: persistedToBrowserStorage} = state;
-    const {chatState: chatState, launcherState: launcherState} = persistedToBrowserStorage;
-    const publicWebChatState = {
-      isConnectedWithHumanAgent: chatState.agentState.isConnected,
-      isWebChatOpen: launcherState.viewState.mainWindow,
-      isConnectingWithHumanAgent: state.agentState.isConnecting,
-      isHomeScreenOpen: chatState.homeScreenState.isHomeScreenOpen,
-      isDebugEnabled: isEnableDebugLog(),
-      hasUserSentMessage: chatState.hasSentNonWelcomeMessage,
-      isTourActive: launcherState.activeTour,
-      viewState: {
-        ...launcherState.viewState
-      },
-      serviceDesk: {
-        isConnected: chatState.agentState.isConnected,
-        isConnecting: state.agentState.isConnecting,
-        isSuspended: chatState.agentState.isSuspended ?? false
-      },
-      locale: this.serviceManager.store.getState().locale,
-      intl: this.serviceManager.intl
-    };
-    return publicWebChatState;
-  }
-  async sendWithCatch(message, source, options = {}, ignoreHydration = false) {
-    try {
-      await this.send(message, source, options, ignoreHydration);
-    } catch (error) {
-      consoleError("An error occurred sending the message", error);
-    }
-  }
-  async send(message, source, options = {}, ignoreHydration = false) {
-    const messageRequest = typeof message === "string" ? createMessageRequestForText(message) : message;
-    if (this.serviceManager.store.getState().persistedToBrowserStorage.chatState.homeScreenState.isHomeScreenOpen) {
-      this.serviceManager.store.dispatch(actions.setHomeScreenIsOpen(false));
-    }
-    if (this.serviceManager.store.getState().responsePanelState.isOpen) {
-      this.serviceManager.store.dispatch(actions.setResponsePanelIsOpen(false));
-    }
-    if (this.hydrationPromise || ignoreHydration) {
-      if (!ignoreHydration) {
-        await this.hydrationPromise;
-      }
-      await this.doSend(messageRequest, source, options);
-    } else {
-      await this.hydrateChat(messageRequest, source, options);
-    }
-  }
-  async doSend(message, source, options = {}) {
-    const {store: store} = this.serviceManager;
-    addDefaultsToMessage(message);
-    const originalUserText = message.history?.label || message.input.text;
-    if (options.silent) {
-      message.history.silent = true;
-    }
-    const localMessage = inputItemToLocalItem(message, originalUserText);
-    if (!message.history.silent) {
-      store.dispatch(actions.addLocalMessageItem(localMessage, message, true));
-    } else {
-      store.dispatch(actions.addMessage(message));
-    }
-    if (options.setValueSelectedForMessageID) {
-      store.dispatch(actions.messageSetOptionSelected(options.setValueSelectedForMessageID, message));
-    }
-    deepFreeze(message);
-    await this.serviceManager.messageService.send(cloneDeep(message), source, localMessage.ui_state.id, options);
-  }
-  async receive(message, isLatestWelcomeNode = false, requestMessage, requestOptions) {
-    const {restartCount: initialRestartCount} = this.serviceManager;
-    if (!message.id) {
-      message.id = uuid(UUIDType.MESSAGE);
-    }
-    const preReceiveEvent = {
-      type: BusEventType.PRE_RECEIVE,
-      data: message
-    };
-    await this.serviceManager.fire(preReceiveEvent);
-    if (initialRestartCount !== this.serviceManager.restartCount) {
-      return;
-    }
-    if (!isLatestWelcomeNode) {
-      this.serviceManager.store.dispatch(actions.updateHasSentNonWelcomeMessage(true));
-    }
-    if (initialRestartCount !== this.serviceManager.restartCount) {
-      return;
-    }
-    const {languagePack: languagePack} = this.serviceManager.store.getState();
-    if (isResponse(message)) {
-      this.processMessageResponse(message, isLatestWelcomeNode, requestMessage, requestOptions).catch(error => {
-        consoleError("Error processing the message response", error);
-      });
-    } else {
-      const inlineError = createMessageResponseForText(languagePack.errors_singleMessage, message.thread_id, MessageResponseTypes.INLINE_ERROR);
-      this.receive(inlineError, false);
-    }
-    deepFreeze(message);
-    await this.serviceManager.fire({
-      type: BusEventType.RECEIVE,
-      data: message
-    });
-  }
-  async removeMessages(messageIDs) {
-    this.serviceManager.store.dispatch(actions.removeMessages(messageIDs));
-  }
-  async insertHistory(messages) {
-    const scrollBottom = this.serviceManager.mainWindow?.getMessagesScrollBottom();
-    const state = this.serviceManager.store.getState();
-    const notes = {
-      notes: [ {
-        body: messages
-      } ]
-    };
-    const history = await this.serviceManager.historyService.loadHistory(notes);
-    const currentAppStateMessages = {
-      allMessageItemsByID: state.allMessageItemsByID,
-      allMessagesByID: state.allMessagesByID,
-      botMessageState: state.botMessageState
-    };
-    const newAppStateMessages = merge({}, history.messageHistory, currentAppStateMessages);
-    newAppStateMessages.botMessageState.messageIDs = [ ...history.messageHistory.botMessageState.messageIDs, ...currentAppStateMessages.botMessageState.messageIDs ];
-    newAppStateMessages.botMessageState.localMessageIDs = [ ...history.messageHistory.botMessageState.localMessageIDs, ...currentAppStateMessages.botMessageState.localMessageIDs ];
-    this.serviceManager.store.dispatch(actions.hydrateMessageHistory(newAppStateMessages));
-    await this.createElementsForUserDefinedResponses(history.messageHistory);
-    this.serviceManager.mainWindow?.doAutoScroll({
-      scrollToBottom: scrollBottom
-    });
-  }
-  async receiveChunk(chunk, messageID, options = {}) {
-    const chunkPromise = resolvablePromise();
-    this.chunkQueue.push({
-      chunk: chunk,
-      messageID: messageID,
-      options: options,
-      chunkPromise: chunkPromise
-    });
-    if (this.chunkQueue.length === 1) {
-      this.processChunkQueue();
-    }
-    return chunkPromise;
-  }
-  async processChunkQueue() {
-    const {chunk: chunk, options: options, chunkPromise: chunkPromise} = this.chunkQueue[0];
-    let {messageID: messageID} = this.chunkQueue[0];
-    const isCompleteItem = isStreamCompleteItem(chunk);
-    const isPartialItem = isStreamPartialItem(chunk);
-    const {store: store} = this.serviceManager;
-    const isStopGeneratingVisible = store.getState().botInputState.stopStreamingButtonState.isVisible;
-    if (isPartialItem) {
-      const streamingData = chunk.partial_item.streaming_metadata;
-      if (streamingData.cancellable && !isStopGeneratingVisible) {
-        store.dispatch(actions.setStopStreamingButtonVisible(true));
-      }
-    }
-    if (isCompleteItem || isPartialItem) {
-      if (!messageID) {
-        messageID = chunk.streaming_metadata.response_id;
-      }
-      if (!store.getState().allMessagesByID[messageID]) {
-        store.dispatch(actions.streamingStart(messageID));
-      }
-      const item = chunk.partial_item || chunk.complete_item;
-      store.dispatch(actions.streamingAddChunk(messageID, item, isCompleteItem, options.disableFadeAnimation ?? true));
-      if (chunk.partial_response?.history) {
-        if (Object.keys(chunk.partial_response).length > 1) {
-          throw new Error(`The partial_response object only supports the "history" property.`);
-        }
-        store.dispatch(actions.streamingMergeHistory(messageID, chunk.partial_response?.history));
-      }
-      await this.handleUserDefinedResponseItemsChunk(messageID, chunk, item);
-    } else if (isStreamFinalResponse(chunk)) {
-      this.receive(chunk.final_response, options.isLatestWelcomeNode, null, {
-        disableFadeAnimation: true
-      });
-    }
-    if ((isCompleteItem || isStreamFinalResponse(chunk)) && isStopGeneratingVisible) {
-      store.dispatch(actions.setStopStreamingButtonDisabled(false));
-      store.dispatch(actions.setStopStreamingButtonVisible(false));
-    }
-    this.chunkQueue.shift();
-    chunkPromise.doResolve();
-    if (this.chunkQueue[0]) {
-      this.processChunkQueue();
-    }
-  }
-  getOrCreateUserDefinedElement(messageItemID) {
-    let userDefinedItem = this.serviceManager.userDefinedElementRegistry.get(messageItemID);
-    if (!userDefinedItem) {
-      userDefinedItem = {
-        element: document.createElement("div"),
-        slotName: `slot-user-defined-${uuid()}`
-      };
-      userDefinedItem.element.setAttribute("slot", userDefinedItem.slotName);
-      this.serviceManager.userDefinedElementRegistry.set(messageItemID, userDefinedItem);
-    }
-    return userDefinedItem;
-  }
-  async handleUserDefinedResponseItems(localMessage, originalMessage) {
-    if (renderAsUserDefinedMessage(localMessage.item)) {
-      let element;
-      let slotName;
-      if (!localMessage.item.user_defined?.silent) {
-        ({element: element, slotName: slotName} = this.getOrCreateUserDefinedElement(localMessage.ui_state.id));
-      }
-      const userDefinedResponseEvent = {
-        type: BusEventType.USER_DEFINED_RESPONSE,
-        data: {
-          message: localMessage.item,
-          fullMessage: originalMessage,
-          element: element,
-          slot: slotName,
-          fullWidth: false
-        }
-      };
-      await this.serviceManager.fire(userDefinedResponseEvent);
-      if (userDefinedResponseEvent.data.fullWidth) {
-        this.serviceManager.store.dispatch(actions.setMessageUIProperty(localMessage.ui_state.id, "fullWidth", true));
-      }
-    } else if (isResponseWithNestedItems(localMessage.item)) {
-      const {itemsLocalMessageItemIDs: itemsLocalMessageItemIDs, bodyLocalMessageItemIDs: bodyLocalMessageItemIDs, footerLocalMessageItemIDs: footerLocalMessageItemIDs, gridLocalMessageItemIDs: gridLocalMessageItemIDs} = localMessage.ui_state;
-      const {allMessageItemsByID: allMessageItemsByID} = this.serviceManager.store.getState();
-      const createElementForNestedUserDefinedResponse = localMessageItemID => {
-        const nestedLocalMessage = allMessageItemsByID[localMessageItemID];
-        return this.handleUserDefinedResponseItems(nestedLocalMessage, originalMessage);
-      };
-      if (gridLocalMessageItemIDs?.length) {
-        await asyncForEach(gridLocalMessageItemIDs, row => asyncForEach(row, cell => asyncForEach(cell, itemID => createElementForNestedUserDefinedResponse(itemID))));
-      }
-      if (itemsLocalMessageItemIDs?.length) {
-        await asyncForEach(itemsLocalMessageItemIDs, createElementForNestedUserDefinedResponse);
-      }
-      if (bodyLocalMessageItemIDs?.length) {
-        await asyncForEach(bodyLocalMessageItemIDs, createElementForNestedUserDefinedResponse);
-      }
-      if (footerLocalMessageItemIDs?.length) {
-        await asyncForEach(footerLocalMessageItemIDs, createElementForNestedUserDefinedResponse);
-      }
-    }
-  }
-  async handleUserDefinedResponseItemsChunk(messageID, chunk, messageItem) {
-    if (renderAsUserDefinedMessage(messageItem)) {
-      const {store: store} = this.serviceManager;
-      const itemID = streamItemID(messageID, messageItem);
-      let element;
-      let slotName;
-      if (!messageItem.user_defined?.silent) {
-        ({element: element, slotName: slotName} = this.getOrCreateUserDefinedElement(itemID));
-      }
-      const userDefinedResponseEvent = {
-        type: BusEventType.CHUNK_USER_DEFINED_RESPONSE,
-        data: {
-          messageItem: messageItem,
-          chunk: chunk,
-          element: element,
-          slot: slotName,
-          fullWidth: false
-        }
-      };
-      await this.serviceManager.fire(userDefinedResponseEvent);
-      if (store.getState().allMessageItemsByID[itemID].ui_state.fullWidth !== userDefinedResponseEvent.data.fullWidth) {
-        store.dispatch(actions.setMessageUIProperty(itemID, "fullWidth", userDefinedResponseEvent.data.fullWidth));
-      }
-    }
-  }
-  async processMessageResponse(fullMessage, isLatestWelcomeNode, requestMessage, requestOptions = {}) {
-    const {store: store} = this.serviceManager;
-    const {config: config} = store.getState();
-    const initialRestartCount = this.serviceManager.restartCount;
-    const output = fullMessage.output.generic;
-    fullMessage.request_id = requestMessage?.id;
-    addDefaultsToMessage(fullMessage);
-    store.dispatch(actions.addMessage(fullMessage));
-    let previousItemID = null;
-    for (let index = 0; index < output.length && initialRestartCount === this.serviceManager.restartCount; index++) {
-      const messageItem = output[index];
-      if (messageItem) {
-        const pause = isPause(messageItem);
-        const agent = isConnectToAgent(messageItem);
-        const tour = hasTourUserDefinedType(messageItem);
-        const localMessageItem = outputItemToLocalItem(messageItem, fullMessage, isLatestWelcomeNode, requestOptions.disableFadeAnimation);
-        if (tour && (requestOptions.skipTourCard || messageItem.user_defined?.skip_card)) {
-          const startTourReason = requestOptions.skipTourCard ? TourStartReason.START_TOUR_METHOD : TourStartReason.SKIP_CARD;
-          const {viewState: viewState} = store.getState().persistedToBrowserStorage.launcherState;
-          if (viewState.mainWindow) {
-            const mainWindowCloseReason = requestOptions.skipTourCard ? MainWindowCloseReason.CALLED_START_TOUR : MainWindowCloseReason.TOUR_SKIP_CARD;
-            this.startTour(localMessageItem, startTourReason, {
-              mainWindowCloseReason: mainWindowCloseReason
-            }).catch(error => {
-              consoleError("Error starting the tour", error);
-            });
-          } else {
-            const viewChangeReason = requestOptions.skipTourCard ? ViewChangeReason.CALLED_START_TOUR : ViewChangeReason.TOUR_SKIP_CARD;
-            this.startTour(localMessageItem, startTourReason, {
-              viewChangeReason: viewChangeReason
-            }).catch(error => {
-              consoleError("Error starting the tour", error);
-            });
-          }
-        } else if (!tour && requestOptions.skipTourCard) {
-          consoleError("The message response received was not a tour, so the tour card was not skipped nor was a tour started by the startTour() call.");
-        }
-        const nestedLocalMessageItems = [];
-        createLocalMessageItemsForNestedMessageItems(localMessageItem, fullMessage, false, nestedLocalMessageItems, true);
-        store.dispatch(actions.addNestedMessages(nestedLocalMessageItems));
-        if (agent && isResponse(fullMessage)) {
-          store.dispatch(actions.addIsTypingCounter(1));
-          if (!hasServiceDesk(config)) {
-            const message = 'Web chat received a "connect_to_agent" message but there is no service desk configured. Check your chat configuration.';
-            this.errorOccurred({
-              errorType: OnErrorType.INTEGRATION_ERROR,
-              message: message
-            });
-            store.dispatch(actions.setMessageHistoryProperty(localMessageItem.fullMessageID, "agent_no_service_desk", true));
-          }
-          const agentAvailability = await (this.serviceManager.humanAgentService?.checkAreAnyAgentsOnline(fullMessage));
-          if (initialRestartCount === this.serviceManager.restartCount) {
-            store.dispatch(actions.setMessageHistoryProperty(localMessageItem.fullMessageID, "agent_availability", agentAvailability));
-            let shouldAutoRequestAgent = false;
-            if (config.public.serviceDesk?.skipConnectAgentCard) {
-              shouldAutoRequestAgent = true;
-            }
-            store.dispatch(actions.addIsTypingCounter(-1));
-            if (shouldAutoRequestAgent && agentAvailability === AgentsOnlineStatus.ONLINE) {
-              this.serviceManager.humanAgentService.startChat(localMessageItem, fullMessage);
-            }
-          }
-        }
-        if (pause) {
-          const showIsTyping = isTyping(messageItem);
-          if (showIsTyping) {
-            store.dispatch(actions.addIsTypingCounter(1));
-          }
-          await sleep(messageItem.time);
-          if (showIsTyping && initialRestartCount === this.serviceManager.restartCount) {
-            store.dispatch(actions.addIsTypingCounter(-1));
-          }
-        } else {
-          await this.handleUserDefinedResponseItems(localMessageItem, fullMessage);
-          if (!localMessageItem.item.user_defined?.silent && initialRestartCount === this.serviceManager.restartCount) {
-            this.serviceManager.store.dispatch(actions.addLocalMessageItem(localMessageItem, fullMessage, false, previousItemID));
-            previousItemID = localMessageItem.ui_state.id;
-          }
-        }
-      }
-    }
-  }
-  openResponsePanel(localMessageItem, isMessageForInput) {
-    this.serviceManager.store.dispatch(actions.setResponsePanelContent(localMessageItem, isMessageForInput));
-    this.serviceManager.store.dispatch(actions.setResponsePanelIsOpen(true));
-  }
-  async insertLocalMessageResponse(message) {
-    message.id = uuid(UUIDType.MESSAGE);
-    await this.processMessageResponse(message, false, null, {});
-  }
-  updateLanguagePack(changes) {
-    const {languagePack: languagePack, locale: locale} = this.serviceManager.store.getState();
-    const messages = {
-      ...languagePack,
-      ...changes
-    };
-    setIntl(this.serviceManager, locale, messages);
-  }
-  addNotification(notification) {
-    this.serviceManager.store.dispatch(actions.addNotification(notification));
-  }
-  removeNotification(groupID) {
-    this.serviceManager.store.dispatch(actions.removeNotifications({
-      groupID: groupID
-    }));
-  }
-  removeAllNotifications() {
-    this.serviceManager.store.dispatch(actions.removeAllNotifications());
-  }
-  updateCSSVariables(publicVars, whiteLabelVariables = {}) {
-    const {store: store} = this.serviceManager;
-    const {theme: theme} = store.getState();
-    const {carbonTheme: carbonTheme, useAITheme: useAITheme} = theme;
-    if (useAITheme) {
-      const usePublicVars = publicVars;
-      publicVars = {};
-      whiteLabelVariables = {};
-      usePublicVars && Object.entries(usePublicVars).forEach(([variable]) => {
-        if (VALID_PUBLIC_VARS_IN_AI_THEME_SET.has(variable)) {
-          publicVars[variable] = usePublicVars[variable];
-        } else {
-          consoleWarn(UPDATE_CSS_VARS_AI_THEME_WARNING_MESSAGE);
-        }
-      });
-    } else {
-      publicVars = {
-        ...publicVars
-      };
-      whiteLabelVariables = {
-        ...whiteLabelVariables
-      };
-    }
-    const allVariables = mergeCSSVariables(publicVars, whiteLabelVariables, carbonTheme, useAITheme);
-    store.dispatch(actions.updateCSSVariables(allVariables, publicVars, whiteLabelVariables));
-  }
-  updateBotName(name) {
-    this.serviceManager.store.dispatch(actions.updateBotName(name));
-  }
-  updateMainHeaderTitle(title) {
-    this.serviceManager.store.dispatch(actions.updateMainHeaderTitle(title));
-  }
-  updateBotAvatarURL(url) {
-    this.serviceManager.store.dispatch(actions.updateBotAvatarURL(url));
-  }
-  updateHomeScreenConfig(homeScreenConfig) {
-    this.serviceManager.store.dispatch(actions.updateHomeScreenConfig(homeScreenConfig));
-  }
-  updateLauncherConfig(launcherConfig) {
-    this.serviceManager.store.dispatch(actions.updateLauncherConfig(launcherConfig));
-  }
-  async changeView(newView, reason, tryHydrating = true, forceViewChange = false) {
-    const {store: store} = this.serviceManager;
-    const {viewState: viewState} = store.getState().persistedToBrowserStorage.launcherState;
-    let newViewState = constructViewState(newView, store.getState());
-    if (!validateViewState(newViewState, store.getState())) {
-      return viewState;
-    }
-    if (!isEqual(newViewState, viewState) || forceViewChange) {
-      await this.fireViewChangeEventsAndChangeView(newViewState, reason);
-      newViewState = store.getState().persistedToBrowserStorage.launcherState.viewState;
-      if (tryHydrating && (newViewState.mainWindow || newViewState.tour) && !store.getState().isHydrated) {
-        this.hydrateChat().catch(error => {
-          consoleError("Error hydrating the chat", error);
-        });
-      }
-    }
-    return newViewState;
-  }
-  async fireViewChangeEventsAndChangeView(newViewState, reason) {
-    const {store: store} = this.serviceManager;
-    if (store.getState().viewChanging) {
-      throw new Error("The view may not be changed while a view change event is already running. Please make sure to resolve any promises from these events.");
-    }
-    store.dispatch(actions.setViewChanging(true));
-    const {viewState: viewState} = store.getState().persistedToBrowserStorage.launcherState;
-    const {viewChangeReason: viewChangeReason} = reason;
-    const oldViewState = deepFreeze(viewState);
-    try {
-      const preViewChangeEvent = {
-        type: BusEventType.VIEW_PRE_CHANGE,
-        reason: viewChangeReason,
-        oldViewState: oldViewState,
-        newViewState: newViewState,
-        cancelViewChange: false
-      };
-      await this.serviceManager.fire(preViewChangeEvent);
-      if (preViewChangeEvent.cancelViewChange) {
-        debugLog("The view changing was cancelled by a view:pre:change event.");
-        return;
-      }
-      if (!validateViewState(preViewChangeEvent.newViewState, store.getState())) {
-        return;
-      }
-      newViewState = preViewChangeEvent.newViewState;
-      store.dispatch(actions.setViewState(deepFreeze(newViewState)));
-      const viewChangeEvent = {
-        type: BusEventType.VIEW_CHANGE,
-        reason: viewChangeReason,
-        oldViewState: oldViewState,
-        newViewState: newViewState,
-        cancelViewChange: false
-      };
-      await this.serviceManager.fire(viewChangeEvent);
-      if (viewChangeEvent.cancelViewChange) {
-        store.dispatch(actions.setViewState(oldViewState));
-        debugLog("The view changing was cancelled by a view:change event.");
-        return;
-      }
-      if (!validateViewState(viewChangeEvent.newViewState, store.getState())) {
-        store.dispatch(actions.setViewState(oldViewState));
-        return;
-      }
-      newViewState = viewChangeEvent.newViewState;
-      store.dispatch(actions.setViewState(deepFreeze(newViewState)));
-    } finally {
-      store.dispatch(actions.setViewChanging(false));
-    }
-  }
-  async startTour(message, startTourReason, changeViewReason) {
-    this.serviceManager.store.dispatch(actions.setTourData(message.fullMessageID));
-    const newViewState = await this.changeView(ViewType.TOUR, changeViewReason);
-    if (newViewState.tour) {
-      await this.serviceManager.fire({
-        type: BusEventType.TOUR_START,
-        reason: startTourReason
-      });
-      await this.serviceManager.fire({
-        type: BusEventType.TOUR_STEP,
-        step: this.serviceManager.store.getState().tourState.activeTourStepItems[0]
-      });
-    }
-  }
-  async endTour(reason) {
-    const {viewState: viewState} = this.serviceManager.store.getState().persistedToBrowserStorage.launcherState;
-    let newViewState = viewState;
-    if (viewState.tour) {
-      newViewState = await this.changeView(ViewType.LAUNCHER, reason);
-    }
-    if (!newViewState.tour) {
-      this.serviceManager.store.dispatch(actions.clearTourData());
-      return true;
-    }
-    return false;
-  }
-  goToSpecificTourStep(stepId) {
-    const {activeTourStepItems: activeTourStepItems} = this.serviceManager.store.getState().tourState;
-    const newStepIndex = activeTourStepItems.findIndex(stepItem => stepItem.step_id === stepId);
-    if (newStepIndex) {
-      this.changeStepInTour({
-        newStepIndex: newStepIndex
-      });
-    } else {
-      consoleError(`No step with the id "${stepId}" was found within the current tour. As a result, goToTourStep() did not change the current tour step.`);
-    }
-  }
-  async changeStepInTour(changeStepOptions) {
-    const {store: store} = this.serviceManager;
-    const {activeTourStepItems: activeTourStepItems} = store.getState().tourState;
-    const {activeTourCurrentStepIndex: activeTourCurrentStepIndex} = store.getState().persistedToBrowserStorage.chatState.persistedTourState;
-    let {newStepIndex: newStepIndex} = changeStepOptions;
-    if (changeStepOptions.nextStep) {
-      newStepIndex = activeTourCurrentStepIndex + 1;
-    } else if (changeStepOptions.previousStep) {
-      newStepIndex = activeTourCurrentStepIndex - 1;
-    }
-    store.dispatch(actions.changeStepInTour(newStepIndex));
-    const actualNewStepIndex = store.getState().persistedToBrowserStorage.chatState.persistedTourState.activeTourCurrentStepIndex;
-    if (actualNewStepIndex === newStepIndex) {
-      await this.serviceManager.fire({
-        type: BusEventType.TOUR_STEP,
-        step: activeTourStepItems[actualNewStepIndex]
-      });
-    } else {
-      consoleWarn("The tour tried to change to a step that was out of bounds for the step array, so no step change was made.");
-    }
-  }
-  errorOccurred(error) {
-    consoleError("An error has occurred", error);
-    if (error.catastrophicErrorType) {
-      this.serviceManager.store.dispatch(actions.setAppStateValue("catastrophicErrorType", error.catastrophicErrorType));
-    }
-    callOnError(this.serviceManager.additionalChatParameters.onError, error);
-  }
-  async restartConversation(options = {}) {
-    const {skipHydration: skipHydration = false, endAgentConversation: endAgentConversation = true, fireEvents: fireEvents = true} = options;
-    debugLog("Restarting conversation");
-    if (this.restarting) {
-      consoleWarn("You cannot restart a conversation while a previous restart is still pending.");
-      return;
-    }
-    this.restarting = true;
-    try {
-      const {serviceManager: serviceManager} = this;
-      const {store: store} = serviceManager;
-      if (fireEvents) {
-        await serviceManager.fire({
-          type: BusEventType.PRE_RESTART_CONVERSATION
-        });
-      }
-      serviceManager.restartCount++;
-      if (this.hydrating) {
-        await this.hydrationPromise;
-      }
-      const currentState = store.getState();
-      const {persistedToBrowserStorage: persistedToBrowserStorage} = currentState;
-      const {viewState: viewState} = persistedToBrowserStorage.launcherState;
-      const {isConnecting: isConnecting} = currentState.agentState;
-      const {isConnected: isConnected} = currentState.persistedToBrowserStorage.chatState.agentState;
-      if ((isConnected || isConnecting) && endAgentConversation) {
-        await serviceManager.humanAgentService.endChat(true, false, false);
-      }
-      if (viewState.tour) {
-        await this.serviceManager.actions.changeView(ViewType.MAIN_WINDOW, {
-          mainWindowOpenReason: MainWindowOpenReason.CALLED_RESTART_CONVERSATION
-        }, false);
-      }
-      this.serviceManager.instance.updateAssistantInputFieldVisibility(true);
-      this.serviceManager.messageService.cancelAllMessageRequests();
-      store.dispatch(actions.restartConversation());
-      if (!skipHydration) {
-        this.hydrationPromise = null;
-      }
-      if (fireEvents) {
-        await serviceManager.fire({
-          type: BusEventType.RESTART_CONVERSATION
-        });
-      }
-      if (this.hydrating) {
-        await this.hydrationPromise;
-      }
-      if (!skipHydration && !serviceManager.store.getState().isHydrated) {
-        this.hydrationPromise = null;
-        if (store.getState().persistedToBrowserStorage.launcherState.viewState.mainWindow) {
-          await serviceManager.actions.hydrateChat();
-        }
-      } else {
-        store.dispatch(actions.chatWasHydrated());
-      }
-    } finally {
-      this.restarting = false;
-    }
-  }
-  async destroySession(keepOpenState) {
-    const {store: store} = this.serviceManager;
-    const {persistedToBrowserStorage: persistedToBrowserStorage} = store.getState();
-    const originalViewState = persistedToBrowserStorage.launcherState.viewState;
-    const newPersistedToBrowserStorage = cloneDeep(DEFAULT_PERSISTED_TO_BROWSER);
-    if (keepOpenState) {
-      newPersistedToBrowserStorage.launcherState.viewState = originalViewState;
-      if (originalViewState.tour) {
-        newPersistedToBrowserStorage.launcherState.viewState = {
-          ...originalViewState,
-          tour: false,
-          mainWindow: true
-        };
-      }
-    } else {
-      newPersistedToBrowserStorage.launcherState.viewState = VIEW_STATE_LAUNCHER_OPEN;
-    }
-    this.serviceManager.messageService.cancelAllMessageRequests();
-    this.serviceManager.userSessionStorageService.clearLauncherSession();
-    this.serviceManager.userSessionStorageService.clearChatSession();
-    this.serviceManager.store.dispatch(actions.setAppStateValue("persistedToBrowserStorage", newPersistedToBrowserStorage));
-  }
-  agentEndConversation(endedByUser) {
-    return this.serviceManager.humanAgentService.endChat(endedByUser);
-  }
-  agentUpdateIsSuspended(isSuspended) {
-    this.serviceManager.store.dispatch(agentUpdateIsSuspended(isSuspended));
-  }
-  async createElementsForUserDefinedResponses(messages) {
-    await asyncForEach(Object.values(messages.allMessageItemsByID), localMessage => {
-      const originalMessage = messages.allMessagesByID[localMessage.fullMessageID];
-      return this.handleUserDefinedResponseItems(localMessage, originalMessage);
-    });
-  }
-}
-
-export { ChatActionsImpl };