feat: After the voice in the new conversation window is played, jump to the tab of the conversation #1877 (#2440)

### What problem does this PR solve?

feat: After the voice in the new conversation window is played, jump to
the tab of the conversation #1877

### Type of change

- [x] New Feature (non-breaking change which adds functionality)

web/src/components/message-item/hooks.ts

 import { useSetModalState } from '@/hooks/common-hooks';
 import { IRemoveMessageById, useSpeechWithSse } from '@/hooks/logic-hooks';
 import { IFeedbackRequestBody } from '@/interfaces/request/chat';
+import { ConversationContext } from '@/pages/chat/context';
 import { getMessagePureId } from '@/utils/chat';
 import { hexStringToUint8Array } from '@/utils/common-util';
 import { SpeechPlayer } from 'openai-speech-stream-player';
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useCallback, useContext, useEffect, useRef, useState } from 'react';
 
 export const useSendFeedback = (messageId: string) => {
   const { visible, hideModal, showModal } = useSetModalState();
   const { read } = useSpeechWithSse();
   const player = useRef<SpeechPlayer>();
   const [isPlaying, setIsPlaying] = useState<boolean>(false);
+  const callback = useContext(ConversationContext);
 
   const initialize = useCallback(async () => {
     player.current = new SpeechPlayer({
       audio: ref.current!,
       onPlaying: () => {
         setIsPlaying(true);
+        callback?.(true);
       },
       onPause: () => {
         setIsPlaying(false);
+        callback?.(false);
       },
       onChunkEnd: () => {},
       mimeType: 'audio/mpeg',
     });
     await player.current.init();
-  }, []);
+  }, [callback]);
 
   const pause = useCallback(() => {
     player.current?.pause();

web/src/interfaces/database/chat.ts

   parameters: Parameter[];
   prologue: string;
   system: string;
+  tts?: boolean;
 }
 
 export interface Parameter {

web/src/pages/chat/chat-container/index.tsx

 } from '@/hooks/chat-hooks';
 import { useFetchUserInfo } from '@/hooks/user-setting-hooks';
 import { memo } from 'react';
+import { ConversationContext } from '../context';
 import styles from './index.less';
 
 const ChatContainer = () => {
   const { data: conversation } = useFetchNextConversation();
 
   const {
+    value,
     ref,
     loading,
     sendLoading,
     derivedMessages,
     handleInputChange,
     handlePressEnter,
-    value,
     regenerateMessage,
     removeMessageById,
+    redirectToNewConversation,
   } = useSendNextMessage();
 
   const { visible, hideModal, documentId, selectedChunk, clickDocumentButton } =
         <Flex flex={1} vertical className={styles.messageContainer}>
           <div>
             <Spin spinning={loading}>
-              {derivedMessages?.map((message, i) => {
-                return (
-                  <MessageItem
-                    loading={
-                      message.role === MessageType.Assistant &&
-                      sendLoading &&
-                      derivedMessages.length - 1 === i
-                    }
-                    key={message.id}
-                    item={message}
-                    nickname={userInfo.nickname}
-                    avatar={userInfo.avatar}
-                    reference={buildMessageItemReference(
-                      {
-                        message: derivedMessages,
-                        reference: conversation.reference,
-                      },
-                      message,
-                    )}
-                    clickDocumentButton={clickDocumentButton}
-                    index={i}
-                    removeMessageById={removeMessageById}
-                    regenerateMessage={regenerateMessage}
-                    sendLoading={sendLoading}
-                  ></MessageItem>
-                );
-              })}
+              <ConversationContext.Provider value={redirectToNewConversation}>
+                {derivedMessages?.map((message, i) => {
+                  return (
+                    <MessageItem
+                      loading={
+                        message.role === MessageType.Assistant &&
+                        sendLoading &&
+                        derivedMessages.length - 1 === i
+                      }
+                      key={message.id}
+                      item={message}
+                      nickname={userInfo.nickname}
+                      avatar={userInfo.avatar}
+                      reference={buildMessageItemReference(
+                        {
+                          message: derivedMessages,
+                          reference: conversation.reference,
+                        },
+                        message,
+                      )}
+                      clickDocumentButton={clickDocumentButton}
+                      index={i}
+                      removeMessageById={removeMessageById}
+                      regenerateMessage={regenerateMessage}
+                      sendLoading={sendLoading}
+                    ></MessageItem>
+                  );
+                })}
+              </ConversationContext.Provider>
             </Spin>
           </div>
           <div ref={ref} />

web/src/pages/chat/context.ts

+import { createContext } from 'react';
+
+export const ConversationContext = createContext<
+  null | ((isPlaying: boolean) => void)
+>(null);

web/src/pages/chat/hooks.ts

   useCallback,
   useEffect,
   useMemo,
+  useRef,
   useState,
 } from 'react';
 import { useSearchParams } from 'umi';
     removeMessageById,
     removeMessagesAfterCurrentMessage,
   } = useSelectNextMessages();
+  const { data: dialog } = useFetchNextDialog();
+  const currentConversationIdRef = useRef<string>('');
+
+  const redirectToNewConversation = useCallback(
+    (isPlaying: boolean) => {
+      if (!conversationId && dialog?.prompt_config?.tts && !isPlaying) {
+        handleClickConversation(currentConversationIdRef.current);
+      }
+    },
+    [dialog, handleClickConversation, conversationId],
+  );
 
   const sendMessage = useCallback(
     async ({
         if (currentConversationId) {
           console.info('111');
           // new conversation
-          handleClickConversation(currentConversationId);
+          if (!dialog?.prompt_config?.tts) {
+            handleClickConversation(currentConversationId);
+          }
         } else {
           console.info('222');
           // fetchConversation(conversationId);
       }
     },
     [
+      dialog,
       derivedMessages,
       conversationId,
       handleClickConversation,
         const data = await setConversation(message.content);
         if (data.retcode === 0) {
           const id = data.data.id;
+          currentConversationIdRef.current = id;
           sendMessage({
             message,
             currentConversationId: id,
     ref,
     derivedMessages,
     removeMessageById,
+    redirectToNewConversation,
   };
 };