@carbon/ai-chat 0.1.6 → 0.1.7-alpha0

package/dist/cjs/HumanAgentServiceImpl.js

@@ -13,38 +13,46 @@ is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND
 or implied. See the License for the specific language governing permissions and limitations under
 the License.
 
-@carbon/ai-chat 0.1.6
+@carbon/ai-chat 0.1.7-alpha0
 
-Built: Feb 3 2025 9:58 am -05:00
+Built: Feb 12 2025 9:14 am -05:00
 
 
 
 */
 'use strict';
 
-var cdsAichatInternal = require('./cds-aichat-internal.js');
+var AppContainer = require('./AppContainer.js');
 var agentActions = require('./agentActions.js');
-require('lit');
-require('lit/decorators.js');
 require('react');
-require('react-dom');
 require('./highlight_js.js');
 require('@carbon/react');
+require('classnames');
 require('react-intl');
 require('react-redux');
+require('tabbable');
+require('@carbon/icons-react');
 require('./markdown.js');
-require('./markdown_attrs.js');
+require('tslib');
+require('lit');
+require('lit/decorators.js');
 require('@carbon/web-components/es/components/button/index.js');
 require('@carbon/web-components/es/components/overflow-menu/index.js');
 require('lit/directives/unsafe-html.js');
+require('prop-types');
 require('@carbon/web-components/es/components/slug/index.js');
 require('@carbon/web-components/es/components/popover/defs.js');
 require('@carbon/web-components/es/components/slug/defs.js');
+require('@floating-ui/react');
+require('react-dom');
 require('@carbon/web-components/es/components/slug/slug-action-button.js');
 require('@carbon/web-components/es/components/slug/slug.js');
+require('@carbon/web-components/es/components/inline-loading/index.js');
+require('@carbon/icon-helpers');
+require('@carbon/icons');
+require('lit/directives/unsafe-svg.js');
 require('@carbon/web-components/es/components/textarea/index.js');
 require('@carbon/web-components/es/components/icon-button/index.js');
-require('lit/directives/unsafe-svg.js');
 require('@carbon/web-components/es/components/tag/index.js');
 require('@carbon/web-components/es/components/chat-button/index.js');
 require('@carbon/web-components/es/components/button/button.js');
@@ -132,7 +140,7 @@ const AVAILABILITY_TIMEOUT_MS = 5000;
  * The amount of time to wait before displaying the "bot returns" message.
  */
 const BOT_RETURN_DELAY = 1500;
-const { FROM_USER, RECONNECTED, DISCONNECTED, AGENT_ENDED_CHAT, AGENT_JOINED, USER_ENDED_CHAT, CHAT_WAS_ENDED, TRANSFER_TO_AGENT, AGENT_LEFT_CHAT, RELOAD_WARNING, SHARING_CANCELLED, SHARING_DECLINED, SHARING_ACCEPTED, SHARING_REQUESTED, SHARING_ENDED, } = cdsAichatInternal.AgentMessageType;
+const { FROM_USER, RECONNECTED, DISCONNECTED, AGENT_ENDED_CHAT, AGENT_JOINED, USER_ENDED_CHAT, CHAT_WAS_ENDED, TRANSFER_TO_AGENT, AGENT_LEFT_CHAT, RELOAD_WARNING, SHARING_CANCELLED, SHARING_DECLINED, SHARING_ACCEPTED, SHARING_REQUESTED, SHARING_ENDED, } = AppContainer.AgentMessageType;
 class HumanAgentServiceImpl {
     constructor(serviceManager) {
         /**
@@ -178,7 +186,7 @@ class HumanAgentServiceImpl {
         const { store, instance } = this.serviceManager;
         const state = store.getState();
         const { config, persistedToBrowserStorage } = state;
-        const serviceDeskState = cdsAichatInternal.cloneDeep(persistedToBrowserStorage.chatState.agentState.serviceDeskState);
+        const serviceDeskState = AppContainer.cloneDeep(persistedToBrowserStorage.chatState.agentState.serviceDeskState);
         this.serviceDeskCallback = new ServiceDeskCallbackImpl(this.serviceManager, this);
         if (config.public.serviceDeskFactory) {
             // A custom service desk factory was provided so use that to create the service desk.
@@ -189,35 +197,35 @@ class HumanAgentServiceImpl {
             };
             this.serviceDesk = await config.public.serviceDeskFactory(parameters);
             validateCustomServiceDesk(this.serviceDesk);
-            cdsAichatInternal.debugLog('Initializing a custom service desk');
+            AppContainer.debugLog('Initializing a custom service desk');
         }
         else {
             const { initConfig, mainConfig } = config.remote;
             const { serviceDesk } = config.public;
             const integrationType = serviceDesk.integrationType || initConfig.service_desk.integration_type;
             switch (integrationType) {
-                case cdsAichatInternal.BuiltInServiceDesk.ZENDESK: {
+                case AppContainer.BuiltInServiceDesk.ZENDESK: {
                     const sdConfig = mainConfig.service_desk;
                     const { ZendeskServiceDesk } = await Promise.resolve().then(function () { return require(
                     /* webpackChunkName: 'zendesk' */ './ZendeskServiceDesk.js'); });
                     this.serviceDesk = new ZendeskServiceDesk(this.serviceDeskCallback, sdConfig, this.serviceManager);
                     break;
                 }
