diff --git a/package.json b/package.json
index 01c422df..4c643536 100644
--- a/package.json
+++ b/package.json
@@ -74,6 +74,7 @@
   "dependencies": {
     "@eeacms/volto-matomo": "6.0.0",
     "@microsoft/fetch-event-source": "2.0.1",
+    "dequal": "2.0.3",
     "fast-json-patch": "3.1.1",
     "highlight.js": "11.10.0",
     "luxon": "3.5.0",
@@ -83,6 +84,10 @@
     "react-textarea-autosize": "^8.5.3",
     "rehype-prism-plus": "1.6.0",
     "remark-gfm": "3.0.1",
+    "unist-util-visit": "5.0.0",
     "uuid": "10.0.0"
+  },
+  "peerDependencies": {
+    "@plone/volto": ">18.0.0 < 19.0.0"
   }
 }
diff --git a/src/ChatBlock/AutoResizeTextarea.jsx b/src/ChatBlock/AutoResizeTextarea.jsx
index d1912040..32651960 100644
--- a/src/ChatBlock/AutoResizeTextarea.jsx
+++ b/src/ChatBlock/AutoResizeTextarea.jsx
@@ -7,12 +7,22 @@ import { SVGIcon } from './utils';
 import SendIcon from './../icons/send.svg';
 
 export default React.forwardRef(function AutoResizeTextarea(props, ref) {
-  const { onSubmit, isStreaming, enableMatomoTracking, persona, ...rest } =
-    props;
+  const {
+    onSubmit,
+    onFocus,
+    onChange = () => {},
+    disableSubmit,
+    enableMatomoTracking,
+    persona,
+    ...rest
+  } = props;
   const [input, setInput] = React.useState('');
 
   const handleSubmit = (e) => {
     e.preventDefault();
+    if (disableSubmit) {
+      return
+    }
     const trimmedInput = input.trim();
     if (trimmedInput) {
       if (enableMatomoTracking) {
@@ -30,8 +40,13 @@ export default React.forwardRef(function AutoResizeTextarea(props, ref) {
   return (
     <>
       <TextareaAutosize
+        aria-describedby="chat-wake-error-message"
         value={input}
-        onChange={(e) => setInput(e.target.value)}
+        onFocus={onFocus}
+        onChange={(e) => {
+          onChange(e);
+          setInput(e.target.value);
+        }}
         onKeyDown={(e) => {
           if (e.key === 'Enter' && !e.shiftKey) {
             handleSubmit(e);
@@ -46,7 +61,7 @@ export default React.forwardRef(function AutoResizeTextarea(props, ref) {
 
       <Button
         className="submit-btn"
-        disabled={isStreaming}
+        disabled={disableSubmit}
         type="submit"
         aria-label="Send"
         onKeyDown={(e) => {
diff --git a/src/ChatBlock/ChatMessageBubble.jsx b/src/ChatBlock/ChatMessageBubble.jsx
index 74f24e95..2e5e17f0 100644
--- a/src/ChatBlock/ChatMessageBubble.jsx
+++ b/src/ChatBlock/ChatMessageBubble.jsx
@@ -1,5 +1,5 @@
 import React from 'react';
-import visit from 'unist-util-visit';
+import { visit } from 'unist-util-visit';
 import loadable from '@loadable/component';
 import { Button, Message, MessageContent } from 'semantic-ui-react';
 import { trackEvent } from '@eeacms/volto-matomo/utils';
diff --git a/src/ChatBlock/ChatWindow.jsx b/src/ChatBlock/ChatWindow.jsx
index 9878ffe4..0a97b0fc 100644
--- a/src/ChatBlock/ChatWindow.jsx
+++ b/src/ChatBlock/ChatWindow.jsx
@@ -6,8 +6,8 @@ import { trackEvent } from '@eeacms/volto-matomo/utils';
 import AutoResizeTextarea from './AutoResizeTextarea';
 import { ChatMessageBubble } from './ChatMessageBubble';
 import EmptyState from './EmptyState';
-import { useScrollonStream } from './lib';
-import { useBackendChat } from './useBackendChat';
+import { useScrollonStream } from "./lib";
+import { useBackendChat, ChatState } from './useBackendChat';
 import { SVGIcon } from './utils';
 import PenIcon from './../icons/square-pen.svg';
 
@@ -41,19 +41,23 @@ function ChatWindow({
     enableMatomoTracking,
   } = data;
   const [qualityCheckEnabled, setQualityCheckEnabled] = React.useState(true);
-  const libs = { rehypePrism, remarkGfm }; // rehypePrism, remarkGfm
+  const libs = {rehypePrism, remarkGfm}; // rehypePrism, remarkGfm
+  const abortController = React.useRef(new AbortController());
   const {
     onSubmit,
     messages,
-    isStreaming,
-    isFetchingRelatedQuestions,
+    chatState,
     clearChat,
+    error,
+    wake,
   } = useBackendChat({
     persona,
     qgenAsistantId,
     enableQgen,
+    signal: abortController.current.signal,
   });
   const [showLandingPage, setShowLandingPage] = React.useState(false);
+  const isStreaming = chatState === ChatState.STREAMING;
 
   const textareaRef = React.useRef(null);
   const conversationRef = React.useRef(null);
@@ -151,7 +155,7 @@ function ChatWindow({
                   enableShowTotalFailMessage={enableShowTotalFailMessage}
                   totalFailMessage={totalFailMessage}
                   showToolCalls={showToolCalls}
-                  isFetchingRelatedQuestions={isFetchingRelatedQuestions}
+                  isFetchingRelatedQuestions={chatState === ChatState.FETCHING_RELATED}
                   enableMatomoTracking={enableMatomoTracking}
                   persona={persona}
                 />
@@ -160,25 +164,43 @@ function ChatWindow({
             </div>
           </>
         )}
-        {isStreaming && !isFetchingRelatedQuestions && (
+        {/* TODO: Only show this if it's taking a while to prevent flashing. Could cause WCAG SC 2.3.1 failure. */}
+        {[ChatState.STREAMING, ChatState.SUBMITTING].includes(chatState) && (
           <div className="loader" />
         )}
       </div>
 
       <div className="chat-form">
         <Form>
+          {error ? (
+            <p
+              id="chat-wake-error-message"
+              aria-live="polite"
+              className="ui red basic label form-error-label"
+            >
+              {error}
+            </p>
+          ) : null}
           <div className="textarea-wrapper">
             <AutoResizeTextarea
               maxRows={8}
               minRows={1}
               ref={textareaRef}
               placeholder={
-                messages.length > 0 ? 'Ask follow-up...' : placeholderPrompt
+                messages.length > 0 ? "Ask follow-up..." : placeholderPrompt
               }
-              isStreaming={isStreaming}
+              disableSubmit={[ChatState.STREAMING].includes(
+                chatState,
+              )}
               enableMatomoTracking={enableMatomoTracking}
               persona={persona}
               onSubmit={onSubmit}
+              onFocus={() => {
+                wake(chatState);
+              }}
+              onChange={() => {
+                wake(chatState);
+              }}
             />
           </div>
         </Form>
diff --git a/src/ChatBlock/lib.js b/src/ChatBlock/lib.js
index ef080367..1f188df8 100644
--- a/src/ChatBlock/lib.js
+++ b/src/ChatBlock/lib.js
@@ -1,9 +1,68 @@
 import { useRef, useEffect } from 'react';
 
+import config from "@plone/registry";
+
 export const delay = (ms) => {
   return new Promise((resolve) => setTimeout(resolve, ms));
 };
 
+// GET Request to DANSWER_URL/api/health to wake it up before starting.
+//   Will retry 3 times over 90 seconds and throw if no response received or unhealthy status is returned.
+export async function wakeApi() {
+  // let timeout = 15000;
+  // 
+  // function fetchWithRetry(url, retries, abortController) {
+  //   return fetch(url, {
+  //     signal: abortController,
+  //     headers: {
+  //       "Content-Type": "application/json",
+  //     },
+  //   }).catch((error) => {
+  //     if ("connection" in navigator && navigator.connection.saveData === true) {
+  //       throw error;
+  //     }
+  //     if (retries > 0 && error.message !== "Request timed out") {
+  //       // Add 5 seconds to the timeout each retry
+  //       timeout += 5000;
+  //       return fetchWithRetry(url, retries - 1, AbortSignal.timeout(timeout));
+  //     } else {
+  //       throw error;
+  //     }
+  //   });
+  // }
+  let healthResponse = undefined;
+  const healthCheckUrl = config.settings["volto-chatbot"].rewakeUrl;
+  try {
+    healthResponse = await fetch(healthCheckUrl, {
+      signal: AbortSignal.timeout(60000),
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+    // healthResponse = await fetchWithRetry(
+    //   healthCheckUrl,
+    //   3,
+    //   AbortSignal.timeout(timeout),
+    // );
+  } catch (err) {
+    // Timeout reached
+    if (err.name === "TimeoutError") {
+      throw Error("Failed to start a chat session at this time. Please try again later");
+    }
+    // Fetch request cancelled
+    else if (err.name === "AbortError") {
+      throw Error(`Chat session startup cancelled. Reason: ${err.message}`)
+    } else {
+      throw Error(`Unknown Error: type: ${err.name}, message: ${err.message}`)
+    }
+  }
+  if (!healthResponse?.ok) {
+    return false;
+  }
+
+  return true;
+}
+
 export async function createChatSession(personaId, description) {
   const createChatSessionResponse = await fetch(
     '/_da/chat/create-chat-session',
@@ -145,6 +204,11 @@ export function buildLatestMessageChain(messageMap) {
   return finalMessageList; // .concat(additionalMessagesOnMainline);
 }
 
+/**
+ * 
+ * @param {Object} options
+ * @param {AbortSignal} signal
+ */
 export async function* sendMessage({
   message,
   fileDescriptors,
@@ -161,6 +225,7 @@ export async function* sendMessage({
   systemPromptOverride,
   useExistingUserMessage,
   alternateAssistantId,
+  signal,
 }) {
   const documentsAreSelected =
     selectedDocumentIds && selectedDocumentIds.length > 0;
@@ -170,6 +235,7 @@ export async function* sendMessage({
     headers: {
       'Content-Type': 'application/json',
     },
+    signal,
     body: JSON.stringify({
       alternate_assistant_id: alternateAssistantId,
       chat_session_id: chatSessionId,
@@ -310,7 +376,7 @@ export class CurrentMessageFIFO {
   }
 }
 
-export async function fetchRelatedQuestions(message, qgenAsistantId) {
+export async function fetchRelatedQuestions(message, { qgenAsistantId, signal }) {
   const { query, answer } = message;
   const chatSessionId = await createChatSession(qgenAsistantId, `Q: ${query}`);
 
@@ -323,6 +389,7 @@ export async function fetchRelatedQuestions(message, qgenAsistantId) {
     promptId: 0,
     filters: {},
     selectedDocumentIds: [],
+    signal: signal,
   };
   const promise = updateCurrentMessageFIFO(params, {}, () => {});
 
@@ -358,11 +425,12 @@ export async function fetchRelatedQuestions(message, qgenAsistantId) {
   return result;
 }
 
-export async function* updateCurrentMessageFIFO(
-  params,
-  isCancelledRef,
-  setIsCancelled,
-) {
+/**
+ * 
+ * @param {Object} params 
+ * @param {AbortSignal} params.signal 
+ */
+export async function* updateCurrentMessageFIFO(params) {
   const promise = sendMessage(params);
 
   try {
@@ -370,11 +438,6 @@ export async function* updateCurrentMessageFIFO(
       for (const packet of packetBunch) {
         yield { packet };
       }
-
-      if (isCancelledRef.current) {
-        setIsCancelled(false);
-        break;
-      }
     }
   } catch (error) {
     yield { error: String(error) };
diff --git a/src/ChatBlock/useBackendChat.js b/src/ChatBlock/useBackendChat.js
index 51164933..716d5909 100644
--- a/src/ChatBlock/useBackendChat.js
+++ b/src/ChatBlock/useBackendChat.js
@@ -1,4 +1,4 @@
-import React, { useState } from 'react';
+import React from 'react';
 import {
   buildLatestMessageChain,
   createChatSession,
@@ -9,8 +9,11 @@ import {
   removeMessage,
   updateCurrentMessageFIFO,
   updateParentChildren,
+  wakeApi,
 } from './lib';
 
+import config from "@plone/registry";
+
 const TEMP_USER_MESSAGE_ID = -1;
 const TEMP_ASSISTANT_MESSAGE_ID = -2;
 const SYSTEM_MESSAGE_ID = -3;
@@ -27,6 +30,17 @@ export const ChatFileType = {
   PLAIN_TEXT: 'plain_text',
 };
 
+export const ChatState = Object.freeze({
+  AWAITING_START: 'awaitingStart',
+  ASLEEP: 'asleep',
+  WAKING: 'waking',
+  READY: 'ready',
+  SUBMITTING: 'submitting',
+  STREAMING: 'streaming',
+  FETCHING_RELATED: 'fetchingRelated',
+  ERRORED: 'error',
+});
+
 function upsertToCompleteMessageMap({
   chatSessionId,
   completeMessageDetail,
@@ -34,7 +48,7 @@ function upsertToCompleteMessageMap({
   makeLatestChildMessage = false,
   messages,
   replacementsMap = null,
-  setCompleteMessageDetail,
+  // setCompleteMessageDetail,
 }) {
   // deep copy
   const frozenCompleteMessageMap =
@@ -88,44 +102,67 @@ function upsertToCompleteMessageMap({
     }
   }
   const newCompleteMessageDetail = {
-    sessionId: chatSessionId || completeMessageDetail.sessionId,
+    sessionId: chatSessionId || completeMessageDetail?.sessionId || null,  // TODO: sessionid can be null because it was an initial error. what should happen?
     messageMap: newCompleteMessageMap,
   };
-  setCompleteMessageDetail(newCompleteMessageDetail);
+  // setCompleteMessageDetail(newCompleteMessageDetail);
   return newCompleteMessageDetail;
 }
 
 class SubmitHandler {
+  /**
+   * @param {Object} options
+   * @param {AbortSignal=} options.signal  Optional parameter for additional control of the abort signal. E.g. stopping the fetch from a button press.
+   */
   constructor({
     persona,
-    setIsStreaming,
-    isCancelledRef,
-    setIsCancelled,
-    messageHistory,
-    completeMessageDetail,
-    currChatSessionId,
-    setCurrChatSessionId,
-    setCompleteMessageDetail,
+    setChatState,
+    onMessageHistoryChange,
     chatTitle,
     qgenAsistantId,
     enableQgen,
-    setIsFetchingRelatedQuestions,
+    setError,
+    signal,
   }) {
     this.persona = persona;
     this.chatTitle = chatTitle;
-    this.setIsStreaming = setIsStreaming;
-    this.isCancelledRef = isCancelledRef;
-    this.setIsCancelled = setIsCancelled;
-    this.messageHistory = messageHistory;
-    this.completeMessageDetail = completeMessageDetail;
-    this.currChatSessionId = currChatSessionId;
-    this.setCurrChatSessionId = setCurrChatSessionId;
-    this.setCompleteMessageDetail = setCompleteMessageDetail;
+    this.setChatState = setChatState;
+    this.onMessageHistoryChange = onMessageHistoryChange;
     this.qgenAsistantId = qgenAsistantId;
     this.enableQgen = enableQgen;
-    this.setIsFetchingRelatedQuestions = setIsFetchingRelatedQuestions;
+    this.setError = setError;
 
     this.onSubmit = this.onSubmit.bind(this);
+    this.abortSignal = signal || null;
+  }
+
+  set messageHistory(history) {
+    this._messageHistory = history;
+    this.onMessageHistoryChange(history);
+
+    if (history.length === 0) {
+      this.completeMessageDetail = ({
+        sessionId: null,
+        messageMap: new Map(),
+      });
+    }
+  }
+  get messageHistory() {
+    return this._messageHistory || [];
+  }
+
+  currChatSessionId = null;
+  completeMessageDetail = {
+      sessionId: null,
+      messageMap: new Map(),
+  }
+    
+  // Resets error if no message is passed
+  handlePacketTimeout(message, promise) {
+    this.setError(message || '');
+    if (promise) {
+      promise.return();
+    }
   }
 
   async onSubmit({
@@ -137,11 +174,15 @@ class SubmitHandler {
     message,
   } = {}) {
     if (this.currChatSessionId === null) {
-      this.currChatSessionId = await createChatSession(
-        this.persona.id,
-        this.chatTitle,
-      );
-      this.setCurrChatSessionId(this.currChatSessionId);
+      try {
+        this.currChatSessionId = await createChatSession(
+          this.persona.id,
+          this.chatTitle,
+        );
+      } catch (error) {
+        this.setError("Failed to create a chat session.");
+        return;
+      }
     }
 
     let newCompleteMessageDetail = {};
@@ -210,7 +251,6 @@ class SubmitHandler {
       messages: messageUpdates,
       chatSessionId: this.currChatSessionId,
       completeMessageDetail: this.completeMessageDetail,
-      setCompleteMessageDetail: this.setCompleteMessageDetail,
     };
 
     const _res = upsertToCompleteMessageMap(info);
@@ -224,7 +264,7 @@ class SubmitHandler {
 
     const currentAssistantId = this.persona.id;
 
-    this.setIsStreaming(true);
+    this.setChatState(ChatState.STREAMING);
 
     let answer = '';
     let query = null;
@@ -252,21 +292,44 @@ class SubmitHandler {
       queryOverride,
       forceSearch,
       useExistingUserMessage: isSeededChat,
+      signal: this.abortSignal,
     };
-    const promise = updateCurrentMessageFIFO(
-      params,
-      this.isCancelledRef,
-      this.setIsCancelled,
-    );
+    const promise = updateCurrentMessageFIFO(params);
 
     await delay(50);
 
+    // const packetWarningTime = 60000;
+    const packetErrorTime = 120000;
+    // let warningTimeout = setTimeout(() => {
+    //   this.handlePacketTimeout("Chat is taking a long time to reply.");
+    // }, packetWarningTime);
+    let errorTimeout = setTimeout(() => {
+      this.handlePacketTimeout(
+        "No response was received from the chat, stopping",
+        promise,
+      );
+    }, packetErrorTime);
+
     for await (const bit of promise) {
+      // clearTimeout(warningTimeouts);
+      clearTimeout(errorTimeout);
+      this.handlePacketTimeout();
+
       if (bit.error) {
         stack.error = bit.error;
+        throw bit.error;
       } else if (bit.isComplete) {
         stack.isComplete = true;
       } else {
+        // warningTimeout = setTimeout(() => {
+        //   this.handlePacketTimeout("Chat is taking a long time to reply.");
+        // }, packetWarningTime);
+        errorTimeout = setTimeout(() => {
+          this.handlePacketTimeout(
+            "No response was received from the chat, stopping",
+            promise,
+          );
+        }, packetErrorTime);
         stack.push(bit.packet);
       }
 
@@ -369,18 +432,16 @@ class SubmitHandler {
             completeMessageMapOverride: frozenMessageMap,
             messages: localMessages,
             replacementsMap: replacementsMap,
-            setCompleteMessageDetail: this.setCompleteMessageDetail,
           };
           newCompleteMessageDetail = upsertToCompleteMessageMap(info);
-        }
-
-        if (this.isCancelledRef.current) {
-          this.setIsCancelled(false);
-          break;
+          this.messageHistory = buildLatestMessageChain(
+            newCompleteMessageDetail.messageMap,
+          );
         }
       }
     }
 
+
     if (
       newCompleteMessageDetail.messageMap &&
       this.enableQgen &&
@@ -395,22 +456,27 @@ class SubmitHandler {
       if (lastMessage && userMessage) {
         const query = userMessage.message;
         const answer = lastMessage.message;
-        this.setIsFetchingRelatedQuestions(true);
+        this.setChatState(ChatState.FETCHING_RELATED);
         const relatedQuestionsText = await fetchRelatedQuestions(
           { query, answer },
-          this.qgenAsistantId,
+          { qgenAsistantId: this.qgenAsistantId }
         );
 
         lastMessage.relatedQuestions = extractJSON(relatedQuestionsText);
 
-        this.setCompleteMessageDetail({
+        this.completeMessageDetail({
           ...newCompleteMessageDetail,
           messageMap,
         });
-        this.setIsFetchingRelatedQuestions(false);
       }
     }
-    this.setIsStreaming(false);
+
+    // Update internal state ready for follow up messages.
+    this.messageHistory = buildLatestMessageChain(
+      newCompleteMessageDetail.messageMap,
+    );
+    this.completeMessageDetail = newCompleteMessageDetail;
+    this.setChatState(ChatState.READY);
   }
 }
 
@@ -427,57 +493,153 @@ function extractJSON(str) {
   }
 }
 
-export function useBackendChat({ persona, qgenAsistantId, enableQgen }) {
-  const [isStreaming, setIsStreaming] = React.useState(false);
-  const [isFetchingRelatedQuestions, setIsFetchingRelatedQuestions] =
-    React.useState(false);
-  const [isCancelled, setIsCancelled] = React.useState(false);
-  const isCancelledRef = React.useRef(isCancelled); // scroll is cancelled
-  const [currChatSessionId, setCurrChatSessionId] = React.useState(null);
+export function useBackendChat({
+  persona,
+  qgenAsistantId,
+  enableQgen,
+  signal,
+}) {
+  const [error, _setError] = React.useState('');
+  const [chatState, setChatState] = React.useState(ChatState.AWAITING_START);
+  const [messageHistory, setMessageHistory] = React.useState([]);
+  const [messageToSubmit, setMessageToSubmit] = React.useState(null);
+
+  const rewakeDelayInMs =
+    config.settings["volto-chatbot"].rewakeDelay * 60 * 1000;
+  
+  function setError(error) {
+    _setError(error instanceof Error ? error.message : error,);
+    if (error) {
+      setChatState(ChatState.ERRORED);
+    }
+  }
+
+  /** Try to wake up the API. Will early return if already awake
+   * @param {*} currentChatState Value of `chatState`. Passed in to workaround stale React state.
+   */
+  async function wake(currentChatState) {
+    const readyForWaking =
+      Date.now() - rewakeDelayInMs > localStorage.getItem("chat-last-awake");
+    if (currentChatState === ChatState.ERRORED) {
+      return false;
+    }
+
+    if (readyForWaking) {
+      localStorage.setItem("chat-last-awake", Date.now());
+    }
+    if (currentChatState === ChatState.WAKING) {
+      return false;
+    }
+    if (![ChatState.ASLEEP, ChatState.AWAITING_START, ChatState.SUBMITTING].includes(currentChatState)) {
+      return true;
+    }
 
+    if (currentChatState !== ChatState.SUBMITTING) {
+      setChatState(ChatState.WAKING);
+    }
+
+    try {
+      const wakeResult = await wakeApi();
+      if (!!wakeResult) {
+        // We want to make sure we know when we're in a submitting and awake state vs just being ready to accept submission
+        if (currentChatState !== ChatState.SUBMITTING) {
+          setChatState(ChatState.READY);
+        }
+        localStorage.setItem("chat-last-awake", Date.now());
+        return true;
+      }
+    } catch (err) {
+      setError(err.message);
+    }
+    return false;
+  }
   React.useEffect(() => {
-    isCancelledRef.current = isCancelled;
-  }, [isCancelled]);
+    if (chatState === ChatState.ASLEEP) {
+      return;
+    }
+    let timeout = null;
+    if (chatState === ChatState.READY) {
+      timeout = setTimeout(() => {
+          setChatState(ChatState.ASLEEP);
+        }, rewakeDelayInMs);
+    }
+    return () => clearTimeout(timeout);
+  }, [chatState]);
 
-  const [completeMessageDetail, setCompleteMessageDetail] = useState({
-    sessionId: null,
-    messageMap: new Map(),
-  });
+  // Hold the submit handler to efficiently keep message history across re-renders
+  const submitHandler = React.useRef(null);
+  React.useEffect(() => {
+    // Handle persona being both a full persona call or just an assistant ID if we didn't make the call
+    const currentPersona = submitHandler.current?.persona?.id || submitHandler.current?.persona;
+    const newPersona = persona?.id || persona;
 
-  const messageHistory = buildLatestMessageChain(
-    completeMessageDetail.messageMap,
-  );
-  const submitHandler = new SubmitHandler({
-    completeMessageDetail,
-    currChatSessionId,
-    isCancelledRef,
-    messageHistory,
-    persona,
-    setCompleteMessageDetail,
-    setCurrChatSessionId,
-    setIsCancelled,
-    setIsStreaming,
-    qgenAsistantId,
-    enableQgen,
-    setIsFetchingRelatedQuestions,
-  });
+    if (currentPersona === newPersona) {
+      return
+    }
+    clearChat()
+    submitHandler.current = new SubmitHandler({
+      messageHistory,
+      persona,
+      setChatState,
+      setError,
+      qgenAsistantId,
+      enableQgen,
+      onMessageHistoryChange: setMessageHistory
+    })
+  }, [chatState, persona])
 
   const clearChat = () => {
-    setCompleteMessageDetail({
-      sessionId: null,
-      messageMap: new Map(),
-    });
-    setCurrChatSessionId(null);
+    if (submitHandler.current) {
+      submitHandler.current.currChatSessionId = null;
+      submitHandler.current.messageHistory = [];  // Will trigger `setMessageHistory`
+    }
+    setError(null);
+    if (chatState === ChatState.ERRORED) {
+      setChatState(ChatState.READY);
+    }
   };
 
-  // console.log('history', messageHistory);
+  const handleSubmit = React.useCallback(
+    function handleSubmit(input) {
+      const onSubmit = submitHandler.current?.onSubmit;
+
+      if (!onSubmit) {
+        throw new Error("TESTING: NO SUBMISSION HANDLER");
+      }
+
+      setError(null);
+      setChatState(ChatState.SUBMITTING);
+      setMessageToSubmit(input);
+    },
+    [chatState],
+  );
+  React.useEffect(() => {
+    if (chatState !== ChatState.SUBMITTING) {
+      return;
+    }
+    if (!messageToSubmit) {
+      return;
+    }
+
+    const onSubmit = submitHandler.current?.onSubmit;
+
+    try {
+      onSubmit(messageToSubmit);
+    } catch (errorReason) {
+      setChatState(ChatState.ERRORED);
+      setError(
+        errorReason instanceof Error ? errorReason.message : errorReason,
+      );
+    }
+    setMessageToSubmit(null);
+  }, [messageToSubmit, chatState, wake]);
 
   return {
     messages: messageHistory,
-    onSubmit: submitHandler.onSubmit,
-    isStreaming,
-    isCancelled,
+    onSubmit: handleSubmit,
+    chatState,
+    error,
     clearChat,
-    isFetchingRelatedQuestions,
+    wake,
   };
 }
diff --git a/src/index.js b/src/index.js
index 812b70f6..ee05d7e3 100644
--- a/src/index.js
+++ b/src/index.js
@@ -40,6 +40,20 @@ const applyConfig = (config) => {
 
   installChatBlock(config);
 
+  config.settings['volto-chatbot'] = {
+    ...(config.settings['volto-chatbot'] || {}),
+    rewakeUrl:
+      process.env['RAZZLE_REWAKE_URL'] ||
+      (typeof window !== 'undefined' && window.env['RAZZLE_REWAKE_URL']) ||
+      '/_da/health',
+    rewakeDelay:
+      Number(
+        process.env['RAZZLE_MINUTES_BEFORE_CHAT_REWAKE'] ||
+          (typeof window !== 'undefined' &&
+            window.env['RAZZLE_MINUTES_BEFORE_CHAT_REWAKE']),
+      ) || 1,
+  };
+
   return config;
 };