feat: Supports pronunciation while outputting text #2088 (#2227)

### What problem does this PR solve?

feat: Supports pronunciation while outputting text #2088

### Type of change

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

web/src/components/message-item/group-button.tsx

   content: string;
   prompt?: string;
   showLikeButton: boolean;
+  audioBinary?: string;
 }
 
 export const AssistantGroupButton = ({
   messageId,
   content,
   prompt,
+  audioBinary,
   showLikeButton,
 }: IProps) => {
   const { visible, hideModal, showModal, onFeedbackOk, loading } =
     showModal: showPromptModal,
   } = useSetModalState();
   const { t } = useTranslation();
-  const { handleRead, ref, isPlaying } = useSpeech(content);
+  const { handleRead, ref, isPlaying } = useSpeech(content, audioBinary);
 
   const handleLike = useCallback(() => {
     onFeedbackOk({ thumbup: true });

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

   return { onRemoveMessage, loading };
 };
 
-export const useSpeech = (content: string) => {
+export const useSpeech = (content: string, audioBinary?: string) => {
   const ref = useRef<HTMLAudioElement>(null);
   const { read } = useSpeechWithSse();
   const player = useRef<SpeechPlayer>();
     }
   }, [setIsPlaying, speech, isPlaying, pause]);
 
+  // useEffect(() => {
+  //   if (audioBinary) {
+  //     const units = hexStringToUint8Array(audioBinary);
+  //     if (units) {
+  //       player.current?.feed(units);
+  //     }
+  //   }
+  // }, [audioBinary]);
+
   useEffect(() => {
     initialize();
   }, [initialize]);

web/src/components/message-item/index.tsx

                     content={item.content}
                     prompt={item.prompt}
                     showLikeButton={showLikeButton}
+                    audioBinary={item.audio_binary}
                   ></AssistantGroupButton>
                 )
               ) : (

web/src/hooks/file-manager-hooks.ts

         formData.append('file', file);
         formData.append('path', pathList[index]);
       });
-      const { data } = await fileManagerService.uploadFile(formData);
-      if (data.retcode === 0) {
-        message.success(t('message.uploaded'));
-        setPaginationParams(1);
-        queryClient.invalidateQueries({ queryKey: ['fetchFileList'] });
+      try {
+        const { data } = await fileManagerService.uploadFile(formData);
+        if (data.retcode === 0) {
+          message.success(t('message.uploaded'));
+          setPaginationParams(1);
+          queryClient.invalidateQueries({ queryKey: ['fetchFileList'] });
+        }
+        return data.retcode;
+      } catch (error) {
+        console.log('🚀 ~ useUploadFile ~ error:', error);
       }
-      return data.retcode;
     },
   });
 

web/src/hooks/logic-hooks.ts

             role: MessageType.Assistant,
           }),
           prompt: answer.prompt,
+          audio_binary: answer.audio_binary,
         },
       ];
     });

web/src/interfaces/database/chat.ts

   doc_ids?: string[];
   prompt?: string;
   id?: string;
+  audio_binary?: string;
 }
 
 export interface IReference {
   conversationId?: string;
   prompt?: string;
   id?: string;
+  audio_binary?: string;
 }
 
 export interface Docagg {

web/src/utils/common-util.ts

   }
   return value;
 };
+
+export const stringToUint8Array = (str: string) => {
+  // const byteString = str.replace(/b'|'/g, '');
+  const byteString = str.slice(2, -1);
+
+  const uint8Array = new Uint8Array(byteString.length);
+  for (let i = 0; i < byteString.length; i++) {
+    uint8Array[i] = byteString.charCodeAt(i);
+  }
+
+  return uint8Array;
+};
+
+export const hexStringToUint8Array = (hex: string) => {
+  const arr = hex.match(/[\da-f]{2}/gi);
+  if (Array.isArray(arr)) {
+    return new Uint8Array(
+      arr.map(function (h) {
+        return parseInt(h, 16);
+      }),
+    );
+  }
+};
+
+export function hexToArrayBuffer(input: string) {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected input to be a string');
+  }
+
+  if (input.length % 2 !== 0) {
+    throw new RangeError('Expected string to be an even number of characters');
+  }
+
+  const view = new Uint8Array(input.length / 2);
+
+  for (let i = 0; i < input.length; i += 2) {
+    view[i / 2] = parseInt(input.substring(i, i + 2), 16);
+  }
+
+  return view.buffer;
+}