-                case cdsAichatInternal.BuiltInServiceDesk.SALES_FORCE: {
-                    const regionHostname = cdsAichatInternal.getRegionHostname(config.public);
+                case AppContainer.BuiltInServiceDesk.SALES_FORCE: {
+                    const regionHostname = AppContainer.getRegionHostname(config.public);
                     const sdConfig = mainConfig.service_desk;
                     const { SFServiceDesk } = await Promise.resolve().then(function () { return require(
                     /* webpackChunkName: 'salesforce' */ './SFServiceDesk.js'); });
                     this.serviceDesk = new SFServiceDesk(this.serviceDeskCallback, sdConfig, regionHostname, this.serviceManager);
                     break;
                 }
-                case cdsAichatInternal.BuiltInServiceDesk.NICE_DFO: {
+                case AppContainer.BuiltInServiceDesk.NICE_DFO: {
                     const { NiceDFOServiceDesk } = await Promise.resolve().then(function () { return require(
                     /* webpackChunkName: 'nice' */ './NiceDFOServiceDesk.js'); });
                     this.serviceDesk = new NiceDFOServiceDesk(this.serviceDeskCallback, serviceDesk.niceDFO, this.serviceManager);
                     break;
                 }
-                case cdsAichatInternal.BuiltInServiceDesk.GENESYS_MESSENGER: {
+                case AppContainer.BuiltInServiceDesk.GENESYS_MESSENGER: {
                     const sdConfig = serviceDesk.genesysMessenger;
                     const { GenesysMessengerServiceDesk } = await Promise.resolve().then(function () { return require(
                     /* webpackChunkName: 'genesys' */ './GenesysMessengerServiceDesk.js'); });
@@ -227,7 +235,7 @@ class HumanAgentServiceImpl {
                 default:
                     throw new Error(`Invalid service desk type: "${integrationType}"`);
             }
-            cdsAichatInternal.debugLog(`Initializing built-in service desk ${integrationType}`);
+            AppContainer.debugLog(`Initializing built-in service desk ${integrationType}`);
         }
         // If the service desk supports reconnecting, we don't need to show this warning.
         this.showLeaveWarning = !this.serviceDesk?.reconnect;
@@ -308,10 +316,10 @@ class HumanAgentServiceImpl {
             });
         }
         catch (error) {
-            cdsAichatInternal.consoleError('[startChat] An error with the service desk occurred.', error);
+            AppContainer.consoleError('[startChat] An error with the service desk occurred.', error);
             // If it failed to start, then stop connecting and clear the service desk.
             if (this.serviceDeskCallback) {
-                await this.serviceDeskCallback.setErrorStatus({ type: cdsAichatInternal.ErrorType.CONNECTING, logInfo: error });
+                await this.serviceDeskCallback.setErrorStatus({ type: AppContainer.ErrorType.CONNECTING, logInfo: error });
             }
             serviceManager.store.dispatch(agentActions.setIsConnecting(false, null));
             this.chatStarted = false;
@@ -378,7 +386,7 @@ class HumanAgentServiceImpl {
         if (isConnected && !skipEndMessages) {
             // Display the "end chat" messages.
             const messageType = endedByUser ? USER_ENDED_CHAT : CHAT_WAS_ENDED;
-            await cdsAichatInternal.addEndChatMessages(messageType, null, BOT_RETURN_DELAY, true, wasSuspended, this.serviceManager);
+            await AppContainer.addEndChatMessages(messageType, null, BOT_RETURN_DELAY, true, wasSuspended, this.serviceManager);
         }
     }
     /**
@@ -387,12 +395,12 @@ class HumanAgentServiceImpl {
     async doEndChat(endedByAgent, preEndChatPayload) {
         const { isConnected } = this.persistedAgentState();
         this.cancelAgentJoinedTimer();
-        this.closeScreenShareRequestModal(cdsAichatInternal.ScreenShareState.CANCELLED);
+        this.closeScreenShareRequestModal(AppContainer.ScreenShareState.CANCELLED);
         try {
-            await cdsAichatInternal.resolveOrTimeout(this.serviceDesk.endChat({ endedByAgent, preEndChatPayload }), END_CHAT_TIMEOUT_MS);
+            await AppContainer.resolveOrTimeout(this.serviceDesk.endChat({ endedByAgent, preEndChatPayload }), END_CHAT_TIMEOUT_MS);
         }
         catch (error) {
-            cdsAichatInternal.consoleError('[doEndChat] An error with the service desk occurred.', error);
+            AppContainer.consoleError('[doEndChat] An error with the service desk occurred.', error);
         }
         this.chatStarted = false;
         this.isAgentTyping = false;
@@ -412,8 +420,8 @@ class HumanAgentServiceImpl {
             return;
         }
         const { serviceManager } = this;
-        cdsAichatInternal.deepFreeze(uploads);
-        const originalMessage = cdsAichatInternal.createMessageRequestForText(text);
+        AppContainer.deepFreeze(uploads);
+        const originalMessage = AppContainer.createMessageRequestForText(text);
         originalMessage.input.agent_message_type = FROM_USER;
         // Fire the pre:send event that will allow code to customize the message.
         await serviceManager.fire({ type: "agent:pre:send" /* BusEventType.AGENT_PRE_SEND */, data: originalMessage, files: uploads });
