diff --git a/src/renderer/src/components/TTSButton.tsx b/src/renderer/src/components/TTSButton.tsx
new file mode 100644
index 0000000000..36b856a434
--- /dev/null
+++ b/src/renderer/src/components/TTSButton.tsx
@@ -0,0 +1,64 @@
+import { SoundOutlined } from '@ant-design/icons'
+import { Button, Tooltip } from 'antd'
+import { useCallback, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import TTSService from '@renderer/services/TTSService'
+import { Message } from '@renderer/types'
+
+interface TTSButtonProps {
+  message: Message
+  className?: string
+}
+
+const TTSButton: React.FC<TTSButtonProps> = ({ message, className }) => {
+  const { t } = useTranslation()
+  const [isSpeaking, setIsSpeaking] = useState(false)
+
+  const handleTTS = useCallback(async () => {
+    if (isSpeaking) {
+      TTSService.stop()
+      setIsSpeaking(false)
+      return
+    }
+
+    setIsSpeaking(true)
+    try {
+      await TTSService.speakFromMessage(message)
+      
+      // 监听播放结束
+      const checkPlayingStatus = () => {
+        if (!TTSService.isCurrentlyPlaying()) {
+          setIsSpeaking(false)
+          clearInterval(checkInterval)
+        }
+      }
+      
+      const checkInterval = setInterval(checkPlayingStatus, 500)
+      
+      // 安全机制，确保即使出错也会重置状态
+      setTimeout(() => {
+        if (isSpeaking) {
+          TTSService.stop()
+          setIsSpeaking(false)
+          clearInterval(checkInterval)
+        }
+      }, 30000) // 30秒后检查
+    } catch (error) {
+      console.error('TTS error:', error)
+      setIsSpeaking(false)
+    }
+  }, [isSpeaking, message])
+
+  return (
+    <Tooltip title={isSpeaking ? t('chat.tts.stop') : t('chat.tts.play')}>
+      <Button
+        className={className}
+        icon={<SoundOutlined />}
+        onClick={handleTTS}
+        type={isSpeaking ? 'primary' : 'default'}
+      />
+    </Tooltip>
+  )
+}
+
+export default TTSButton
diff --git a/src/renderer/src/i18n/locales/en-us.json b/src/renderer/src/i18n/locales/en-us.json
index c8d0c447c7..49f24e7637 100644
--- a/src/renderer/src/i18n/locales/en-us.json
+++ b/src/renderer/src/i18n/locales/en-us.json
@@ -1317,6 +1317,49 @@
       "privacy": {
         "title": "Privacy Settings",
         "enable_privacy_mode": "Anonymous reporting of errors and statistics"
+      },
+      "tts": {
+        "title": "Text-to-Speech Settings",
+        "enable": "Enable Text-to-Speech",
+        "enable.help": "Enable to convert text to speech",
+        "reset": "Reset",
+        "reset_title": "Reset Custom Voices and Models",
+        "reset_confirm": "Are you sure you want to reset all custom voices and models? This will delete all custom items you've added.",
+        "reset_success": "Reset successful",
+        "reset_help": "If voices or models display abnormally, try resetting all custom items",
+        "api_settings": "API Settings",
+        "service_type": "Service Type",
+        "service_type.openai": "OpenAI",
+        "service_type.edge": "Edge TTS",
+        "service_type.refresh": "Refresh TTS service type settings",
+        "service_type.refreshed": "TTS service type settings refreshed",
+        "api_key": "API Key",
+        "api_key.placeholder": "Enter OpenAI API key",
+        "api_url": "API URL",
+        "api_url.placeholder": "Example: https://api.openai.com/v1/audio/speech",
+        "edge_voice": "Edge TTS Voice",
+        "edge_voice.loading": "Loading...",
+        "edge_voice.refresh": "Refresh available voices",
+        "edge_voice.not_found": "No matching voices found",
+        "voice": "Voice",
+        "voice.placeholder": "Select a voice",
+        "voice_input_placeholder": "Enter voice",
+        "voice_add": "Add",
+        "voice_empty": "No custom voices yet, please add below",
+        "model": "Model",
+        "model.placeholder": "Select a model",
+        "model_input_placeholder": "Enter model",
+        "model_add": "Add",
+        "model_empty": "No custom models yet, please add below",
+        "filter_options": "Filter Options",
+        "filter.thinking_process": "Filter thinking process",
+        "filter.markdown": "Filter Markdown",
+        "filter.code_blocks": "Filter code blocks",
+        "filter.html_tags": "Filter HTML tags",
+        "max_text_length": "Maximum text length",
+        "test": "Test Speech",
+        "help": "Text-to-speech functionality supports converting text to natural-sounding speech.",
+        "learn_more": "Learn more"
       }
     },
     "translate": {
diff --git a/src/renderer/src/i18n/locales/zh-cn.json b/src/renderer/src/i18n/locales/zh-cn.json
index 7a74a6b938..fc53207c0b 100644
--- a/src/renderer/src/i18n/locales/zh-cn.json
+++ b/src/renderer/src/i18n/locales/zh-cn.json
@@ -1317,6 +1317,49 @@
       "privacy": {
         "title": "隐私设置",
         "enable_privacy_mode": "匿名发送错误报告和数据统计"
+      },
+      "tts": {
+        "title": "语音合成设置",
+        "enable": "启用语音合成",
+        "enable.help": "启用后可以将文本转换为语音",
+        "reset": "重置",
+        "reset_title": "重置自定义音色和模型",
+        "reset_confirm": "确定要重置所有自定义音色和模型吗？这将删除所有已添加的自定义项。",
+        "reset_success": "重置成功",
+        "reset_help": "如果音色或模型显示异常，可以尝试重置所有自定义项",
+        "api_settings": "API设置",
+        "service_type": "服务类型",
+        "service_type.openai": "OpenAI",
+        "service_type.edge": "Edge TTS",
+        "service_type.refresh": "刷新TTS服务类型设置",
+        "service_type.refreshed": "已刷新TTS服务类型设置",
+        "api_key": "API密钥",
+        "api_key.placeholder": "请输入OpenAI API密钥",
+        "api_url": "API地址",
+        "api_url.placeholder": "例如：https://api.openai.com/v1/audio/speech",
+        "edge_voice": "Edge TTS音色",
+        "edge_voice.loading": "加载中...",
+        "edge_voice.refresh": "刷新可用音色列表",
+        "edge_voice.not_found": "未找到匹配的音色",
+        "voice": "音色",
+        "voice.placeholder": "请选择音色",
+        "voice_input_placeholder": "输入音色",
+        "voice_add": "添加",
+        "voice_empty": "暂无自定义音色，请在下方添加",
+        "model": "模型",
+        "model.placeholder": "请选择模型",
+        "model_input_placeholder": "输入模型",
+        "model_add": "添加",
+        "model_empty": "暂无自定义模型，请在下方添加",
+        "filter_options": "过滤选项",
+        "filter.thinking_process": "过滤思考过程",
+        "filter.markdown": "过滤Markdown标记",
+        "filter.code_blocks": "过滤代码块",
+        "filter.html_tags": "过滤HTML标签",
+        "max_text_length": "最大文本长度",
+        "test": "测试语音",
+        "help": "语音合成功能支持将文本转换为自然语音。",
+        "learn_more": "了解更多"
       }
     },
     "translate": {
diff --git a/src/renderer/src/pages/home/Messages/MessageMenubar.tsx b/src/renderer/src/pages/home/Messages/MessageMenubar.tsx
index 31e8697712..a566da7750 100644
--- a/src/renderer/src/pages/home/Messages/MessageMenubar.tsx
+++ b/src/renderer/src/pages/home/Messages/MessageMenubar.tsx
@@ -8,6 +8,7 @@ import {
   MenuOutlined,
   QuestionCircleOutlined,
   SaveOutlined,
+  SoundOutlined,
   SyncOutlined,
   TranslationOutlined
 } from '@ant-design/icons'
@@ -15,11 +16,13 @@ import { UploadOutlined } from '@ant-design/icons'
 import ObsidianExportPopup from '@renderer/components/Popups/ObsidianExportPopup'
 import SelectModelPopup from '@renderer/components/Popups/SelectModelPopup'
 import TextEditPopup from '@renderer/components/Popups/TextEditPopup'
+import TTSButton from '@renderer/components/TTSButton'
 import { isReasoningModel } from '@renderer/config/models'
 import { TranslateLanguageOptions } from '@renderer/config/translate'
 import { useMessageOperations, useTopicLoading } from '@renderer/hooks/useMessageOperations'
 import { EVENT_NAMES, EventEmitter } from '@renderer/services/EventService'
 import { getMessageTitle, resetAssistantMessage } from '@renderer/services/MessagesService'
+import TTSService from '@renderer/services/TTSService'
 import { translateText } from '@renderer/services/TranslateService'
 import { RootState } from '@renderer/store'
 import type { Message, Model } from '@renderer/types'
@@ -61,6 +64,7 @@ const MessageMenubar: FC<Props> = (props) => {
   const { t } = useTranslation()
   const [copied, setCopied] = useState(false)
   const [isTranslating, setIsTranslating] = useState(false)
+  const [isSpeaking, setIsSpeaking] = useState(false)
   const [showRegenerateTooltip, setShowRegenerateTooltip] = useState(false)
   const [showDeleteTooltip, setShowDeleteTooltip] = useState(false)
   const assistantModel = assistant?.model
@@ -85,6 +89,9 @@ const MessageMenubar: FC<Props> = (props) => {
       }
   )
 
+  // 获取TTS设置
+  const ttsEnabled = useSelector((state: RootState) => state.settings.ttsEnabled)
+
   const onCopy = useCallback(
     (e: React.MouseEvent) => {
       e.stopPropagation()
@@ -181,6 +188,64 @@ const MessageMenubar: FC<Props> = (props) => {
     [isTranslating, message, editMessage, setStreamMessage, commitStreamMessage, clearStreamMessage, t]
   )
 
+  // 处理TTS功能
+  const handleTTS = useCallback(async () => {
+    console.log('点击TTS按钮，当前状态:', isSpeaking ? '正在播放' : '未播放')
+
+    if (isSpeaking) {
+      // 如果正在播放，则停止
+      console.log('正在播放，执行停止操作')
+      TTSService.stop()
+      setIsSpeaking(false)
+      return
+    }
+
+    // 先停止所有正在进行的TTS播放
+    console.log('开始新的播放，先停止现有播放')
+    TTSService.stop()
+
+    // 等待一下，确保之前的播放已经完全停止
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    setIsSpeaking(true)
+    try {
+      console.log('开始播放消息:', message.id)
+      await TTSService.speakFromMessage(message)
+
+      // 监听播放结束
+      let checkPlayingStatusInterval: number | null = null
+
+      const checkPlayingStatus = () => {
+        if (!TTSService.isCurrentlyPlaying()) {
+          console.log('TTS播放已结束，重置状态')
+          setIsSpeaking(false)
+          if (checkPlayingStatusInterval !== null) {
+            clearInterval(checkPlayingStatusInterval)
+            checkPlayingStatusInterval = null
+          }
+        }
+      }
+
+      checkPlayingStatusInterval = window.setInterval(checkPlayingStatus, 500) as unknown as number
+
+      // 添加一个安全机制，确保即使出错也会重置状态
+      setTimeout(() => {
+        if (isSpeaking) {
+          console.log('TTS播放超时，强制重置状态')
+          TTSService.stop()
+          setIsSpeaking(false)
+          if (checkPlayingStatusInterval !== null) {
+            clearInterval(checkPlayingStatusInterval)
+            checkPlayingStatusInterval = null
+          }
+        }
+      }, 30000) // 30秒后检查
+    } catch (error) {
+      console.error('TTS error:', error)
+      setIsSpeaking(false)
+    }
+  }, [isSpeaking, message])
+
   const dropdownItems = useMemo(
     () => [
       {
@@ -363,6 +428,9 @@ const MessageMenubar: FC<Props> = (props) => {
           </ActionButton>
         </Tooltip>
       )}
+      {isAssistantMessage && (
+        <TTSButton message={message} className="message-action-button" />
+      )}
       {!isUserMessage && (
         <Dropdown
           menu={{
@@ -390,6 +458,13 @@ const MessageMenubar: FC<Props> = (props) => {
           </Tooltip>
         </Dropdown>
       )}
+      {!isUserMessage && ttsEnabled && (
+        <Tooltip title={isSpeaking ? t('chat.tts.stop') : t('chat.tts.speak')} mouseEnterDelay={0.8}>
+          <ActionButton className="message-action-button" onClick={handleTTS}>
+            <SoundOutlined style={isSpeaking ? { color: 'var(--color-primary)' } : undefined} />
+          </ActionButton>
+        </Tooltip>
+      )}
       {isAssistantMessage && isGrouped && (
         <Tooltip title={t('chat.message.useful')} mouseEnterDelay={0.8}>
           <ActionButton className="message-action-button" onClick={onUseful}>
diff --git a/src/renderer/src/pages/home/Messages/Messages.tsx b/src/renderer/src/pages/home/Messages/Messages.tsx
index 1e921a18b9..574792119c 100644
--- a/src/renderer/src/pages/home/Messages/Messages.tsx
+++ b/src/renderer/src/pages/home/Messages/Messages.tsx
@@ -3,6 +3,7 @@ import { LOAD_MORE_COUNT } from '@renderer/config/constant'
 import db from '@renderer/databases'
 import { useAssistant } from '@renderer/hooks/useAssistant'
 import { useMessageOperations, useTopicLoading, useTopicMessages } from '@renderer/hooks/useMessageOperations'
+
 import { useSettings } from '@renderer/hooks/useSettings'
 import { useShortcut } from '@renderer/hooks/useShortcuts'
 import { autoRenameTopic, getTopic } from '@renderer/hooks/useTopic'
@@ -31,6 +32,7 @@ import MessageGroup from './MessageGroup'
 import NarrowLayout from './NarrowLayout'
 import NewTopicButton from './NewTopicButton'
 import Prompt from './Prompt'
+import TTSStopButton from './TTSStopButton'
 
 interface MessagesProps {
   assistant: Assistant
@@ -276,6 +278,7 @@ const Messages: React.FC<MessagesProps> = ({ assistant, topic, setActiveTopic })
       </NarrowLayout>
       {messageNavigation === 'anchor' && <MessageAnchorLine messages={displayMessages} />}
       {messageNavigation === 'buttons' && <ChatNavigation containerId="messages" />}
+      <TTSStopButton />
     </Container>
   )
 }
diff --git a/src/renderer/src/pages/home/Messages/TTSStopButton.tsx b/src/renderer/src/pages/home/Messages/TTSStopButton.tsx
new file mode 100644
index 0000000000..c9f0e86da9
--- /dev/null
+++ b/src/renderer/src/pages/home/Messages/TTSStopButton.tsx
@@ -0,0 +1,73 @@
+import { useTranslation } from 'react-i18next'
+import { SoundOutlined } from '@ant-design/icons'
+import { Button, Tooltip } from 'antd'
+import styled from 'styled-components'
+import { useCallback, useEffect, useState } from 'react'
+import TTSService from '@renderer/services/TTSService'
+
+const TTSStopButton: React.FC = () => {
+  const { t } = useTranslation()
+  const [isVisible, setIsVisible] = useState(false)
+
+  // 检查是否正在播放TTS
+  useEffect(() => {
+    const checkPlayingStatus = setInterval(() => {
+      const isPlaying = TTSService.isCurrentlyPlaying()
+      setIsVisible(isPlaying)
+    }, 500)
+
+    return () => clearInterval(checkPlayingStatus)
+  }, [])
+
+  // 停止TTS播放
+  const handleStopTTS = useCallback(async () => {
+    console.log('点击全局停止TTS按钮')
+
+    // 强制停止所有TTS播放
+    TTSService.stop()
+
+    // 等待一下，确保播放已经完全停止
+    await new Promise(resolve => setTimeout(resolve, 100))
+
+    // 再次检查并停止，确保强制停止
+    if (TTSService.isCurrentlyPlaying()) {
+      console.log('第一次停止未成功，再次尝试')
+      TTSService.stop()
+    }
+
+    // 立即隐藏按钮
+    setIsVisible(false)
+
+    // 显示停止消息
+    window.message.success({ content: t('chat.tts.stopped', { defaultValue: '已停止语音播放' }), key: 'tts-stopped' })
+  }, [t])
+
+  if (!isVisible) return null
+
+  return (
+    <StopButtonContainer>
+      <Tooltip title={t('chat.tts.stop_global')}>
+        <StyledButton
+          type="primary"
+          shape="circle"
+          icon={<SoundOutlined />}
+          onClick={handleStopTTS}
+          size="large"
+        />
+      </Tooltip>
+    </StopButtonContainer>
+  )
+}
+
+const StopButtonContainer = styled.div`
+  position: fixed;
+  bottom: 100px;
+  right: 20px;
+  z-index: 1000;
+`
+
+const StyledButton = styled(Button)`
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+`
+
+export default TTSStopButton
diff --git a/src/renderer/src/pages/settings/TTSSettings/TTSSettings.tsx b/src/renderer/src/pages/settings/TTSSettings/TTSSettings.tsx
new file mode 100644
index 0000000000..3418bdb97a
--- /dev/null
+++ b/src/renderer/src/pages/settings/TTSSettings/TTSSettings.tsx
@@ -0,0 +1,705 @@
+import { PlusOutlined, ReloadOutlined, SoundOutlined } from '@ant-design/icons'
+import { useTheme } from '@renderer/context/ThemeProvider'
+import store, { useAppDispatch } from '@renderer/store'
+import {
+  addTtsCustomModel,
+  addTtsCustomVoice,
+  removeTtsCustomModel,
+  removeTtsCustomVoice,
+  resetTtsCustomValues,
+  setTtsApiKey,
+  setTtsApiUrl,
+  setTtsEdgeVoice,
+  setTtsEnabled,
+  setTtsFilterOptions,
+  setTtsModel,
+  setTtsServiceType,
+  setTtsVoice
+} from '@renderer/store/settings'
+import { Button, Form, Input, Select, Space, Switch, Tag, message } from 'antd'
+import { FC, useState, useEffect } from 'react'
+import { useTranslation } from 'react-i18next'
+import { useSelector } from 'react-redux'
+import styled from 'styled-components'
+
+import { SettingContainer, SettingDivider, SettingGroup, SettingHelpText, SettingRow, SettingRowTitle, SettingTitle } from '..'
+import TTSService from '@renderer/services/TTSService'
+
+const CustomVoiceInput = styled.div`
+  margin-top: 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+`
+
+const TagsContainer = styled.div`
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 8px;
+  margin-bottom: 16px;
+`
+
+const EmptyText = styled.div`
+  color: rgba(0, 0, 0, 0.45);
+  padding: 4px 0;
+`
+
+const InputGroup = styled.div`
+  display: flex;
+  gap: 8px;
+  margin-bottom: 8px;
+`
+
+const FlexContainer = styled.div`
+  display: flex;
+  gap: 8px;
+`
+
+const FilterOptionItem = styled.div`
+  margin-bottom: 16px;
+`
+
+const LengthLabel = styled.span`
+  margin-right: 8px;
+`
+
+const LoadingText = styled.div`
+  margin-top: 8px;
+  color: #999;
+`
+
+const VoiceSelectContainer = styled.div`
+  display: flex;
+  gap: 8px;
+  margin-bottom: 8px;
+`
+
+const TTSSettings: FC = () => {
+  const { t } = useTranslation()
+  const { theme } = useTheme()
+  const dispatch = useAppDispatch()
+
+  // 从Redux获取TTS设置
+  const ttsEnabled = useSelector((state: any) => state.settings.ttsEnabled)
+  const ttsServiceType = useSelector((state: any) => state.settings.ttsServiceType || 'openai')
+  const ttsApiKey = useSelector((state: any) => state.settings.ttsApiKey)
+  const ttsApiUrl = useSelector((state: any) => state.settings.ttsApiUrl)
+  const ttsVoice = useSelector((state: any) => state.settings.ttsVoice)
+  const ttsModel = useSelector((state: any) => state.settings.ttsModel)
+  const ttsEdgeVoice = useSelector((state: any) => state.settings.ttsEdgeVoice || 'zh-CN-XiaoxiaoNeural')
+  const ttsCustomVoices = useSelector((state: any) => state.settings.ttsCustomVoices || [])
+  const ttsCustomModels = useSelector((state: any) => state.settings.ttsCustomModels || [])
+  const ttsFilterOptions = useSelector((state: any) => state.settings.ttsFilterOptions || {
+    filterThinkingProcess: true,
+    filterMarkdown: true,
+    filterCodeBlocks: true,
+    filterHtmlTags: true,
+    maxTextLength: 4000
+  })
+
+  // 新增自定义音色和模型的状态
+  const [newVoice, setNewVoice] = useState('')
+  const [newModel, setNewModel] = useState('')
+
+  // 浏览器可用的语音列表
+  const [availableVoices, setAvailableVoices] = useState<{ label: string; value: string }[]>([])
+
+  // 预定义的Edge TTS音色列表
+  const predefinedVoices = [
+    { label: '小晓 (女声, 中文)', value: 'zh-CN-XiaoxiaoNeural' },
+    { label: '云扬 (男声, 中文)', value: 'zh-CN-YunyangNeural' },
+    { label: '晓晓 (女声, 中文)', value: 'zh-CN-XiaoxiaoNeural' },
+    { label: '晓涵 (女声, 中文)', value: 'zh-CN-XiaohanNeural' },
+    { label: '晓诗 (女声, 中文)', value: 'zh-CN-XiaoshuangNeural' },
+    { label: '晓瑞 (女声, 中文)', value: 'zh-CN-XiaoruiNeural' },
+    { label: '晓墨 (女声, 中文)', value: 'zh-CN-XiaomoNeural' },
+    { label: '晓然 (男声, 中文)', value: 'zh-CN-XiaoranNeural' },
+    { label: '晓坤 (男声, 中文)', value: 'zh-CN-XiaokunNeural' },
+    { label: 'Aria (Female, English)', value: 'en-US-AriaNeural' },
+    { label: 'Guy (Male, English)', value: 'en-US-GuyNeural' },
+    { label: 'Jenny (Female, English)', value: 'en-US-JennyNeural' },
+    { label: 'Ana (Female, Spanish)', value: 'es-ES-ElviraNeural' },
+    { label: 'Ichiro (Male, Japanese)', value: 'ja-JP-KeitaNeural' },
+    { label: 'Nanami (Female, Japanese)', value: 'ja-JP-NanamiNeural' },
+    // 添加更多常用的语音
+    { label: 'Microsoft David (en-US)', value: 'Microsoft David Desktop - English (United States)' },
+    { label: 'Microsoft Zira (en-US)', value: 'Microsoft Zira Desktop - English (United States)' },
+    { label: 'Microsoft Mark (en-US)', value: 'Microsoft Mark Online (Natural) - English (United States)' },
+    { label: 'Microsoft Aria (en-US)', value: 'Microsoft Aria Online (Natural) - English (United States)' },
+    { label: 'Google US English', value: 'Google US English' },
+    { label: 'Google UK English Female', value: 'Google UK English Female' },
+    { label: 'Google UK English Male', value: 'Google UK English Male' },
+    { label: 'Google 日本語', value: 'Google 日本語' },
+    { label: 'Google 普通话（中国大陆）', value: 'Google 普通话（中国大陆）' },
+    { label: 'Google 粤語（香港）', value: 'Google 粤語（香港）' }
+  ]
+
+  // 获取浏览器可用的语音列表
+  const getVoices = () => {
+    if (typeof window !== 'undefined' && 'speechSynthesis' in window) {
+      // 先触发一下语音合成引擎，确保它已经初始化
+      window.speechSynthesis.cancel()
+
+      // 获取浏览器可用的语音列表
+      const voices = window.speechSynthesis.getVoices()
+      console.log('获取到的语音列表:', voices)
+      console.log('语音列表长度:', voices.length)
+
+      // 转换浏览器语音列表为选项格式
+      const browserVoices = voices.map(voice => ({
+        label: `${voice.name} (${voice.lang})${voice.default ? ' - 默认' : ''}`,
+        value: voice.name,
+        lang: voice.lang,
+        isNative: true // 标记为浏览器原生语音
+      }))
+
+      // 添加语言信息到预定义语音
+      const enhancedPredefinedVoices = predefinedVoices.map(voice => ({
+        ...voice,
+        lang: voice.value.split('-').slice(0, 2).join('-'),
+        isNative: false // 标记为非浏览器原生语音
+      }))
+
+      // 合并所有语音列表
+      let allVoices = [...browserVoices]
+
+      // 如果浏览器语音少于5个，添加预定义语音
+      if (browserVoices.length < 5) {
+        allVoices = [...browserVoices, ...enhancedPredefinedVoices]
+      }
+
+      // 去除重复项，优先保留浏览器原生语音
+      const uniqueVoices = allVoices.filter((voice, index, self) => {
+        const firstIndex = self.findIndex(v => v.value === voice.value)
+        // 如果是原生语音或者是第一次出现，则保留
+        return voice.isNative || firstIndex === index
+      })
+
+      // 按语言分组并排序
+      const groupedVoices = uniqueVoices.sort((a, b) => {
+        // 先按语言排序
+        if (a.lang !== b.lang) {
+          return a.lang.localeCompare(b.lang)
+        }
+        // 同语言下，原生语音优先
+        if (a.isNative !== b.isNative) {
+          return a.isNative ? -1 : 1
+        }
+        // 最后按名称排序
+        return a.label.localeCompare(b.label)
+      })
+
+      setAvailableVoices(groupedVoices)
+      console.log('设置可用语音列表:', groupedVoices)
+    } else {
+      // 如果浏览器不支持Web Speech API，使用预定义的语音列表
+      console.log('浏览器不支持Web Speech API，使用预定义的语音列表')
+      setAvailableVoices(predefinedVoices)
+    }
+  }
+
+  // 刷新语音列表
+  const refreshVoices = () => {
+    console.log('手动刷新语音列表')
+    message.loading({ content: t('settings.tts.edge_voice.refreshing', { defaultValue: '正在刷新语音列表...' }), key: 'refresh-voices' })
+
+    // 先清空当前列表
+    setAvailableVoices([])
+
+    // 强制重新加载语音列表
+    if (typeof window !== 'undefined' && 'speechSynthesis' in window) {
+      window.speechSynthesis.cancel()
+
+      // 尝试多次获取语音列表
+      setTimeout(() => {
+        getVoices()
+        setTimeout(() => {
+          getVoices()
+          message.success({ content: t('settings.tts.edge_voice.refreshed', { defaultValue: '语音列表已刷新' }), key: 'refresh-voices' })
+        }, 1000)
+      }, 500)
+    } else {
+      // 如果浏览器不支持Web Speech API，使用预定义的语音列表
+      setAvailableVoices(predefinedVoices)
+      message.success({ content: t('settings.tts.edge_voice.refreshed', { defaultValue: '语音列表已刷新' }), key: 'refresh-voices' })
+    }
+  }
+
+  useEffect(() => {
+    // 初始化语音合成引擎
+    if (typeof window !== 'undefined' && 'speechSynthesis' in window) {
+      // 触发语音合成引擎初始化
+      window.speechSynthesis.cancel()
+
+      // 设置voiceschanged事件处理程序
+      const voicesChangedHandler = () => {
+        console.log('检测到voiceschanged事件，重新获取语音列表')
+        getVoices()
+      }
+
+      // 添加事件监听器
+      window.speechSynthesis.onvoiceschanged = voicesChangedHandler
+
+      // 立即获取可用的语音
+      getVoices()
+
+      // 创建多个定时器，在不同时间点尝试获取语音列表
+      // 这是因为不同浏览器加载语音列表的时间不同
+      const timers = [
+        setTimeout(() => getVoices(), 500),
+        setTimeout(() => getVoices(), 1000),
+        setTimeout(() => getVoices(), 2000)
+      ]
+
+      return () => {
+        // 清理事件监听器和定时器
+        window.speechSynthesis.onvoiceschanged = null
+        timers.forEach(timer => clearTimeout(timer))
+      }
+    } else {
+      // 如果浏览器不支持Web Speech API，使用预定义的语音列表
+      setAvailableVoices(predefinedVoices)
+      return () => {}
+    }
+  }, [])
+
+  // 测试TTS功能
+  const testTTS = async () => {
+    if (!ttsEnabled) {
+      window.message.error({ content: t('settings.tts.error.not_enabled'), key: 'tts-test' })
+      return
+    }
+
+    // 获取最新的服务类型设置
+    const latestSettings = store.getState().settings
+    const currentServiceType = latestSettings.ttsServiceType || 'openai'
+    console.log('测试TTS时使用的服务类型:', currentServiceType)
+    console.log('测试时完整TTS设置:', {
+      ttsEnabled: latestSettings.ttsEnabled,
+      ttsServiceType: latestSettings.ttsServiceType,
+      ttsApiKey: latestSettings.ttsApiKey ? '已设置' : '未设置',
+      ttsVoice: latestSettings.ttsVoice,
+      ttsModel: latestSettings.ttsModel,
+      ttsEdgeVoice: latestSettings.ttsEdgeVoice
+    })
+
+    // 根据服务类型检查必要的参数
+    if (currentServiceType === 'openai') {
+      if (!ttsApiKey) {
+        window.message.error({ content: t('settings.tts.error.no_api_key'), key: 'tts-test' })
+        return
+      }
+
+      if (!ttsVoice) {
+        window.message.error({ content: t('settings.tts.error.no_voice'), key: 'tts-test' })
+        return
+      }
+
+      if (!ttsModel) {
+        window.message.error({ content: t('settings.tts.error.no_model'), key: 'tts-test' })
+        return
+      }
+    } else if (currentServiceType === 'edge') {
+      if (!ttsEdgeVoice) {
+        window.message.error({ content: t('settings.tts.error.no_edge_voice'), key: 'tts-test' })
+        return
+      }
+    }
+
+    await TTSService.speak('这是一段测试语音，用于测试TTS功能是否正常工作。')
+  }
+
+  // 添加自定义音色
+  const handleAddVoice = () => {
+    if (!newVoice) {
+      window.message.error({ content: '请输入音色', key: 'add-voice' })
+      return
+    }
+
+    // 确保添加的是字符串
+    const voiceStr = typeof newVoice === 'string' ? newVoice : String(newVoice);
+    dispatch(addTtsCustomVoice(voiceStr))
+    setNewVoice('')
+  }
+
+  // 添加自定义模型
+  const handleAddModel = () => {
+    if (!newModel) {
+      window.message.error({ content: '请输入模型', key: 'add-model' })
+      return
+    }
+
+    // 确保添加的是字符串
+    const modelStr = typeof newModel === 'string' ? newModel : String(newModel);
+    dispatch(addTtsCustomModel(modelStr))
+    setNewModel('')
+  }
+
+  // 删除自定义音色
+  const handleRemoveVoice = (voice: string) => {
+    // 确保删除的是字符串
+    const voiceStr = typeof voice === 'string' ? voice : String(voice);
+    dispatch(removeTtsCustomVoice(voiceStr))
+  }
+
+  // 删除自定义模型
+  const handleRemoveModel = (model: string) => {
+    // 确保删除的是字符串
+    const modelStr = typeof model === 'string' ? model : String(model);
+    dispatch(removeTtsCustomModel(modelStr))
+  }
+
+  return (
+    <SettingContainer theme={theme}>
+      <SettingTitle>
+        <Space>
+          <SoundOutlined />
+          {t('settings.tts.title')}
+        </Space>
+      </SettingTitle>
+
+      <SettingDivider />
+
+      <SettingGroup>
+        <SettingRow>
+          <SettingRowTitle>{t('settings.tts.enable')}</SettingRowTitle>
+          <Switch checked={ttsEnabled} onChange={(checked) => dispatch(setTtsEnabled(checked))} />
+        </SettingRow>
+        <SettingHelpText>{t('settings.tts.enable.help')}</SettingHelpText>
+      </SettingGroup>
+
+      {/* 重置按钮 */}
+      <SettingGroup>
+        <SettingRow>
+          <SettingRowTitle>{t('settings.tts.reset_title')}</SettingRowTitle>
+          <Button
+            danger
+            onClick={() => {
+              if (window.confirm(t('settings.tts.reset_confirm'))) {
+                dispatch(resetTtsCustomValues());
+                window.message.success({ content: t('settings.tts.reset_success'), key: 'reset-tts' });
+              }
+            }}
+          >
+            {t('settings.tts.reset')}
+          </Button>
+        </SettingRow>
+        <SettingHelpText>{t('settings.tts.reset_help')}</SettingHelpText>
+      </SettingGroup>
+
+      <SettingDivider />
+
+      <SettingGroup>
+        <SettingRowTitle>{t('settings.tts.api_settings')}</SettingRowTitle>
+        <Form layout="vertical" style={{ width: '100%' }}>
+          {/* TTS服务类型选择 */}
+          <Form.Item label={t('settings.tts.service_type')} style={{ marginBottom: 16 }}>
+            <FlexContainer>
+              <Select
+                value={ttsServiceType}
+                onChange={(value: string) => {
+                  console.log('切换TTS服务类型为:', value)
+                  // 先将新的服务类型写入Redux状态
+                  dispatch(setTtsServiceType(value))
+
+                  // 等待一下，确保状态已更新
+                  setTimeout(() => {
+                    // 验证状态是否正确更新
+                    const currentType = store.getState().settings.ttsServiceType
+                    console.log('更新后的TTS服务类型:', currentType)
+
+                    // 如果状态没有正确更新，再次尝试
+                    if (currentType !== value) {
+                      console.log('状态未正确更新，再次尝试')
+                      dispatch(setTtsServiceType(value))
+                    }
+                  }, 100)
+                }}
+                options={[
+                  { label: t('settings.tts.service_type.openai'), value: 'openai' },
+                  { label: t('settings.tts.service_type.edge'), value: 'edge' }
+                ]}
+                disabled={!ttsEnabled}
+                style={{ flex: 1 }}
+              />
+              <Button
+                icon={<ReloadOutlined />}
+                onClick={() => {
+                  // 强制刷新当前服务类型设置
+                  const currentType = store.getState().settings.ttsServiceType
+                  console.log('强制刷新TTS服务类型:', currentType)
+                  dispatch(setTtsServiceType(currentType))
+                  window.message.success({ content: t('settings.tts.service_type.refreshed', { defaultValue: '已刷新TTS服务类型设置' }), key: 'tts-refresh' })
+                }}
+                disabled={!ttsEnabled}
+                title={t('settings.tts.service_type.refresh', { defaultValue: '刷新TTS服务类型设置' })}
+              />
+            </FlexContainer>
+          </Form.Item>
+
+          {/* OpenAI TTS设置 */}
+          {ttsServiceType === 'openai' && (
+            <>
+              <Form.Item label={t('settings.tts.api_key')} style={{ marginBottom: 16 }}>
+                <Input.Password
+                  value={ttsApiKey}
+                  onChange={(e) => dispatch(setTtsApiKey(e.target.value))}
+                  placeholder={t('settings.tts.api_key.placeholder')}
+                  disabled={!ttsEnabled}
+                />
+              </Form.Item>
+              <Form.Item label={t('settings.tts.api_url')} style={{ marginBottom: 16 }}>
+                <Input
+                  value={ttsApiUrl}
+                  onChange={(e) => dispatch(setTtsApiUrl(e.target.value))}
+                  placeholder={t('settings.tts.api_url.placeholder')}
+                  disabled={!ttsEnabled}
+                />
+              </Form.Item>
+            </>
+          )}
+
+          {/* Edge TTS设置 */}
+          {ttsServiceType === 'edge' && (
+            <Form.Item label={t('settings.tts.edge_voice')} style={{ marginBottom: 16 }}>
+              <VoiceSelectContainer>
+                <Select
+                  value={ttsEdgeVoice}
+                  onChange={(value) => dispatch(setTtsEdgeVoice(value))}
+                  options={availableVoices.length > 0 ? availableVoices : [
+                    { label: t('settings.tts.edge_voice.loading'), value: '' }
+                  ]}
+                  disabled={!ttsEnabled}
+                  style={{ flex: 1 }}
+                  showSearch
+                  optionFilterProp="label"
+                  placeholder={availableVoices.length === 0 ? t('settings.tts.edge_voice.loading') : t('settings.tts.voice.placeholder')}
+                  notFoundContent={availableVoices.length === 0 ? t('settings.tts.edge_voice.loading') : t('settings.tts.edge_voice.not_found')}
+                />
+                <Button
+                  icon={<ReloadOutlined />}
+                  onClick={refreshVoices}
+                  disabled={!ttsEnabled}
+                  title={t('settings.tts.edge_voice.refresh')}
+                />
+              </VoiceSelectContainer>
+              {availableVoices.length === 0 && (
+                <LoadingText>
+                  {t('settings.tts.edge_voice.loading')}
+                </LoadingText>
+              )}
+            </Form.Item>
+          )}
+
+          {/* OpenAI TTS的音色和模型设置 */}
+          {ttsServiceType === 'openai' && (
+            <>
+              {/* 音色选择 */}
+              <Form.Item label={t('settings.tts.voice')} style={{ marginBottom: 8 }}>
+                <Select
+                  value={ttsVoice}
+                  onChange={(value) => dispatch(setTtsVoice(value))}
+                  options={ttsCustomVoices.map((voice: any) => {
+                    // 确保voice是字符串
+                    const voiceStr = typeof voice === 'string' ? voice : String(voice);
+                    return { label: voiceStr, value: voiceStr };
+                  })}
+                  disabled={!ttsEnabled}
+                  style={{ width: '100%' }}
+                  placeholder={t('settings.tts.voice.placeholder')}
+                  showSearch
+                  optionFilterProp="label"
+                  allowClear
+                />
+              </Form.Item>
+
+              {/* 自定义音色列表 */}
+              <TagsContainer>
+                {ttsCustomVoices && ttsCustomVoices.length > 0 ? (
+                  ttsCustomVoices.map((voice: any, index: number) => {
+                    // 确保voice是字符串
+                    const voiceStr = typeof voice === 'string' ? voice : String(voice);
+                    return (
+                      <Tag
+                        key={`${voiceStr}-${index}`}
+                        closable
+                        onClose={() => handleRemoveVoice(voiceStr)}
+                        style={{ padding: '4px 8px' }}
+                      >
+                        {voiceStr}
+                      </Tag>
+                    );
+                  })
+                ) : (
+                  <EmptyText>
+                    {t('settings.tts.voice_empty')}
+                  </EmptyText>
+                )}
+              </TagsContainer>
+
+              {/* 添加自定义音色 */}
+              <CustomVoiceInput>
+                <InputGroup>
+                  <Input
+                    placeholder={t('settings.tts.voice_input_placeholder')}
+                    value={newVoice}
+                    onChange={(e) => setNewVoice(e.target.value)}
+                    disabled={!ttsEnabled}
+                    style={{ flex: 1 }}
+                  />
+                  <Button
+                    type="primary"
+                    icon={<PlusOutlined />}
+                    onClick={handleAddVoice}
+                    disabled={!ttsEnabled || !newVoice}
+                  >
+                    {t('settings.tts.voice_add')}
+                  </Button>
+                </InputGroup>
+              </CustomVoiceInput>
+
+              {/* 模型选择 */}
+              <Form.Item label={t('settings.tts.model')} style={{ marginBottom: 8, marginTop: 16 }}>
+                <Select
+                  value={ttsModel}
+                  onChange={(value) => dispatch(setTtsModel(value))}
+                  options={ttsCustomModels.map((model: any) => {
+                    // 确保model是字符串
+                    const modelStr = typeof model === 'string' ? model : String(model);
+                    return { label: modelStr, value: modelStr };
+                  })}
+                  disabled={!ttsEnabled}
+                  style={{ width: '100%' }}
+                  placeholder={t('settings.tts.model.placeholder')}
+                  showSearch
+                  optionFilterProp="label"
+                  allowClear
+                />
+              </Form.Item>
+
+              {/* 自定义模型列表 */}
+              <TagsContainer>
+                {ttsCustomModels && ttsCustomModels.length > 0 ? (
+                  ttsCustomModels.map((model: any, index: number) => {
+                    // 确保model是字符串
+                    const modelStr = typeof model === 'string' ? model : String(model);
+                    return (
+                      <Tag
+                        key={`${modelStr}-${index}`}
+                        closable
+                        onClose={() => handleRemoveModel(modelStr)}
+                        style={{ padding: '4px 8px' }}
+                      >
+                        {modelStr}
+                      </Tag>
+                    );
+                  })
+                ) : (
+                  <EmptyText>
+                    {t('settings.tts.model_empty')}
+                  </EmptyText>
+                )}
+              </TagsContainer>
+
+              {/* 添加自定义模型 */}
+              <CustomVoiceInput>
+                <InputGroup>
+                  <Input
+                    placeholder={t('settings.tts.model_input_placeholder')}
+                    value={newModel}
+                    onChange={(e) => setNewModel(e.target.value)}
+                    disabled={!ttsEnabled}
+                    style={{ flex: 1 }}
+                  />
+                  <Button
+                    type="primary"
+                    icon={<PlusOutlined />}
+                    onClick={handleAddModel}
+                    disabled={!ttsEnabled || !newModel}
+                  >
+                    {t('settings.tts.model_add')}
+                  </Button>
+                </InputGroup>
+              </CustomVoiceInput>
+            </>
+          )}
+
+          {/* TTS过滤选项 */}
+          <Form.Item label={t('settings.tts.filter_options')} style={{ marginTop: 24, marginBottom: 8 }}>
+            <FilterOptionItem>
+              <Switch
+                checked={ttsFilterOptions.filterThinkingProcess}
+                onChange={(checked) => dispatch(setTtsFilterOptions({ filterThinkingProcess: checked }))}
+                disabled={!ttsEnabled}
+              /> {t('settings.tts.filter.thinking_process')}
+            </FilterOptionItem>
+            <FilterOptionItem>
+              <Switch
+                checked={ttsFilterOptions.filterMarkdown}
+                onChange={(checked) => dispatch(setTtsFilterOptions({ filterMarkdown: checked }))}
+                disabled={!ttsEnabled}
+              /> {t('settings.tts.filter.markdown')}
+            </FilterOptionItem>
+            <FilterOptionItem>
+              <Switch
+                checked={ttsFilterOptions.filterCodeBlocks}
+                onChange={(checked) => dispatch(setTtsFilterOptions({ filterCodeBlocks: checked }))}
+                disabled={!ttsEnabled}
+              /> {t('settings.tts.filter.code_blocks')}
+            </FilterOptionItem>
+            <FilterOptionItem>
+              <Switch
+                checked={ttsFilterOptions.filterHtmlTags}
+                onChange={(checked) => dispatch(setTtsFilterOptions({ filterHtmlTags: checked }))}
+                disabled={!ttsEnabled}
+              /> {t('settings.tts.filter.html_tags')}
+            </FilterOptionItem>
+            <FilterOptionItem>
+              <LengthLabel>{t('settings.tts.max_text_length')}:</LengthLabel>
+              <Select
+                value={ttsFilterOptions.maxTextLength}
+                onChange={(value) => dispatch(setTtsFilterOptions({ maxTextLength: value }))}
+                disabled={!ttsEnabled}
+                style={{ width: 120 }}
+                options={[
+                  { label: '1000', value: 1000 },
+                  { label: '2000', value: 2000 },
+                  { label: '4000', value: 4000 },
+                  { label: '8000', value: 8000 },
+                  { label: '16000', value: 16000 },
+                ]}
+              />
+            </FilterOptionItem>
+          </Form.Item>
+
+          <Form.Item style={{ marginTop: 16 }}>
+            <Button
+              type="primary"
+              onClick={testTTS}
+              disabled={
+                !ttsEnabled ||
+                (ttsServiceType === 'openai' && (!ttsApiKey || !ttsVoice || !ttsModel)) ||
+                (ttsServiceType === 'edge' && !ttsEdgeVoice)
+              }
+            >
+              {t('settings.tts.test')}
+            </Button>
+          </Form.Item>
+        </Form>
+      </SettingGroup>
+
+      <SettingDivider />
+
+      <SettingHelpText>
+        {t('settings.tts.help')}
+        <br />
+        <a href="https://platform.openai.com/docs/guides/text-to-speech" target="_blank" rel="noopener noreferrer">
+          {t('settings.tts.learn_more')}
+        </a>
+      </SettingHelpText>
+    </SettingContainer>
+  )
+}
+
+export default TTSSettings
diff --git a/src/renderer/src/services/TTSService.ts b/src/renderer/src/services/TTSService.ts
new file mode 100644
index 0000000000..52d101fd0d
--- /dev/null
+++ b/src/renderer/src/services/TTSService.ts
@@ -0,0 +1,1102 @@
+import i18n from '@renderer/i18n'
+import store from '@renderer/store'
+import { Message } from '@renderer/types'
+
+/**
+ * TTS服务，用于将文本转换为语音
+ */
+class TTSService {
+  private audio: HTMLAudioElement | null = null
+  private isPlaying = false
+
+  /**
+   * 将文本转换为语音并播放
+   * @param text 要转换的文本
+   */
+  speak = async (text: string): Promise<void> => {
+    try {
+      const { ttsEnabled, ttsServiceType, ttsApiKey, ttsApiUrl, ttsVoice, ttsModel, ttsEdgeVoice } = store.getState().settings
+
+      if (!ttsEnabled) {
+        window.message.error({ content: i18n.t('settings.tts.error.not_enabled'), key: 'tts-error' })
+        return
+      }
+
+      // 停止当前正在播放的音频
+      this.stop()
+
+      // 显示加载提示
+      window.message.loading({ content: i18n.t('settings.tts.processing', { defaultValue: '正在生成语音...' }), key: 'tts-loading' })
+
+      // 初始化为空的Blob，防止类型错误
+      let audioBlob: Blob = new Blob([], { type: 'audio/wav' })
+
+      // 根据服务类型选择不同的TTS实现
+      console.log('当前TTS服务类型:', ttsServiceType)
+
+      // 确保ttsServiceType是有效的值
+      // 从存储中重新获取服务类型，确保使用最新的设置
+      // 强制使用最新的状态，而不是传入的参数
+      const latestSettings = store.getState().settings
+      const serviceType = latestSettings.ttsServiceType || 'openai'
+      console.log('最终使用的TTS服务类型:', serviceType)
+      console.log('当前完整TTS设置:', {
+        ttsEnabled: latestSettings.ttsEnabled,
+        ttsServiceType: latestSettings.ttsServiceType,
+        ttsApiKey: latestSettings.ttsApiKey ? '已设置' : '未设置',
+        ttsVoice: latestSettings.ttsVoice,
+        ttsModel: latestSettings.ttsModel,
+        ttsEdgeVoice: latestSettings.ttsEdgeVoice
+      })
+
+      if (serviceType === 'openai') {
+        // 检查OpenAI TTS所需的参数
+        if (!ttsApiKey) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_api_key'), key: 'tts-error' })
+          return
+        }
+
+        if (!ttsApiUrl) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_api_url'), key: 'tts-error' })
+          return
+        }
+
+        if (!ttsVoice) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_voice'), key: 'tts-error' })
+          return
+        }
+
+        if (!ttsModel) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_model'), key: 'tts-error' })
+          return
+        }
+
+        // 准备OpenAI TTS请求体
+        const requestBody: any = {
+          input: text
+        }
+
+        // 只有当模型和音色不为空时才添加到请求体中
+        if (ttsModel) {
+          requestBody.model = ttsModel
+        }
+
+        if (ttsVoice) {
+          requestBody.voice = ttsVoice
+        }
+
+        // 调用OpenAI TTS API
+        const response = await fetch(ttsApiUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${ttsApiKey}`
+          },
+          body: JSON.stringify(requestBody)
+        })
+
+        if (!response.ok) {
+          const errorData = await response.json()
+          throw new Error(errorData.error?.message || 'OpenAI语音合成失败')
+        }
+
+        // 获取音频数据
+        console.log('获取到OpenAI TTS响应，开始处理音频数据')
+        audioBlob = await response.blob()
+      } else if (serviceType === 'edge') {
+        // 使用浏览器的Web Speech API
+        if (!ttsEdgeVoice) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_edge_voice'), key: 'tts-error' })
+          return
+        }
+
+        try {
+          console.log('使用浏览器TTS生成语音，音色:', ttsEdgeVoice)
+
+          // 使用Web Speech API
+          if (!('speechSynthesis' in window)) {
+            throw new Error(i18n.t('settings.tts.error.browser_not_support'))
+          }
+
+          // 停止当前正在播放的语音
+          window.speechSynthesis.cancel()
+
+          // 创建语音合成器实例
+          const utterance = new SpeechSynthesisUtterance(text)
+
+          // 获取可用的语音合成声音
+          let voices = window.speechSynthesis.getVoices()
+          console.log('初始可用的语音合成声音:', voices)
+
+          // 如果没有可用的声音，等待声音加载
+          if (voices.length === 0) {
+            try {
+              await new Promise<void>((resolve) => {
+                const voicesChangedHandler = () => {
+                  window.speechSynthesis.onvoiceschanged = null
+                  resolve()
+                }
+
+                window.speechSynthesis.onvoiceschanged = voicesChangedHandler
+
+                // 设置超时，防止无限等待
+                setTimeout(() => {
+                  window.speechSynthesis.onvoiceschanged = null
+                  resolve() // 超时后仍然继续，而不是报错
+                }, 2000)
+              })
+            } catch (e) {
+              console.warn('等待语音加载时出错:', e)
+            }
+          }
+
+          // 重新获取声音列表
+          const updatedVoices = window.speechSynthesis.getVoices()
+          console.log('更新后的声音列表:', updatedVoices)
+
+          // 尝试找到指定的声音
+          let selectedVoice: SpeechSynthesisVoice | undefined = undefined
+
+          // 输出所有可用的语音信息，便于调试
+          console.log('所有可用的语音信息:')
+          updatedVoices.forEach((voice, index) => {
+            console.log(`语音 ${index + 1}:`, {
+              name: voice.name,
+              lang: voice.lang,
+              default: voice.default,
+              localService: voice.localService,
+              voiceURI: voice.voiceURI
+            })
+          })
+
+          // 记录当前选择的音色，便于调试
+          console.log('当前选择的Edge TTS音色:', ttsEdgeVoice)
+
+          // 创建一个音色映射表，将Neural音色映射到浏览器原生音色
+          const voiceMapping: Record<string, string[]> = {
+            // 中文音色映射
+            'zh-CN-XiaoxiaoNeural': ['Microsoft Yaoyao', 'Microsoft Huihui', 'Google 普通话'],
+            'zh-CN-YunyangNeural': ['Microsoft Kangkang', 'Google 普通话'],
+            'zh-CN-XiaohanNeural': ['Microsoft Yaoyao', 'Microsoft Huihui', 'Google 普通话'],
+            'zh-CN-XiaoshuangNeural': ['Microsoft Yaoyao', 'Microsoft Huihui', 'Google 普通话'],
+            'zh-CN-XiaoruiNeural': ['Microsoft Yaoyao', 'Microsoft Huihui', 'Google 普通话'],
+            'zh-CN-XiaomoNeural': ['Microsoft Yaoyao', 'Microsoft Huihui', 'Google 普通话'],
+            'zh-CN-XiaoranNeural': ['Microsoft Kangkang', 'Google 普通话'],
+            'zh-CN-XiaokunNeural': ['Microsoft Kangkang', 'Google 普通话'],
+
+            // 英文音色映射
+            'en-US-AriaNeural': ['Microsoft Zira', 'Google US English', 'Google UK English Female'],
+            'en-US-GuyNeural': ['Microsoft David', 'Google UK English Male'],
+            'en-US-JennyNeural': ['Microsoft Zira', 'Google US English', 'Google UK English Female'],
+
+            // 西班牙语音色映射
+            'es-ES-ElviraNeural': ['Google español'],
+
+            // 日语音色映射
+            'ja-JP-KeitaNeural': ['Google 日本語'],
+            'ja-JP-NanamiNeural': ['Google 日本語']
+          }
+
+          // 先尝试使用映射表进行匹配
+          if (ttsEdgeVoice && voiceMapping[ttsEdgeVoice]) {
+            console.log('使用映射表匹配音色:', ttsEdgeVoice)
+
+            // 遍历映射表中的候选音色
+            for (const candidateVoice of voiceMapping[ttsEdgeVoice]) {
+              // 尝试找到匹配的音色
+              const matchedVoice = updatedVoices.find(voice =>
+                voice.name.includes(candidateVoice) ||
+                voice.voiceURI.includes(candidateVoice)
+              )
+
+              if (matchedVoice) {
+                selectedVoice = matchedVoice
+                console.log('使用映射表找到匹配的音色:', matchedVoice.name)
+                break
+              }
+            }
+          }
+
+          // 如果映射表没有找到匹配，尝试精确匹配名称
+          if (!selectedVoice) {
+            selectedVoice = updatedVoices.find(voice => voice.name === ttsEdgeVoice)
+            if (selectedVoice) {
+              console.log('找到精确匹配的语音:', selectedVoice.name)
+            }
+          }
+
+          // 如果没有精确匹配，尝试匹配 Neural 类型的语音
+          if (!selectedVoice && ttsEdgeVoice && ttsEdgeVoice.includes('Neural')) {
+            // 提取语言代码，如zh-CN
+            const langParts = ttsEdgeVoice.split('-')
+            if (langParts.length >= 2) {
+              const langCode = langParts.slice(0, 2).join('-')
+              console.log('检测到Neural音色值，提取语言代码:', langCode)
+
+              // 先尝试匹配包含语言代码的语音
+              selectedVoice = updatedVoices.find(voice =>
+                voice.lang.startsWith(langCode) &&
+                (voice.name.includes(langParts[2]) || // 匹配人名部分，如Xiaoxiao
+                 voice.name.toLowerCase().includes(langParts[2].toLowerCase()))
+              )
+
+              // 如果没有找到，就匹配该语言的任何语音
+              if (!selectedVoice) {
+                selectedVoice = updatedVoices.find(voice => voice.lang.startsWith(langCode))
+                if (selectedVoice) {
+                  console.log('找到匹配语言的语音:', selectedVoice.name)
+                }
+              }
+            }
+          }
+
+          // 如果还没有找到，尝试模糊匹配
+          if (!selectedVoice && ttsEdgeVoice) {
+            console.log('尝试模糊匹配语音:', ttsEdgeVoice)
+
+            // 尝试匹配名称中包含的部分
+            selectedVoice = updatedVoices.find(voice =>
+              voice.name.toLowerCase().includes(ttsEdgeVoice.toLowerCase()) ||
+              ttsEdgeVoice.toLowerCase().includes(voice.name.toLowerCase())
+            )
+
+            if (selectedVoice) {
+              console.log('找到模糊匹配的语音:', selectedVoice.name)
+            }
+          }
+
+          // 如果还是没有找到，尝试根据语言代码匹配
+          if (!selectedVoice && ttsEdgeVoice) {
+            // 尝试从音色值中提取语言代码
+            let langCode = ''
+
+            if (ttsEdgeVoice.includes('zh')) {
+              langCode = 'zh'
+            } else if (ttsEdgeVoice.includes('en')) {
+              langCode = 'en'
+            } else if (ttsEdgeVoice.includes('ja')) {
+              langCode = 'ja'
+            } else if (ttsEdgeVoice.includes('es')) {
+              langCode = 'es'
+            }
+
+            if (langCode) {
+              console.log('尝试根据语言代码匹配语音:', langCode)
+              selectedVoice = updatedVoices.find(voice => voice.lang.startsWith(langCode))
+
+              if (selectedVoice) {
+                console.log('找到匹配语言代码的语音:', selectedVoice.name)
+              }
+            }
+          }
+
+          // 如果还是没有找到，使用默认语音或第一个可用的语音
+          if (!selectedVoice) {
+            // 先尝试使用默认语音
+            selectedVoice = updatedVoices.find(voice => voice.default)
+
+            // 如果没有默认语音，使用第一个可用的语音
+            if (!selectedVoice && updatedVoices.length > 0) {
+              console.log('没有找到匹配的语音，使用第一个可用的语音')
+              selectedVoice = updatedVoices[0]
+            }
+          }
+
+          if (selectedVoice) {
+            utterance.voice = selectedVoice
+            console.log('选择的声音:', selectedVoice)
+          } else {
+            console.warn('未找到指定的声音，使用默认声音')
+          }
+
+          // 设置语音合成参数
+          utterance.rate = 1.0  // 语速（0.1-10）
+          utterance.pitch = 1.0 // 音调（0-2）
+          utterance.volume = 1.0 // 音量（0-1）
+
+          // 设置事件处理程序
+          utterance.onstart = () => {
+            console.log('Edge TTS 开始播放')
+          }
+
+          utterance.onend = () => {
+            console.log('Edge TTS 播放结束')
+          }
+
+          utterance.onerror = (event) => {
+            console.error('Edge TTS 播放错误:', event)
+          }
+
+          // 将文本分段处理，避免过长文本导致的问题
+          if (text.length > 200) {
+            console.log('文本过长，分段处理以确保完整播放')
+
+            // 将文本按句子分段
+            const sentences = text.split(/[.!?\u3002\uff01\uff1f]/).filter(s => s.trim().length > 0)
+            console.log(`将文本分为 ${sentences.length} 个句子进行播放`)
+
+            // 创建多个语音合成器实例
+            for (let i = 0; i < sentences.length; i++) {
+              const sentenceText = sentences[i].trim() + '.'
+              if (sentenceText.length > 0) {
+                const sentenceUtterance = new SpeechSynthesisUtterance(sentenceText)
+
+                // 复制语音设置
+                if (selectedVoice) sentenceUtterance.voice = selectedVoice
+                sentenceUtterance.rate = utterance.rate
+                sentenceUtterance.pitch = utterance.pitch
+                sentenceUtterance.volume = utterance.volume
+
+                // 添加到队列
+                window.speechSynthesis.speak(sentenceUtterance)
+              }
+            }
+          } else {
+            // 直接使用Web Speech API播放语音
+            window.speechSynthesis.speak(utterance)
+          }
+
+          // 创建一个有效的音频文件作为占位符
+          // 这是一个最小的有效WAV文件头
+          const wavHeader = new Uint8Array([
+            0x52, 0x49, 0x46, 0x46, // "RIFF"
+            0x24, 0x00, 0x00, 0x00, // 文件大小
+            0x57, 0x41, 0x56, 0x45, // "WAVE"
+            0x66, 0x6d, 0x74, 0x20, // "fmt "
+            0x10, 0x00, 0x00, 0x00, // fmt块大小
+            0x01, 0x00,             // 格式类型
+            0x01, 0x00,             // 通道数
+            0x44, 0xac, 0x00, 0x00, // 采样率
+            0x88, 0x58, 0x01, 0x00, // 字节率
+            0x02, 0x00,             // 块对齐
+            0x10, 0x00,             // 位深度
+            0x64, 0x61, 0x74, 0x61, // "data"
+            0x10, 0x00, 0x00, 0x00  // 数据大小 (16 bytes)
+          ]);
+
+          // 添加一些样本数据
+          const dummyAudio = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+          const combinedArray = new Uint8Array(wavHeader.length + dummyAudio.length);
+          combinedArray.set(wavHeader);
+          combinedArray.set(dummyAudio, wavHeader.length);
+
+          // 创建一个有效的WAV文件
+          let localAudioBlob = new Blob([combinedArray], { type: 'audio/wav' })
+          console.log('创建了有效WAV文件，大小:', localAudioBlob.size, 'bytes')
+
+          // 显示成功消息
+          window.message.success({ content: i18n.t('settings.tts.playing', { defaultValue: '语音播放中...' }), key: 'tts-loading' })
+
+          // 在Edge TTS模式下，我们不需要播放音频元素，因为浏览器已经在播放语音
+          // 我们只需要创建一个有效的音频Blob作为占位符
+
+          // 等待语音播放完成
+          await new Promise<void>((resolve, reject) => {
+            // 创建一个检查播放状态的函数
+            let isPlaying = true
+            let checkInterval: number | null = null
+
+            // 定期检查播放状态
+            const checkPlayingStatus = () => {
+              if (!window.speechSynthesis.speaking && !window.speechSynthesis.pending) {
+                console.log('Edge TTS 播放完成（通过检测检测到）')
+                isPlaying = false
+                if (checkInterval) {
+                  clearInterval(checkInterval)
+                  checkInterval = null
+                }
+                resolve()
+              }
+            }
+
+            // 设置事件处理程序
+            const originalOnEnd = utterance.onend
+            utterance.onend = (event) => {
+              console.log('Edge TTS 播放结束（通过事件检测到）')
+              isPlaying = false
+              if (checkInterval) {
+                clearInterval(checkInterval)
+                checkInterval = null
+              }
+              if (originalOnEnd) originalOnEnd.call(utterance, event)
+              resolve()
+            }
+
+            const originalOnError = utterance.onerror
+            utterance.onerror = (event) => {
+              console.error('Edge TTS 播放错误:', event)
+              isPlaying = false
+              if (checkInterval) {
+                clearInterval(checkInterval)
+                checkInterval = null
+              }
+              if (originalOnError) originalOnError.call(utterance, event)
+              reject(new Error(`语音合成错误: ${event.error}`))
+            }
+
+            // 开始定期检查
+            checkInterval = window.setInterval(checkPlayingStatus, 500) as unknown as number
+
+            // 设置超时，防止语音合成卡住
+            setTimeout(() => {
+              if (isPlaying) {
+                console.log('Edge TTS 播放超时，强制结束')
+                if (window.speechSynthesis.speaking || window.speechSynthesis.pending) {
+                  window.speechSynthesis.cancel()
+                }
+                isPlaying = false
+                if (checkInterval) {
+                  clearInterval(checkInterval)
+                  checkInterval = null
+                }
+                resolve()
+              }
+            }, 30000) // 30秒超时
+          })
+
+          // 如果没有音频数据，使用默认的音频
+          if (!localAudioBlob) {
+            // 创建一个有效的音频数据
+            // 这是一个最小的有效WAV文件头
+            const wavHeader = new Uint8Array([
+              0x52, 0x49, 0x46, 0x46, // "RIFF"
+              0x24, 0x00, 0x00, 0x00, // 文件大小
+              0x57, 0x41, 0x56, 0x45, // "WAVE"
+              0x66, 0x6d, 0x74, 0x20, // "fmt "
+              0x10, 0x00, 0x00, 0x00, // fmt块大小
+              0x01, 0x00,             // 格式类型
+              0x01, 0x00,             // 通道数
+              0x44, 0xac, 0x00, 0x00, // 采样率
+              0x88, 0x58, 0x01, 0x00, // 字节率
+              0x02, 0x00,             // 块对齐
+              0x10, 0x00,             // 位深度
+              0x64, 0x61, 0x74, 0x61, // "data"
+              0x00, 0x00, 0x00, 0x00  // 数据大小
+            ]);
+
+            // 添加一些样本数据
+            const dummyAudio = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+            const combinedArray = new Uint8Array(wavHeader.length + dummyAudio.length);
+            combinedArray.set(wavHeader);
+            combinedArray.set(dummyAudio, wavHeader.length);
+
+            localAudioBlob = new Blob([combinedArray], { type: 'audio/wav' })
+            console.log('创建了有效WAV文件，大小:', localAudioBlob.size, 'bytes')
+          }
+
+          // 设置全局音频Blob
+          audioBlob = localAudioBlob
+        } catch (error: any) {
+          console.error('浏览器TTS错误:', error)
+
+          // 如果浏览器TTS失败，尝试使用默认的音频
+          try {
+            // 创建一个简单的音频数据
+            const audioContext = new AudioContext()
+            const oscillator = audioContext.createOscillator()
+            const gainNode = audioContext.createGain()
+
+            oscillator.connect(gainNode)
+            gainNode.connect(audioContext.destination)
+
+            oscillator.type = 'sine'
+            oscillator.frequency.value = 440 // A4音频
+            gainNode.gain.value = 0.5
+
+            oscillator.start()
+
+            // 录制音频
+            const mediaStreamDest = audioContext.createMediaStreamDestination()
+            gainNode.connect(mediaStreamDest)
+
+            const mediaRecorder = new MediaRecorder(mediaStreamDest.stream)
+            const fallbackAudioChunks: BlobPart[] = []
+            let fallbackAudioBlob: Blob | null = null
+
+            mediaRecorder.ondataavailable = (event) => {
+              if (event.data.size > 0) {
+                fallbackAudioChunks.push(event.data)
+              }
+            }
+
+            mediaRecorder.onstop = () => {
+              fallbackAudioBlob = new Blob(fallbackAudioChunks, { type: 'audio/wav' })
+              oscillator.stop()
+            }
+
+            mediaRecorder.start()
+
+            // 录制500毫秒
+            await new Promise<void>(resolve => setTimeout(resolve, 500))
+
+            mediaRecorder.stop()
+
+            // 等待录制完成
+            await new Promise<void>(resolve => {
+              mediaRecorder.onstop = () => {
+                fallbackAudioBlob = new Blob(fallbackAudioChunks, { type: 'audio/wav' })
+                oscillator.stop()
+                resolve()
+              }
+            })
+
+            // 设置全局音频Blob
+            if (fallbackAudioBlob) {
+              audioBlob = fallbackAudioBlob
+            }
+          } catch (fallbackError) {
+            console.error('默认音频生成失败:', fallbackError)
+            throw new Error(`浏览器TTS语音合成失败: ${error.message}`)
+          }
+        }
+      } else {
+        console.error('不支持的TTS服务类型:', serviceType)
+        // 默认使用OpenAI TTS
+        if (!ttsApiKey) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_api_key'), key: 'tts-error' })
+          return
+        }
+
+        if (!ttsApiUrl) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_api_url'), key: 'tts-error' })
+          return
+        }
+
+        if (!ttsVoice) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_voice'), key: 'tts-error' })
+          return
+        }
+
+        if (!ttsModel) {
+          window.message.error({ content: i18n.t('settings.tts.error.no_model'), key: 'tts-error' })
+          return
+        }
+
+        // 准备OpenAI TTS请求体
+        const requestBody: any = {
+          input: text
+        }
+
+        // 只有当模型和音色不为空时才添加到请求体中
+        if (ttsModel) {
+          requestBody.model = ttsModel
+        }
+
+        if (ttsVoice) {
+          requestBody.voice = ttsVoice
+        }
+
+        // 调用OpenAI TTS API
+        const response = await fetch(ttsApiUrl, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${ttsApiKey}`
+          },
+          body: JSON.stringify(requestBody)
+        })
+
+        if (!response.ok) {
+          const errorData = await response.json()
+          throw new Error(errorData.error?.message || 'OpenAI语音合成失败')
+        }
+
+        // 获取音频数据
+        console.log('获取到OpenAI TTS响应，开始处理音频数据')
+        audioBlob = await response.blob()
+      }
+
+      // 确保audioBlob已经初始化
+      if (!audioBlob) {
+        // 创建一个有效的音频文件作为占位符
+        // 这是一个最小的有效WAV文件头
+        const wavHeader = new Uint8Array([
+          0x52, 0x49, 0x46, 0x46, // "RIFF"
+          0x24, 0x00, 0x00, 0x00, // 文件大小
+          0x57, 0x41, 0x56, 0x45, // "WAVE"
+          0x66, 0x6d, 0x74, 0x20, // "fmt "
+          0x10, 0x00, 0x00, 0x00, // fmt块大小
+          0x01, 0x00,             // 格式类型
+          0x01, 0x00,             // 通道数
+          0x44, 0xac, 0x00, 0x00, // 采样率
+          0x88, 0x58, 0x01, 0x00, // 字节率
+          0x02, 0x00,             // 块对齐
+          0x10, 0x00,             // 位深度
+          0x64, 0x61, 0x74, 0x61, // "data"
+          0x10, 0x00, 0x00, 0x00  // 数据大小 (16 bytes)
+        ]);
+
+        // 添加一些样本数据
+        const dummyAudio = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+        const combinedArray = new Uint8Array(wavHeader.length + dummyAudio.length);
+        combinedArray.set(wavHeader);
+        combinedArray.set(dummyAudio, wavHeader.length);
+
+        audioBlob = new Blob([combinedArray], { type: 'audio/wav' })
+        console.log('创建了有效WAV文件，大小:', audioBlob.size, 'bytes')
+      }
+
+      console.log('音频Blob大小:', audioBlob.size, 'bytes', '类型:', audioBlob.type)
+      const audioUrl = URL.createObjectURL(audioBlob)
+      console.log('创建的Blob URL:', audioUrl)
+
+      // 创建音频元素并播放
+      this.audio = new Audio()
+      this.audio.oncanplay = () => {
+        console.log('音频已准备好可以播放')
+      }
+      this.audio.onended = () => {
+        console.log('音频播放结束')
+        this.isPlaying = false
+        URL.revokeObjectURL(audioUrl)
+      }
+      this.audio.onerror = (error) => {
+        console.error('音频播放错误:', error)
+        console.error('错误代码:', this.audio?.error?.code)
+        console.error('错误消息:', this.audio?.error?.message)
+        window.message.error({ content: `音频播放失败: ${this.audio?.error?.message || '未知错误'}`, key: 'tts-error' })
+        this.isPlaying = false
+        URL.revokeObjectURL(audioUrl)
+      }
+
+      // 设置音频源并播放
+      this.audio.src = audioUrl
+      console.log('开始播放音频')
+      try {
+        await this.audio.play()
+        console.log('音频开始播放')
+        this.isPlaying = true
+      } catch (error: any) {
+        console.error('播放音频时出错:', error)
+        window.message.error({ content: `播放音频失败: ${error.message}`, key: 'tts-error' })
+        this.isPlaying = false
+        URL.revokeObjectURL(audioUrl)
+        throw error
+      }
+
+      // 关闭加载提示
+      window.message.success({ content: '语音播放中...', key: 'tts-loading' })
+    } catch (error: any) {
+      console.error('TTS错误:', error)
+      window.message.error({ content: `语音合成失败: ${error.message}`, key: 'tts-error' })
+    }
+  }
+
+  /**
+   * 清理文本，移除不需要的标点符号和格式化标记
+   * @param text 要清理的文本
+   * @returns 清理后的文本
+   */
+  private cleanTextForSpeech(text: string): string {
+    // 获取最新的TTS设置
+    const { ttsFilterOptions = {
+      filterThinkingProcess: true,
+      filterMarkdown: true,
+      filterCodeBlocks: true,
+      filterHtmlTags: true,
+      maxTextLength: 4000
+    }, ttsServiceType } = store.getState().settings;
+
+    // 输出当前的TTS服务类型，便于调试
+    console.log('清理文本时使用的TTS服务类型:', ttsServiceType || 'openai')
+    let cleanedText = text;
+
+    // 根据过滤选项进行处理
+
+    // 移除Markdown格式化的符号，如*号、`号等
+    if (ttsFilterOptions.filterMarkdown) {
+      cleanedText = cleanedText
+        // 移除加粗和斜体标记
+        .replace(/\*\*([^*]+)\*\*/g, '$1') // **bold** -> bold
+        .replace(/\*([^*]+)\*/g, '$1')       // *italic* -> italic
+        .replace(/__([^_]+)__/g, '$1')       // __bold__ -> bold
+        .replace(/_([^_]+)_/g, '$1')         // _italic_ -> italic
+        // 移除链接格式，只保留链接文本
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1'); // [text](url) -> text
+    }
+
+    // 移除代码块
+    if (ttsFilterOptions.filterCodeBlocks) {
+      cleanedText = cleanedText
+        .replace(/```[\s\S]*?```/g, '')      // 移除代码块
+        .replace(/`([^`]+)`/g, '$1');       // `code` -> code
+    }
+
+    // 移除HTML标签
+    if (ttsFilterOptions.filterHtmlTags) {
+      cleanedText = cleanedText.replace(/<[^>]*>/g, '');
+    }
+
+    // 基本清理（始终执行）
+    cleanedText = cleanedText
+      // 将多个连续的空格替换为单个空格
+      .replace(/\s+/g, ' ')
+      // 将多个连续的换行替换为单个换行
+      .replace(/\n+/g, '\n')
+      // 移除行首和行尾的空白字符
+      .trim();
+
+    return cleanedText;
+  }
+
+  /**
+   * 检测并移除思考过程
+   * @param text 要处理的文本
+   * @returns 处理后的文本
+   */
+  private removeThinkingProcess(text: string): string {
+    // 获取最新的TTS设置
+    const { ttsFilterOptions = {
+      filterThinkingProcess: true,
+      filterMarkdown: true,
+      filterCodeBlocks: true,
+      filterHtmlTags: true,
+      maxTextLength: 4000
+    }, ttsServiceType } = store.getState().settings;
+
+    // 输出当前的TTS服务类型，便于调试
+    console.log('移除思考过程时使用的TTS服务类型:', ttsServiceType || 'openai')
+
+    // 如果不需要过滤思考过程，直接返回原文本
+    if (!ttsFilterOptions.filterThinkingProcess) {
+      return text;
+    }
+    // 如果整个文本都是{'text': '...'}格式，则不处理
+    // 这种情况可能是伪思考过程，实际上是整个回答
+    const isFullTextJson = text.trim().startsWith('{') &&
+                          text.includes('"text":') &&
+                          text.trim().endsWith('}') &&
+                          !text.includes('\n\n');
+
+    // 如果文本中包含多个段落或明显的思考过程标记，则处理
+    const hasThinkingMarkers = text.includes('<think>') ||
+                              text.includes('<thinking>') ||
+                              text.includes('[THINKING]') ||
+                              text.includes('```thinking');
+
+    // 如果文本以JSON格式开头，且不是整个文本都是JSON，或者包含思考过程标记
+    if ((text.trim().startsWith('{') && text.includes('"text":') && !isFullTextJson) || hasThinkingMarkers) {
+      // 尝试提取JSON中的text字段
+      try {
+        const match = text.match(/"text":\s*"([^"]+)"/);
+        if (match && match[1]) {
+          // 只返回text字段的内容
+          return match[1].replace(/\\n/g, '\n').replace(/\\"/g, '"');
+        }
+      } catch (e) {
+        console.error('解析JSON失败:', e);
+      }
+    }
+
+    // 直接检查是否以<think>开头
+    const trimmedText = text.trim();
+    console.log('检查是否以<think>开头:', trimmedText.startsWith('<think>'));
+
+    if (trimmedText.startsWith('<think>')) {
+      // 如果文本以<think>开头，则尝试找到对应的</think>结尾标签
+      const endTagIndex = text.indexOf('</think>');
+      console.log('结束标签位置:', endTagIndex);
+
+      if (endTagIndex !== -1) {
+        // 找到结束标签，去除<think>...</think>部分
+        const thinkContent = text.substring(0, endTagIndex + 9); // 思考过程部分
+        const afterThinkTag = text.substring(endTagIndex + 9).trim(); // 9是</think>的长度
+
+        console.log('思考过程内容长度:', thinkContent.length);
+        console.log('思考过程后的内容长度:', afterThinkTag.length);
+        console.log('思考过程后的内容开头:', afterThinkTag.substring(0, 50));
+
+        if (afterThinkTag) {
+          console.log('找到<think>标签，已移除思考过程');
+          return afterThinkTag;
+        } else {
+          // 如果思考过程后没有内容，则尝试提取思考过程中的有用信息
+          console.log('思考过程后没有内容，尝试提取思考过程中的有用信息');
+
+          // 提取<think>和</think>之间的内容
+          const thinkContentText = text.substring(text.indexOf('<think>') + 7, endTagIndex).trim();
+
+          // 如果思考过程中包含“这是”或“This is”等关键词，可能是有用的信息
+          if (thinkContentText.includes('这是') ||
+              thinkContentText.includes('This is') ||
+              thinkContentText.includes('The error') ||
+              thinkContentText.includes('错误')) {
+
+            // 尝试找到最后一个段落，可能包含总结信息
+            const paragraphs = thinkContentText.split(/\n\s*\n/);
+            if (paragraphs.length > 0) {
+              const lastParagraph = paragraphs[paragraphs.length - 1].trim();
+              if (lastParagraph.length > 50) { // 确保段落足够长
+                console.log('从思考过程中提取了最后一个段落');
+                return lastParagraph;
+              }
+            }
+
+            // 如果没有找到合适的段落，返回整个思考过程
+            console.log('返回整个思考过程内容');
+            return thinkContentText;
+          }
+        }
+      }
+    }
+
+    // 先处理<think>标签
+    if (text.includes('<think>')) {
+      const startIndex = text.indexOf('<think>');
+      const endIndex = text.indexOf('</think>');
+
+      if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+        console.log('找到<think>标签，起始位置:', startIndex, '结束位置:', endIndex);
+
+        // 提取<think>和</think>之间的内容
+        const thinkContent = text.substring(startIndex + 7, endIndex);
+
+        // 提取</think>后面的内容
+        const afterThinkContent = text.substring(endIndex + 9).trim(); // 9是</think>的长度
+
+        console.log('<think>内容长度:', thinkContent.length);
+        console.log('</think>后内容长度:', afterThinkContent.length);
+
+        if (afterThinkContent) {
+          // 如果</think>后面有内容，则使用该内容
+          console.log('使用</think>后面的内容');
+          return afterThinkContent;
+        } else {
+          // 如果</think>后面没有内容，则使用思考过程中的内容
+          console.log('使用<think>标签中的内容');
+          return thinkContent;
+        }
+      }
+    }
+
+    // 如果没有<think>标签或处理失败，则移除其他思考过程标记
+    let processedText = text
+      // 移除HTML标记的思考过程
+      .replace(/<thinking>[\s\S]*?<\/thinking>/gi, '')
+      .replace(/<think>[\s\S]*?<\/think>/gi, '')
+      // 移除方括号标记的思考过程
+      .replace(/\[THINKING\][\s\S]*?\[\/THINKING\]/gi, '')
+      .replace(/\[THINK\][\s\S]*?\[\/THINK\]/gi, '')
+      // 移除代码块标记的思考过程
+      .replace(/```thinking[\s\S]*?```/gi, '')
+      .replace(/```think[\s\S]*?```/gi, '')
+      // 移除开头的“我先思考一下”类似的句子
+      .replace(/^(\s*)(\S+\s+)?(\S+\s+)?(\S+\s+)?(我|让我|让我们|我们|我先|我来)(思考|分析|理解|看一下|想一想)[^\n]*\n/i, '')
+      // 移除开头的“Let me think”类似的句子
+      .replace(/^(\s*)(\S+\s+)?(\S+\s+)?(\S+\s+)?(Let me|I'll|I will|I need to|Let's|I'm going to)\s+(think|analyze|understand|consider|break down)[^\n]*\n/i, '')
+      // 移除开头的“To answer this question”类似的句子
+      .replace(/^(\s*)(\S+\s+)?(\S+\s+)?(\S+\s+)?(To answer this|To solve this|To address this|To respond to this)[^\n]*\n/i, '')
+
+    // 如果文本中包含“我的回答是”或“我的答案是”，只保留这之后的内容
+    const answerMarkers = [
+      /[\n\r]+(\s*)(我的|最终|最终的|正确的|完整的)?(回答|答案|结论|解决方案)(是|如下|就是|就是如下)[\s:：]*/i,
+      /[\n\r]+(\s*)(My|The|Final|Complete|Correct)\s+(answer|response|solution|conclusion)\s+(is|would be|follows)[\s:]*/i
+    ];
+
+    for (const marker of answerMarkers) {
+      const parts = processedText.split(marker);
+      if (parts.length > 1) {
+        // 取最后一个匹配后的内容
+        return parts[parts.length - 1].trim();
+      }
+    }
+
+    return processedText;
+  }
+
+
+
+  /**
+   * 从消息中提取文本并转换为语音
+   * @param message 消息对象
+   */
+  speakFromMessage = async (message: Message): Promise<void> => {
+    // 只读取回答内容，不读取思考过程
+    let text = message.content
+
+    // 如果有翻译内容，则使用翻译内容
+    if (message.translatedContent) {
+      text = message.translatedContent
+    }
+
+    console.log('原始文本长度:', text.length)
+    console.log('原始文本开头:', text.substring(0, 100))
+
+    // 先移除思考过程
+    const processedText = this.removeThinkingProcess(text);
+    console.log('移除思考过程后文本长度:', processedText.length);
+    console.log('处理后文本开头:', processedText.substring(0, 100));
+    text = processedText;
+
+    // 清理文本，移除不需要的标点符号
+    text = this.cleanTextForSpeech(text)
+    console.log('清理标点符号后文本长度:', text.length)
+
+    // 获取最新的TTS设置
+    const latestSettings = store.getState().settings;
+    const ttsFilterOptions = latestSettings.ttsFilterOptions || {
+      filterThinkingProcess: true,
+      filterMarkdown: true,
+      filterCodeBlocks: true,
+      filterHtmlTags: true,
+      maxTextLength: 4000
+    };
+    const ttsServiceType = latestSettings.ttsServiceType;
+
+    // 输出当前的TTS服务类型，便于调试
+    console.log('当前消息播放使用的TTS服务类型:', ttsServiceType || 'openai')
+    console.log('消息播放时完整TTS设置:', {
+      ttsEnabled: latestSettings.ttsEnabled,
+      ttsServiceType: latestSettings.ttsServiceType,
+      ttsApiKey: latestSettings.ttsApiKey ? '已设置' : '未设置',
+      ttsVoice: latestSettings.ttsVoice,
+      ttsModel: latestSettings.ttsModel,
+      ttsEdgeVoice: latestSettings.ttsEdgeVoice
+    })
+
+    // 如果消息过长，可能会导致TTS API超时或失败
+    // 根据设置的最大文本长度进行截断
+    const maxLength = ttsFilterOptions.maxTextLength || 4000; // 默认为4000
+    if (text.length > maxLength) {
+      text = text.substring(0, maxLength) + '...'
+      console.log(`文本过长，已截断为${maxLength}个字符`)
+    }
+
+    await this.speak(text)
+  }
+
+  /**
+   * 暂停当前播放的音频
+   */
+  pause = (): void => {
+    if (this.audio && this.isPlaying) {
+      this.audio.pause()
+      this.isPlaying = false
+    }
+  }
+
+  /**
+   * 恢复播放
+   */
+  resume = (): void => {
+    if (this.audio && !this.isPlaying) {
+      this.audio.play()
+      this.isPlaying = true
+    }
+  }
+
+  /**
+   * 停止播放并释放资源
+   */
+  stop = (): void => {
+    console.log('执行停止TTS播放操作')
+
+    try {
+      // 首先将音量设为0，避免停止时的特殊声音
+      if (this.audio) {
+        // 先将音量渐变为0，避免突然停止的噪音
+        const originalVolume = this.audio.volume || 1
+        const fadeOutSteps = 5
+        const fadeOutInterval = 20 // 毫秒
+
+        // 如果正在播放，则渐变音量
+        if (this.isPlaying) {
+          const fadeStep = originalVolume / fadeOutSteps
+          let currentStep = 0
+
+          const fadeOut = () => {
+            if (currentStep < fadeOutSteps && this.audio) {
+              this.audio.volume = Math.max(0, originalVolume - (fadeStep * currentStep))
+              currentStep++
+              setTimeout(fadeOut, fadeOutInterval)
+            } else {
+              // 渐变结束后正式停止
+              this.finalizeStop()
+            }
+          }
+
+          fadeOut()
+        } else {
+          // 如果不是正在播放状态，直接停止
+          this.finalizeStop()
+        }
+      } else {
+        // 如果没有音频元素，直接停止
+        this.finalizeStop()
+      }
+    } catch (error) {
+      console.error('停止TTS播放时出错:', error)
+      // 出错时仍然尝试停止
+      this.finalizeStop()
+    }
+  }
+
+  /**
+   * 完成停止播放的操作
+   * 这是内部方法，由stop()调用
+   */
+  private finalizeStop(): void {
+    console.log('执行最终停止TTS播放操作')
+
+    // 停止浏览器的Web Speech API播放
+    if (window.speechSynthesis) {
+      try {
+        window.speechSynthesis.cancel()
+        // 清除所有排队的语音
+        window.speechSynthesis.cancel()
+      } catch (e) {
+        console.error('停止Web Speech API时出错:', e)
+      }
+    }
+
+    // 停止音频元素的播放
+    if (this.audio) {
+      try {
+        // 移除所有事件监听器
+        this.audio.onended = null
+        this.audio.oncanplay = null
+        this.audio.onerror = null
+
+        // 停止播放
+        this.audio.pause()
+        this.audio.currentTime = 0
+
+        // 释放资源
+        const oldSrc = this.audio.src
+        this.audio.src = ''
+        this.audio.load() // 强制释放资源
+
+        // 尝试释放BlobURL
+        if (oldSrc && oldSrc.startsWith('blob:')) {
+          try {
+            URL.revokeObjectURL(oldSrc)
+          } catch (e) {
+            console.error('释放BlobURL时出错:', e)
+          }
+        }
+
+        this.audio = null
+      } catch (e) {
+        console.error('停止音频元素时出错:', e)
+        // 确保即使出错也重置状态
+        this.audio = null
+      }
+    }
+
+    // 重置播放状态
+    this.isPlaying = false
+
+    // 清除加载提示
+    window.message.destroy('tts-loading')
+  }
+
+  /**
+   * 检查是否正在播放
+   */
+  isCurrentlyPlaying = (): boolean => {
+    return this.isPlaying
+  }
+}
+
+// 导出单例
+export default new TTSService()
diff --git a/src/renderer/src/store/settings.ts b/src/renderer/src/store/settings.ts
index 18c503ad70..8669d46c73 100644
--- a/src/renderer/src/store/settings.ts
+++ b/src/renderer/src/store/settings.ts
@@ -110,6 +110,25 @@ export interface SettingsState {
   showOpenedMinappsInSidebar: boolean
   // 隐私设置
   enableDataCollection: boolean
+  // TTS配置
+  ttsEnabled: boolean
+  ttsServiceType: string // TTS服务类型：openai或edge
+  ttsApiKey: string
+  ttsApiUrl: string
+  ttsVoice: string
+  ttsModel: string
+  ttsCustomVoices: string[]
+  ttsCustomModels: string[]
+  // Edge TTS配置
+  ttsEdgeVoice: string
+  // TTS过滤选项
+  ttsFilterOptions: {
+    filterThinkingProcess: boolean  // 过滤思考过程
+    filterMarkdown: boolean         // 过滤Markdown标记
+    filterCodeBlocks: boolean       // 过滤代码块
+    filterHtmlTags: boolean         // 过滤HTML标签
+    maxTextLength: number           // 最大文本长度
+  }
   exportMenuOptions: {
     image: boolean
     markdown: boolean
@@ -208,6 +227,24 @@ const initialState: SettingsState = {
   maxKeepAliveMinapps: 3,
   showOpenedMinappsInSidebar: true,
   enableDataCollection: false,
+  // TTS配置
+  ttsEnabled: false,
+  ttsServiceType: 'openai', // 默认使用OpenAI TTS
+  ttsApiKey: '',
+  ttsApiUrl: 'https://api.openai.com/v1/audio/speech',
+  ttsVoice: '',
+  ttsModel: '',
+  ttsCustomVoices: [],
+  ttsCustomModels: [],
+  // Edge TTS配置
+  ttsEdgeVoice: 'zh-CN-XiaoxiaoNeural', // 默认使用小小的声音
+  ttsFilterOptions: {
+    filterThinkingProcess: true,  // 默认过滤思考过程
+    filterMarkdown: true,         // 默认过滤Markdown标记
+    filterCodeBlocks: true,       // 默认过滤代码块
+    filterHtmlTags: true,         // 默认过滤HTML标签
+    maxTextLength: 4000           // 默认最大文本长度
+  },
   exportMenuOptions: {
     image: true,
     markdown: true,
@@ -476,10 +513,120 @@ const settingsSlice = createSlice({
     },
     setExportMenuOptions: (state, action: PayloadAction<typeof initialState.exportMenuOptions>) => {
       state.exportMenuOptions = action.payload
+    },
+    // TTS相关的action
+    setTtsEnabled: (state, action: PayloadAction<boolean>) => {
+      state.ttsEnabled = action.payload
+    },
+    setTtsServiceType: (state, action: PayloadAction<string>) => {
+      state.ttsServiceType = action.payload
+    },
+    setTtsApiKey: (state, action: PayloadAction<string>) => {
+      state.ttsApiKey = action.payload
+    },
+    setTtsApiUrl: (state, action: PayloadAction<string>) => {
+      state.ttsApiUrl = action.payload
+    },
+    setTtsEdgeVoice: (state, action: PayloadAction<string>) => {
+      state.ttsEdgeVoice = action.payload
+    },
+    setTtsVoice: (state, action: PayloadAction<string>) => {
+      state.ttsVoice = action.payload
+    },
+    setTtsModel: (state, action: PayloadAction<string>) => {
+      state.ttsModel = action.payload
+    },
+    setTtsCustomVoices: (state, action: PayloadAction<string[]>) => {
+      // 确保所有值都是字符串
+      state.ttsCustomVoices = action.payload
+        .filter(voice => voice !== null && voice !== undefined)
+        .map(voice => typeof voice === 'string' ? voice : String(voice))
+    },
+    setTtsCustomModels: (state, action: PayloadAction<string[]>) => {
+      // 确保所有值都是字符串
+      state.ttsCustomModels = action.payload
+        .filter(model => model !== null && model !== undefined)
+        .map(model => typeof model === 'string' ? model : String(model))
+    },
+    resetTtsCustomValues: (state) => {
+      // 重置所有自定义音色和模型
+      state.ttsCustomVoices = [];
+      state.ttsCustomModels = [];
+    },
+    addTtsCustomVoice: (state, action: PayloadAction<string>) => {
+      // 确保添加的是字符串
+      const voiceStr = typeof action.payload === 'string' ? action.payload : String(action.payload);
+
+      // 检查是否已存在相同的音色
+      const exists = state.ttsCustomVoices.some(voice => {
+        if (typeof voice === 'string') {
+          return voice === voiceStr;
+        }
+        return String(voice) === voiceStr;
+      });
+
+      if (!exists) {
+        state.ttsCustomVoices.push(voiceStr);
+      }
+    },
+    addTtsCustomModel: (state, action: PayloadAction<string>) => {
+      // 确保添加的是字符串
+      const modelStr = typeof action.payload === 'string' ? action.payload : String(action.payload);
+
+      // 检查是否已存在相同的模型
+      const exists = state.ttsCustomModels.some(model => {
+        if (typeof model === 'string') {
+          return model === modelStr;
+        }
+        return String(model) === modelStr;
+      });
+
+      if (!exists) {
+        state.ttsCustomModels.push(modelStr);
+      }
+    },
+    removeTtsCustomVoice: (state, action: PayloadAction<string>) => {
+      // 确保删除的是字符串
+      const voiceStr = typeof action.payload === 'string' ? action.payload : String(action.payload);
+
+      // 过滤掉要删除的音色
+      state.ttsCustomVoices = state.ttsCustomVoices.filter(voice => {
+        if (typeof voice === 'string') {
+          return voice !== voiceStr;
+        }
+        return String(voice) !== voiceStr;
+      });
+    },
+    removeTtsCustomModel: (state, action: PayloadAction<string>) => {
+      // 确保删除的是字符串
+      const modelStr = typeof action.payload === 'string' ? action.payload : String(action.payload);
+
+      // 过滤掉要删除的模型
+      state.ttsCustomModels = state.ttsCustomModels.filter(model => {
+        if (typeof model === 'string') {
+          return model !== modelStr;
+        }
+        return String(model) !== modelStr;
+      });
+    },
+    // TTS过滤选项的action
+    setTtsFilterOptions: (state, action: PayloadAction<{
+      filterThinkingProcess?: boolean
+      filterMarkdown?: boolean
+      filterCodeBlocks?: boolean
+      filterHtmlTags?: boolean
+      maxTextLength?: number
+    }>) => {
+      state.ttsFilterOptions = {
+        ...state.ttsFilterOptions,
+        ...action.payload
+      }
     }
   }
 })
 
+const settingsActions = settingsSlice.actions
+
 export const {
   setShowAssistants,
   toggleShowAssistants,
@@ -562,7 +709,23 @@ export const {
   setMaxKeepAliveMinapps,
   setShowOpenedMinappsInSidebar,
   setEnableDataCollection,
-  setExportMenuOptions
-} = settingsSlice.actions
+  setExportMenuOptions,
+  // TTS相关的action
+  setTtsEnabled,
+  setTtsServiceType,
+  setTtsApiKey,
+  setTtsApiUrl,
+  setTtsEdgeVoice,
+  setTtsVoice,
+  setTtsModel,
+  setTtsCustomVoices,
+  setTtsCustomModels,
+  resetTtsCustomValues,
+  addTtsCustomVoice,
+  addTtsCustomModel,
+  removeTtsCustomVoice,
+  removeTtsCustomModel,
+  setTtsFilterOptions
+} = settingsActions
 
 export default settingsSlice.reducer
diff --git a/src/renderer/src/types/index.ts b/src/renderer/src/types/index.ts
index ca5fbafcc2..6d58328ebd 100644
--- a/src/renderer/src/types/index.ts
+++ b/src/renderer/src/types/index.ts
@@ -417,3 +417,12 @@ export interface QuickPhrase {
   updatedAt: number
   order?: number
 }
+
+export type TTSProvider = {
+  id: string
+  name: string
+  apiKey?: string
+  apiUrl?: string
+  voice?: string
+  model?: string
+}