@@ -422,19 +430,19 @@ class HumanAgentServiceImpl {
         const localMessageID = textMessage.ui_state.id;
         const pairs = [];
         if (textMessage.item.text) {
-            pairs.push(cdsAichatInternal.toPair([textMessage], originalMessage));
+            pairs.push(AppContainer.toPair([textMessage], originalMessage));
         }
         // Add a message for each file upload.
         uploads.forEach(upload => {
             // Note that we're going to reuse the file ID for the MessageRequest and LocalMessage to make it easier to
             // locate the objects when we need to update their states.
-            const uploadOriginalMessage = cdsAichatInternal.createMessageRequestForFileUpload(upload);
+            const uploadOriginalMessage = AppContainer.createMessageRequestForFileUpload(upload);
             const uploadLocalMessage = agentActions.inputItemToLocalItem(uploadOriginalMessage, uploadOriginalMessage.input.text, upload.id);
-            pairs.push(cdsAichatInternal.toPair([uploadLocalMessage], uploadOriginalMessage));
+            pairs.push(AppContainer.toPair([uploadLocalMessage], uploadOriginalMessage));
             this.uploadingFiles.add(upload.id);
         });
         this.serviceManager.store.dispatch(agentActions.updateFilesUploadInProgress(this.uploadingFiles.size > 0));
-        await cdsAichatInternal.addMessages(pairs, true, true, !this.isSuspended(), serviceManager);
+        await AppContainer.addMessages(pairs, true, true, !this.isSuspended(), serviceManager);
         // Track when a message from the user is sent to human agent.
         const trackProps = {
             eventName: 'Human Message Received from User',
@@ -447,12 +455,12 @@ class HumanAgentServiceImpl {
         let messageFailed = false;
         setTimeout(() => {
             if (!messageSucceeded && !messageFailed) {
-                this.setMessageErrorState(textMessage.fullMessageID, cdsAichatInternal.MessageErrorState.RETRYING);
+                this.setMessageErrorState(textMessage.fullMessageID, AppContainer.MessageErrorState.RETRYING);
             }
         }, SEND_TIMEOUT_WARNING_MS);
         setTimeout(() => {
             if (!messageSucceeded) {
-                this.setMessageErrorState(textMessage.fullMessageID, cdsAichatInternal.MessageErrorState.FAILED);
+                this.setMessageErrorState(textMessage.fullMessageID, AppContainer.MessageErrorState.FAILED);
             }
         }, SEND_TIMEOUT_ERROR_MS);
         const additionalData = {
@@ -462,13 +470,13 @@ class HumanAgentServiceImpl {
             // Send the message to the service desk.
             await this.serviceDesk.sendMessageToAgent(originalMessage, localMessageID, additionalData);
             messageSucceeded = true;
-            this.setMessageErrorState(textMessage.fullMessageID, cdsAichatInternal.MessageErrorState.NONE);
+            this.setMessageErrorState(textMessage.fullMessageID, AppContainer.MessageErrorState.NONE);
             await serviceManager.fire({ type: "agent:send" /* BusEventType.AGENT_SEND */, data: originalMessage, files: uploads });
         }
         catch (error) {
             messageFailed = true;
-            cdsAichatInternal.consoleError('[sendMessageToAgent] An error with the service desk occurred.', error);
-            this.setMessageErrorState(textMessage.fullMessageID, cdsAichatInternal.MessageErrorState.FAILED);
+            AppContainer.consoleError('[sendMessageToAgent] An error with the service desk occurred.', error);
+            this.setMessageErrorState(textMessage.fullMessageID, AppContainer.MessageErrorState.FAILED);
         }
     }
     /**
@@ -484,7 +492,7 @@ class HumanAgentServiceImpl {
             this.serviceDesk.filesSelectedForUpload?.(uploads);
         }
         catch (error) {
-            cdsAichatInternal.consoleError('[userReadMessages] An error with the service desk occurred.', error);
+            AppContainer.consoleError('[userReadMessages] An error with the service desk occurred.', error);
         }
     }
     /**
@@ -499,7 +507,7 @@ class HumanAgentServiceImpl {
             await this.serviceDesk.userReadMessages();
         }
         catch (error) {
-            cdsAichatInternal.consoleError('[userReadMessages] An error with the service desk occurred.', error);
+            AppContainer.consoleError('[userReadMessages] An error with the service desk occurred.', error);
         }
     }
     /**
@@ -513,28 +521,28 @@ class HumanAgentServiceImpl {
         let resultValue;
         const initialRestartCount = this.serviceManager.restartCount;
         if (!this.serviceDesk?.areAnyAgentsOnline) {
-            resultValue = cdsAichatInternal.AgentsOnlineStatus.UNKNOWN;
+            resultValue = AppContainer.AgentsOnlineStatus.UNKNOWN;
         }
         else {
             try {
                 const timeoutSeconds = this.serviceManager.store.getState().config.public.serviceDesk?.availabilityTimeoutSeconds;
                 const timeout = timeoutSeconds ? timeoutSeconds * 1000 : AVAILABILITY_TIMEOUT_MS;
-                const result = await cdsAichatInternal.resolveOrTimeout(this.serviceDesk.areAnyAgentsOnline(connectMessage), timeout);
+                const result = await AppContainer.resolveOrTimeout(this.serviceDesk.areAnyAgentsOnline(connectMessage), timeout);
                 if (result === true) {
-                    resultValue = cdsAichatInternal.AgentsOnlineStatus.ONLINE;
+                    resultValue = AppContainer.AgentsOnlineStatus.ONLINE;
                 }
                 else if (result === false) {
-                    resultValue = cdsAichatInternal.AgentsOnlineStatus.OFFLINE;
+                    resultValue = AppContainer.AgentsOnlineStatus.OFFLINE;
                 }
                 else {
                     // Any other value for result will return an unknown status.
-                    resultValue = cdsAichatInternal.AgentsOnlineStatus.UNKNOWN;
+                    resultValue = AppContainer.AgentsOnlineStatus.UNKNOWN;
                 }
             }
             catch (error) {
-                cdsAichatInternal.consoleError('Error attempting to get agent availability', error);
+                AppContainer.consoleError('Error attempting to get agent availability', error);
                 // If we fail to get an answer we'll just return false to indicate that no agents are available.
-                resultValue = cdsAichatInternal.AgentsOnlineStatus.OFFLINE;
+                resultValue = AppContainer.AgentsOnlineStatus.OFFLINE;
             }
         }
         if (initialRestartCount === this.serviceManager.restartCount) {
@@ -560,7 +568,7 @@ class HumanAgentServiceImpl {
             await this.serviceDesk.userTyping?.(isTyping);
         }
         catch (error) {
-            cdsAichatInternal.consoleError('[userTyping] An error with the service desk occurred.', error);
+            AppContainer.consoleError('[userTyping] An error with the service desk occurred.', error);
         }
     }
     /**
@@ -571,7 +579,7 @@ class HumanAgentServiceImpl {
      * @param errorState The state to set of the message.
      */
     setMessageErrorState(messageID, errorState) {
-        this.serviceManager.store.dispatch(cdsAichatInternal.actions.setMessageErrorState(messageID, errorState));
+        this.serviceManager.store.dispatch(AppContainer.actions.setMessageErrorState(messageID, errorState));
     }
     /**
      * This is called when an agent fails to join a chat after a given period of time.
@@ -579,8 +587,8 @@ class HumanAgentServiceImpl {
     async handleAgentJoinedTimeout() {
         // Display an error to the user.
         const message = this.serviceManager.store.getState().languagePack.errors_noAgentsJoined;
-        const { originalMessage, localMessage } = cdsAichatInternal.createLocalMessageForInlineError(message);
-        await cdsAichatInternal.addMessages([cdsAichatInternal.toPair([localMessage], originalMessage)], true, false, !this.isSuspended(), this.serviceManager);
+        const { originalMessage, localMessage } = AppContainer.createLocalMessageForInlineError(message);
+        await AppContainer.addMessages([AppContainer.toPair([localMessage], originalMessage)], true, false, !this.isSuspended(), this.serviceManager);
         // End the chat.
         this.endChat(false);
     }
@@ -607,16 +615,16 @@ class HumanAgentServiceImpl {
         this.closeScreenShareRequestModal(state);
         let agentMessageType;
         switch (state) {
-            case cdsAichatInternal.ScreenShareState.ACCEPTED:
+            case AppContainer.ScreenShareState.ACCEPTED:
                 agentMessageType = SHARING_ACCEPTED;
                 break;
-            case cdsAichatInternal.ScreenShareState.DECLINED:
+            case AppContainer.ScreenShareState.DECLINED:
                 agentMessageType = SHARING_DECLINED;
                 break;
-            case cdsAichatInternal.ScreenShareState.CANCELLED:
+            case AppContainer.ScreenShareState.CANCELLED:
                 agentMessageType = SHARING_CANCELLED;
                 break;
-            case cdsAichatInternal.ScreenShareState.ENDED:
+            case AppContainer.ScreenShareState.ENDED:
                 agentMessageType = SHARING_ENDED;
                 break;
             default:
@@ -651,7 +659,7 @@ class HumanAgentServiceImpl {
                     didReconnect = await this.serviceDesk.reconnect();
                 }
                 catch (error) {
-                    cdsAichatInternal.consoleError(`Error while trying to reconnect to an agent.`, error);
+                    AppContainer.consoleError(`Error while trying to reconnect to an agent.`, error);
                 }
             }
             store.dispatch(agentActions.setIsReconnecting(false));
@@ -668,7 +676,7 @@ class HumanAgentServiceImpl {
                 store.dispatch(agentActions.endChat());
                 if (allowEndChatMessages) {
                     // If we didn't reconnect, then show the "end chat" messages to the user.
-                    await cdsAichatInternal.addEndChatMessages(cdsAichatInternal.AgentMessageType.CHAT_WAS_ENDED, null, 0, false, wasSuspended, this.serviceManager);
+                    await AppContainer.addEndChatMessages(AppContainer.AgentMessageType.CHAT_WAS_ENDED, null, 0, false, wasSuspended, this.serviceManager);
                 }
             }
             else {
@@ -687,7 +695,7 @@ class HumanAgentServiceImpl {
             this.screenShareRequestPromise.doResolve(state);
             this.screenShareRequestPromise = null;
         }
-        this.serviceManager.store.dispatch(agentActions.setIsScreenSharing(state === cdsAichatInternal.ScreenShareState.ACCEPTED));
+        this.serviceManager.store.dispatch(agentActions.setIsScreenSharing(state === AppContainer.ScreenShareState.ACCEPTED));
     }
     /**
      * Adds a local agent message.
@@ -696,8 +704,8 @@ class HumanAgentServiceImpl {
         if (!agentProfile) {
             agentProfile = this.persistedAgentState().agentProfile;
         }
-        const { localMessage, originalMessage } = await cdsAichatInternal.createAgentLocalMessage(agentMessageType, this.serviceManager, agentProfile, fireEvents);
-        await cdsAichatInternal.addMessages([cdsAichatInternal.toPair([localMessage], originalMessage)], saveInHistory, false, !this.isSuspended(), this.serviceManager);
+        const { localMessage, originalMessage } = await AppContainer.createAgentLocalMessage(agentMessageType, this.serviceManager, agentProfile, fireEvents);
+        await AppContainer.addMessages([AppContainer.toPair([localMessage], originalMessage)], saveInHistory, false, !this.isSuspended(), this.serviceManager);
     }
     /**
      * Returns the persisted agent state from the store.
@@ -728,7 +736,7 @@ class ServiceDeskCallbackImpl {
      * @param capabilities The set of capabilities to update. Only properties that need to be changed need to be included.
      */
     updateCapabilities(capabilities) {
-        this.serviceManager.store.dispatch(agentActions.updateCapabilities(cdsAichatInternal.cloneDeep(capabilities)));
+        this.serviceManager.store.dispatch(agentActions.updateCapabilities(AppContainer.cloneDeep(capabilities)));
     }
     /**
      * Sends updated availability information to the chat widget for a user who is waiting to be connected to an
@@ -777,7 +785,7 @@ class ServiceDeskCallbackImpl {
             // The chat is no longer running.
             return;
         }
-        cdsAichatInternal.debugLog('[ServiceDeskCallbackImpl] agentReadMessages');
+        AppContainer.debugLog('[ServiceDeskCallbackImpl] agentReadMessages');
     }
     /**
      * Tells the chat widget if an agent has started or stopped typing.
@@ -806,12 +814,12 @@ class ServiceDeskCallbackImpl {
             // The chat is no longer running or no message was actually provided.
             return;
         }
-        const messageResponse = typeof message === 'string' ? cdsAichatInternal.createMessageResponseForText(message) : message;
-        cdsAichatInternal.addDefaultsToMessage(messageResponse);
+        const messageResponse = typeof message === 'string' ? AppContainer.createMessageResponseForText(message) : message;
+        AppContainer.addDefaultsToMessage(messageResponse);
         if (messageResponse.output?.generic?.length) {
             messageResponse.output.generic.forEach(messageItem => {
                 if (!messageItem.agent_message_type) {
-                    messageItem.agent_message_type = cdsAichatInternal.AgentMessageType.FROM_AGENT;
+                    messageItem.agent_message_type = AppContainer.AgentMessageType.FROM_AGENT;
                 }
             });
         }
@@ -828,7 +836,7 @@ class ServiceDeskCallbackImpl {
                 // agent (if there is one).
                 agentProfile = this.persistedAgentState().agentProfile;
                 if (agentProfile) {
-                    cdsAichatInternal.consoleError(`Got agent ID ${agentID} but no agent with that ID joined the conversation. Using the current agent instead.`);
+                    AppContainer.consoleError(`Got agent ID ${agentID} but no agent with that ID joined the conversation. Using the current agent instead.`);
                 }
             }
         }
@@ -840,9 +848,9 @@ class ServiceDeskCallbackImpl {
         });
         messageResponse.history.agent_profile = agentProfile;
         const localMessages = messageResponse.output.generic.map(item => {
-            return cdsAichatInternal.outputItemToLocalItem(item, messageResponse);
+            return AppContainer.outputItemToLocalItem(item, messageResponse);
         });
-        await cdsAichatInternal.addMessages([cdsAichatInternal.toPair(localMessages, messageResponse)], true, true, !this.service.isSuspended(), this.serviceManager);
+        await AppContainer.addMessages([AppContainer.toPair(localMessages, messageResponse)], true, true, !this.service.isSuspended(), this.serviceManager);
         // Track when a message from a human agent is sent to the user.
         const trackProps = {
             eventName: 'Human Message Sent to User',
@@ -905,7 +913,7 @@ class ServiceDeskCallbackImpl {
         await this.service.doEndChat(true, event.preEndChatPayload);
         // Display the "end chat" messages.
         const { agentProfile } = this.persistedAgentState();
-        await cdsAichatInternal.addEndChatMessages(AGENT_ENDED_CHAT, agentProfile, BOT_RETURN_DELAY, true, wasSuspended, this.serviceManager);
+        await AppContainer.addEndChatMessages(AGENT_ENDED_CHAT, agentProfile, BOT_RETURN_DELAY, true, wasSuspended, this.serviceManager);
     }
     /**
      * Sets the state of the given error type.
@@ -921,36 +929,36 @@ class ServiceDeskCallbackImpl {
         const { store } = this.serviceManager;
         const { isConnecting } = store.getState().agentState;
         if (logInfo) {
-            cdsAichatInternal.consoleError(`An error occurred in the service desk (type=${type})`, logInfo);
+            AppContainer.consoleError(`An error occurred in the service desk (type=${type})`, logInfo);
         }
         // If the service desk reports a disconnected error while we're in the middle of connecting, then handle it as a
         // connecting error instead. This avoids us sending the user a message when we never actually connected.
-        if (isConnecting && errorInfo.type === cdsAichatInternal.ErrorType.DISCONNECTED && errorInfo.isDisconnected) {
-            errorInfo = { type: cdsAichatInternal.ErrorType.CONNECTING };
+        if (isConnecting && errorInfo.type === AppContainer.ErrorType.DISCONNECTED && errorInfo.isDisconnected) {
+            errorInfo = { type: AppContainer.ErrorType.CONNECTING };
         }
         switch (errorInfo.type) {
-            case cdsAichatInternal.ErrorType.DISCONNECTED: {
+            case AppContainer.ErrorType.DISCONNECTED: {
                 if (errorInfo.isDisconnected) {
                     // The service desk has become disconnected so show an error and don't allow the user to send messages.
                     this.service.showingDisconnectedError = true;
                     await this.service.addAgentLocalMessage(DISCONNECTED, null, true, false);
-                    store.dispatch(cdsAichatInternal.actions.updateInputState({ isReadonly: true }, true));
+                    store.dispatch(AppContainer.actions.updateInputState({ isReadonly: true }, true));
                 }
                 else if (this.service.showingDisconnectedError) {
                     // The service desk says it's no longer disconnected but double check that we previously thought we were
                     // disconnected.
                     this.service.showingDisconnectedError = false;
                     await this.service.addAgentLocalMessage(RECONNECTED, null, true, false);
-                    store.dispatch(cdsAichatInternal.actions.updateInputState({ isReadonly: false }, true));
+                    store.dispatch(AppContainer.actions.updateInputState({ isReadonly: false }, true));
                 }
                 break;
             }
-            case cdsAichatInternal.ErrorType.CONNECTING: {
+            case AppContainer.ErrorType.CONNECTING: {
                 // If we can't connect, display an inline error message on the bot view.
                 const { languagePack } = this.serviceManager.store.getState();
                 const message = errorInfo.messageToUser || languagePack.errors_connectingToAgent;
-                const { originalMessage, localMessage } = cdsAichatInternal.createLocalMessageForInlineError(message);
-                await cdsAichatInternal.addMessages([cdsAichatInternal.toPair([localMessage], originalMessage)], true, false, !this.service.isSuspended(), this.serviceManager);
+                const { originalMessage, localMessage } = AppContainer.createLocalMessageForInlineError(message);
+                await AppContainer.addMessages([AppContainer.toPair([localMessage], originalMessage)], true, false, !this.service.isSuspended(), this.serviceManager);
                 // Cancel the connecting status.
                 this.serviceManager.store.dispatch(agentActions.setIsConnecting(false, null));
                 this.service.chatStarted = false;
@@ -958,8 +966,8 @@ class ServiceDeskCallbackImpl {
                 await this.service.fireEndChat(false, isConnecting);
                 break;
             }
-            case cdsAichatInternal.ErrorType.USER_MESSAGE: {
-                this.service.setMessageErrorState(errorInfo.messageID, cdsAichatInternal.MessageErrorState.FAILED);
+            case AppContainer.ErrorType.USER_MESSAGE: {
+                this.service.setMessageErrorState(errorInfo.messageID, AppContainer.MessageErrorState.FAILED);
                 break;
             }
         }
@@ -988,31 +996,31 @@ class ServiceDeskCallbackImpl {
         if (uploadMessage) {
             // Update the value in the redux store.
             const partialMessage = {
-                history: { file_upload_status: cdsAichatInternal.FileStatusValue.COMPLETE },
+                history: { file_upload_status: AppContainer.FileStatusValue.COMPLETE },
             };
             if (isError) {
-                store.dispatch(cdsAichatInternal.actions.setMessageHistoryProperty(fileID, 'file_upload_status', cdsAichatInternal.FileStatusValue.COMPLETE));
-                store.dispatch(cdsAichatInternal.actions.setMessageHistoryProperty(fileID, 'error_state', cdsAichatInternal.MessageErrorState.FAILED));
-                partialMessage.history.error_state = cdsAichatInternal.MessageErrorState.FAILED;
+                store.dispatch(AppContainer.actions.setMessageHistoryProperty(fileID, 'file_upload_status', AppContainer.FileStatusValue.COMPLETE));
+                store.dispatch(AppContainer.actions.setMessageHistoryProperty(fileID, 'error_state', AppContainer.MessageErrorState.FAILED));
+                partialMessage.history.error_state = AppContainer.MessageErrorState.FAILED;
                 if (errorMessage) {
                     // Generate an inline error message to show the error to the user.
-                    const { originalMessage, localMessage } = cdsAichatInternal.createLocalMessageForInlineError(errorMessage);
-                    localMessage.item.agent_message_type = cdsAichatInternal.AgentMessageType.INLINE_ERROR;
-                    await cdsAichatInternal.addMessages([cdsAichatInternal.toPair([localMessage], originalMessage)], true, true, !this.service.isSuspended(), this.serviceManager);
+                    const { originalMessage, localMessage } = AppContainer.createLocalMessageForInlineError(errorMessage);
+                    localMessage.item.agent_message_type = AppContainer.AgentMessageType.INLINE_ERROR;
+                    await AppContainer.addMessages([AppContainer.toPair([localMessage], originalMessage)], true, true, !this.service.isSuspended(), this.serviceManager);
                 }
             }
             else {
                 // If the upload was completed successfully, we display a temporary "success" status. This will display a
                 // checkmark temporarily before fading out. Session history will store "complete" as the status.
-                store.dispatch(cdsAichatInternal.actions.setMessageHistoryProperty(fileID, 'file_upload_status', cdsAichatInternal.FileStatusValue.SUCCESS));
-                store.dispatch(cdsAichatInternal.actions.announceMessage({ messageID: 'fileSharing_ariaAnnounceSuccess' }));
+                store.dispatch(AppContainer.actions.setMessageHistoryProperty(fileID, 'file_upload_status', AppContainer.FileStatusValue.SUCCESS));
+                store.dispatch(AppContainer.actions.announceMessage({ messageID: 'fileSharing_ariaAnnounceSuccess' }));
             }
             // Send an update to store the status in session history.
             await this.serviceManager.actions.sendUpdateHistoryEvent(fileID, partialMessage);
         }
         else if (isError) {
             // Update the input area.
-            store.dispatch(cdsAichatInternal.actions.fileUploadInputError(fileID, errorMessage, true));
+            store.dispatch(AppContainer.actions.fileUploadInputError(fileID, errorMessage, true));
         }
         this.service.uploadingFiles.delete(fileID);
         this.serviceManager.store.dispatch(agentActions.updateFilesUploadInProgress(this.service.uploadingFiles.size > 0));
@@ -1030,7 +1038,7 @@ class ServiceDeskCallbackImpl {
             return Promise.reject(new Error('Cannot request screen sharing if no chat is in progress.'));
         }
         if (!this.service.screenShareRequestPromise) {
-            this.service.screenShareRequestPromise = cdsAichatInternal.resolvablePromise();
+            this.service.screenShareRequestPromise = AppContainer.resolvablePromise();
             this.serviceManager.store.dispatch(agentActions.setShowScreenShareRequest(true));
             await this.service.addAgentLocalMessage(SHARING_REQUESTED);
         }
@@ -1043,7 +1051,7 @@ class ServiceDeskCallbackImpl {
     async screenShareEnded() {
         const wasScreenSharing = this.serviceManager.store.getState().agentState.isScreenSharing;
         const requestPending = this.service.screenShareRequestPromise;
-        this.service.closeScreenShareRequestModal(cdsAichatInternal.ScreenShareState.CANCELLED);
+        this.service.closeScreenShareRequestModal(AppContainer.ScreenShareState.CANCELLED);
         if (wasScreenSharing) {
             this.serviceManager.store.dispatch(agentActions.setIsScreenSharing(false));
             await this.service.addAgentLocalMessage(SHARING_ENDED);
@@ -1083,12 +1091,12 @@ class ServiceDeskCallbackImpl {
         const { store } = this.serviceManager;
         let newState;
         if (mergeWithCurrent) {
-            newState = cdsAichatInternal.merge({}, store.getState().persistedToBrowserStorage.chatState.agentState.serviceDeskState, state);
+            newState = AppContainer.merge({}, store.getState().persistedToBrowserStorage.chatState.agentState.serviceDeskState, state);
         }
         else {
-            newState = cdsAichatInternal.cloneDeep(state);
+            newState = AppContainer.cloneDeep(state);
         }
-        store.dispatch(agentActions.setPersistedServiceDeskState(cdsAichatInternal.deepFreeze(newState)));
+        store.dispatch(agentActions.setPersistedServiceDeskState(AppContainer.deepFreeze(newState)));
     }
 }
 /**
@@ -1104,17 +1112,17 @@ function createService(serviceManager) {
  */
 function validateCustomServiceDesk(serviceDesk) {
     if (!serviceDesk) {
-        cdsAichatInternal.consoleError('The custom service desk does not appear to be valid. No service desk was provided.', serviceDesk);
+        AppContainer.consoleError('The custom service desk does not appear to be valid. No service desk was provided.', serviceDesk);
     }
     else if (typeof serviceDesk !== 'object') {
-        cdsAichatInternal.consoleError(`The custom service desk does not appear to be valid. The type should be "object" but is "${typeof serviceDesk}"`, serviceDesk);
+        AppContainer.consoleError(`The custom service desk does not appear to be valid. The type should be "object" but is "${typeof serviceDesk}"`, serviceDesk);
     }
     else {
         const propertyNames = ['startChat', 'endChat', 'sendMessageToAgent'];
         propertyNames.forEach(propertyName => {
             const value = serviceDesk[propertyName];
             if (typeof value !== 'function') {
-                cdsAichatInternal.consoleError(`The custom service desk does not appear to be valid. The type of property "${propertyName}"should be "function" but is "${typeof value}"`, value, serviceDesk);
+                AppContainer.consoleError(`The custom service desk does not appear to be valid. The type of property "${propertyName}"should be "function" but is "${typeof value}"`, value, serviceDesk);
             }
         });
         const name = serviceDesk.getName?.();
@@ -1134,7 +1142,7 @@ function replaceVersionInSessionHistoryKey(localConnectMessage) {
     const sessionHistoryKey = localConnectMessage.item.transfer_info?.session_history_key;
     if (sessionHistoryKey) {
         const sessionHistoryKeySerialized = SessionHistoryKeySerializer.deserialize(sessionHistoryKey);
-        sessionHistoryKeySerialized.version = cdsAichatInternal.VERSION;
+        sessionHistoryKeySerialized.version = AppContainer.VERSION;
         return SessionHistoryKeySerializer.serialize(sessionHistoryKeySerialized);
     }
     return '';