fix: ci

* feat(minapp): add Google login tip for untrusted browser issue

* feat(miniapp): add open Google button for Google Login popup

* feat(minapp): replace custom alert with Ant Design Alert component

.editorconfig

@@ -1,9 +1,9 @@
-root = true
-
-[*]
-charset = utf-8
-indent_style = space
-indent_size = 2
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true

.git-blame-ignore-revs

@@ -0,0 +1,2 @@
+# ignore #7923 eol change and code formatting
+4ac8a388347ff35f34de42c3ef4a2f81f03fb3b1

.gitattributes

@@ -1,2 +1,3 @@
+* text=auto eol=lf
 /.yarn/**            linguist-vendored
 /.yarn/releases/*    binary

.github/ISSUE_TEMPLATE/#3_others.yml

@@ -73,4 +73,4 @@ body:
     id: additional
     attributes:
       label: 附加信息
-      description: 任何能让我们对您的问题有更多了解的信息，包括截图或相关链接
+      description: 任何能让我们对您的问题有更多了解的信息，包括截图或相关链接

.github/ISSUE_TEMPLATE/3_others.yml

@@ -73,4 +73,4 @@ body:
     id: additional
     attributes:
       label: Additional Information
-      description: Any other information that could help us better understand your question, including screenshots or relevant links
+      description: Any other information that could help us better understand your question, including screenshots or relevant links

.github/issue-checker.yml

@@ -9,115 +9,115 @@ labels:
   # skips and removes
   - name: skip all
     content:
-    regexes: "[Ss]kip (?:[Aa]ll |)[Ll]abels?"
+    regexes: '[Ss]kip (?:[Aa]ll |)[Ll]abels?'
   - name: remove all
     content:
-    regexes: "[Rr]emove (?:[Aa]ll |)[Ll]abels?"
+    regexes: '[Rr]emove (?:[Aa]ll |)[Ll]abels?'
 
   - name: skip kind/bug
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)kind/bug(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)kind/bug(?:`|)'
   - name: remove kind/bug
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)kind/bug(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)kind/bug(?:`|)'
 
   - name: skip kind/enhancement
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)kind/enhancement(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)kind/enhancement(?:`|)'
   - name: remove kind/enhancement
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)kind/enhancement(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)kind/enhancement(?:`|)'
 
   - name: skip kind/question
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)kind/question(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)kind/question(?:`|)'
   - name: remove kind/question
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)kind/question(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)kind/question(?:`|)'
 
   - name: skip area/Connectivity
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)area/Connectivity(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)area/Connectivity(?:`|)'
   - name: remove area/Connectivity
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)area/Connectivity(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)area/Connectivity(?:`|)'
 
   - name: skip area/UI/UX
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)area/UI/UX(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)area/UI/UX(?:`|)'
   - name: remove area/UI/UX
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)area/UI/UX(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)area/UI/UX(?:`|)'
 
   - name: skip kind/documentation
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)kind/documentation(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)kind/documentation(?:`|)'
   - name: remove kind/documentation
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)kind/documentation(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)kind/documentation(?:`|)'
 
   - name: skip client:linux
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)client:linux(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)client:linux(?:`|)'
   - name: remove client:linux
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)client:linux(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)client:linux(?:`|)'
 
   - name: skip client:mac
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)client:mac(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)client:mac(?:`|)'
   - name: remove client:mac
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)client:mac(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)client:mac(?:`|)'
 
   - name: skip client:win
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)client:win(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)client:win(?:`|)'
   - name: remove client:win
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)client:win(?:`|)"
-  
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)client:win(?:`|)'
+
   - name: skip sig/Assistant
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)sig/Assistant(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)sig/Assistant(?:`|)'
   - name: remove sig/Assistant
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)sig/Assistant(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)sig/Assistant(?:`|)'
 
   - name: skip sig/Data
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)sig/Data(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)sig/Data(?:`|)'
   - name: remove sig/Data
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)sig/Data(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)sig/Data(?:`|)'
 
   - name: skip sig/MCP
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)sig/MCP(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)sig/MCP(?:`|)'
   - name: remove sig/MCP
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)sig/MCP(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)sig/MCP(?:`|)'
 
   - name: skip sig/RAG
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)sig/RAG(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)sig/RAG(?:`|)'
   - name: remove sig/RAG
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)sig/RAG(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)sig/RAG(?:`|)'
 
   - name: skip lgtm
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)lgtm(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)lgtm(?:`|)'
   - name: remove lgtm
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)lgtm(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)lgtm(?:`|)'
 
   - name: skip License
     content:
-    regexes: "[Ss]kip (?:[Ll]abels? |)(?:`|)License(?:`|)"
+    regexes: '[Ss]kip (?:[Ll]abels? |)(?:`|)License(?:`|)'
   - name: remove License
     content:
-    regexes: "[Rr]emove (?:[Ll]abels? |)(?:`|)License(?:`|)"
+    regexes: '[Rr]emove (?:[Ll]abels? |)(?:`|)License(?:`|)'
 
   # `Dev Team`
   - name: Dev Team
@@ -129,7 +129,7 @@ labels:
   # Area labels
   - name: area/Connectivity
     content: area/Connectivity
-    regexes: "代理|[Pp]roxy"
+    regexes: '代理|[Pp]roxy'
     skip-if:
       - skip all
       - skip area/Connectivity
@@ -139,7 +139,7 @@ labels:
 
   - name: area/UI/UX
     content: area/UI/UX
-    regexes: "界面|[Uu][Ii]|重叠|按钮|图标|组件|渲染|菜单|栏目|头像|主题|样式|[Cc][Ss][Ss]"
+    regexes: '界面|[Uu][Ii]|重叠|按钮|图标|组件|渲染|菜单|栏目|头像|主题|样式|[Cc][Ss][Ss]'
     skip-if:
       - skip all
       - skip area/UI/UX
@@ -150,7 +150,7 @@ labels:
   # Kind labels
   - name: kind/documentation
     content: kind/documentation
-    regexes: "文档|教程|[Dd]oc(s|umentation)|[Rr]eadme"
+    regexes: '文档|教程|[Dd]oc(s|umentation)|[Rr]eadme'
     skip-if:
       - skip all
       - skip kind/documentation
@@ -161,7 +161,7 @@ labels:
   # Client labels
   - name: client:linux
     content: client:linux
-    regexes: "(?:[Ll]inux|[Uu]buntu|[Dd]ebian)"
+    regexes: '(?:[Ll]inux|[Uu]buntu|[Dd]ebian)'
     skip-if:
       - skip all
       - skip client:linux
@@ -171,7 +171,7 @@ labels:
 
   - name: client:mac
     content: client:mac
-    regexes: "(?:[Mm]ac|[Mm]acOS|[Oo]SX)"
+    regexes: '(?:[Mm]ac|[Mm]acOS|[Oo]SX)'
     skip-if:
       - skip all
       - skip client:mac
@@ -181,7 +181,7 @@ labels:
 
   - name: client:win
     content: client:win
-    regexes: "(?:[Ww]in|[Ww]indows)"
+    regexes: '(?:[Ww]in|[Ww]indows)'
     skip-if:
       - skip all
       - skip client:win
@@ -192,7 +192,7 @@ labels:
   # SIG labels
   - name: sig/Assistant
     content: sig/Assistant
-    regexes: "快捷助手|[Aa]ssistant"
+    regexes: '快捷助手|[Aa]ssistant'
     skip-if:
       - skip all
       - skip sig/Assistant
@@ -202,7 +202,7 @@ labels:
 
   - name: sig/Data
     content: sig/Data
-    regexes: "[Ww]ebdav|坚果云|备份|同步|数据|Obsidian|Notion|Joplin|思源"
+    regexes: '[Ww]ebdav|坚果云|备份|同步|数据|Obsidian|Notion|Joplin|思源'
     skip-if:
       - skip all
       - skip sig/Data
@@ -212,7 +212,7 @@ labels:
 
   - name: sig/MCP
     content: sig/MCP
-    regexes: "[Mm][Cc][Pp]"
+    regexes: '[Mm][Cc][Pp]'
     skip-if:
       - skip all
       - skip sig/MCP
@@ -222,7 +222,7 @@ labels:
 
   - name: sig/RAG
     content: sig/RAG
-    regexes: "知识库|[Rr][Aa][Gg]"
+    regexes: '知识库|[Rr][Aa][Gg]'
     skip-if:
       - skip all
       - skip sig/RAG
@@ -233,7 +233,7 @@ labels:
   # Other labels
   - name: lgtm
     content: lgtm
-    regexes: "(?:[Ll][Gg][Tt][Mm]|[Ll]ooks [Gg]ood [Tt]o [Mm]e)"
+    regexes: '(?:[Ll][Gg][Tt][Mm]|[Ll]ooks [Gg]ood [Tt]o [Mm]e)'
     skip-if:
       - skip all
       - skip lgtm
@@ -243,7 +243,7 @@ labels:
 
   - name: License
     content: License
-    regexes: "(?:[Ll]icense|[Cc]opyright|[Mm][Ii][Tt]|[Aa]pache)"
+    regexes: '(?:[Ll]icense|[Cc]opyright|[Mm][Ii][Tt]|[Aa]pache)'
     skip-if:
       - skip all
       - skip License

.github/workflows/dispatch-docs-update.yml

@@ -0,0 +1,27 @@
+name: Dispatch Docs Update on Release
+
+on:
+  release:
+    types: [released]
+
+permissions:
+  contents: write
+
+jobs:
+  dispatch-docs-update:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get Release Tag from Event
+        id: get-event-tag
+        shell: bash
+        run: |
+          # 从当前 Release 事件中获取 tag_name
+          echo "tag=${{ github.event.release.tag_name }}" >> $GITHUB_OUTPUT
+
+      - name: Dispatch update-download-version workflow to cherry-studio-docs
+        uses: peter-evans/repository-dispatch@v3
+        with:
+          token: ${{ secrets.REPO_DISPATCH_TOKEN }}
+          repository: CherryHQ/cherry-studio-docs
+          event-type: update-download-version
+          client-payload: '{"version": "${{ steps.get-event-tag.outputs.tag }}"}'

.github/workflows/issue-checker.yml

@@ -1,4 +1,4 @@
-name: "Issue Checker"
+name: 'Issue Checker'
 
 on:
   issues:
@@ -19,7 +19,7 @@ jobs:
     steps:
       - uses: MaaAssistantArknights/issue-checker@v1.14
         with:
-          repo-token: "${{ secrets.GITHUB_TOKEN }}"
+          repo-token: '${{ secrets.GITHUB_TOKEN }}'
           configuration-path: .github/issue-checker.yml
           not-before: 2022-08-05T00:00:00Z
-          include-title: 1
+          include-title: 1

.github/workflows/issue-management.yml

@@ -1,8 +1,8 @@
-name: "Stale Issue Management"
+name: 'Stale Issue Management'
 
 on:
   schedule:
-    - cron: "0 0 * * *"
+    - cron: '0 0 * * *'
   workflow_dispatch:
 
 env:
@@ -24,18 +24,18 @@ jobs:
         uses: actions/stale@v9
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
-          only-labels: "needs-more-info"
+          only-labels: 'needs-more-info'
           days-before-stale: ${{ env.daysBeforeStale }}
-          days-before-close: 0  # Close immediately after stale
-          stale-issue-label: "inactive"
-          close-issue-label: "closed:no-response"
+          days-before-close: 0 # Close immediately after stale
+          stale-issue-label: 'inactive'
+          close-issue-label: 'closed:no-response'
           stale-issue-message: |
             This issue has been labeled as needing more information and has been inactive for ${{ env.daysBeforeStale }} days. 
             It will be closed now due to lack of additional information.
-            
+
             该问题被标记为"需要更多信息"且已经 ${{ env.daysBeforeStale }} 天没有任何活动，将立即关闭。
           operations-per-run: 50
-          exempt-issue-labels: "pending, Dev Team"
+          exempt-issue-labels: 'pending, Dev Team'
           days-before-pr-stale: -1
           days-before-pr-close: -1
 
@@ -45,11 +45,11 @@ jobs:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-stale: ${{ env.daysBeforeStale }}
           days-before-close: ${{ env.daysBeforeClose }}
-          stale-issue-label: "inactive"
+          stale-issue-label: 'inactive'
           stale-issue-message: |
             This issue has been inactive for a prolonged period and will be closed automatically in ${{ env.daysBeforeClose }} days.
             该问题已长时间处于闲置状态，${{ env.daysBeforeClose }} 天后将自动关闭。
-          exempt-issue-labels: "pending, Dev Team, kind/enhancement"
+          exempt-issue-labels: 'pending, Dev Team, kind/enhancement'
           days-before-pr-stale: -1 # Completely disable stalling for PRs
           days-before-pr-close: -1 # Completely disable closing for PRs
 

.github/workflows/release.yml

@@ -77,9 +77,10 @@ jobs:
 
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          RENDERER_VITE_AIHUBMIX_SECRET: ${{ vars.RENDERER_VITE_AIHUBMIX_SECRET }}
           NODE_OPTIONS: --max-old-space-size=8192
           MAIN_VITE_MINERU_API_KEY: ${{ vars.MAIN_VITE_MINERU_API_KEY }}
+          RENDERER_VITE_AIHUBMIX_SECRET: ${{ vars.RENDERER_VITE_AIHUBMIX_SECRET }}
+          RENDERER_VITE_PPIO_APP_SECRET: ${{ vars.RENDERER_VITE_PPIO_APP_SECRET }}
 
       - name: Build Mac
         if: matrix.os == 'macos-latest'
@@ -93,10 +94,11 @@ jobs:
           APPLE_ID: ${{ vars.APPLE_ID }}
           APPLE_APP_SPECIFIC_PASSWORD: ${{ vars.APPLE_APP_SPECIFIC_PASSWORD }}
           APPLE_TEAM_ID: ${{ vars.APPLE_TEAM_ID }}
-          RENDERER_VITE_AIHUBMIX_SECRET: ${{ vars.RENDERER_VITE_AIHUBMIX_SECRET }}
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NODE_OPTIONS: --max-old-space-size=8192
           MAIN_VITE_MINERU_API_KEY: ${{ vars.MAIN_VITE_MINERU_API_KEY }}
+          RENDERER_VITE_AIHUBMIX_SECRET: ${{ vars.RENDERER_VITE_AIHUBMIX_SECRET }}
+          RENDERER_VITE_PPIO_APP_SECRET: ${{ vars.RENDERER_VITE_PPIO_APP_SECRET }}
 
       - name: Build Windows
         if: matrix.os == 'windows-latest'
@@ -105,9 +107,10 @@ jobs:
           yarn build:win
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          RENDERER_VITE_AIHUBMIX_SECRET: ${{ vars.RENDERER_VITE_AIHUBMIX_SECRET }}
           NODE_OPTIONS: --max-old-space-size=8192
           MAIN_VITE_MINERU_API_KEY: ${{ vars.MAIN_VITE_MINERU_API_KEY }}
+          RENDERER_VITE_AIHUBMIX_SECRET: ${{ vars.RENDERER_VITE_AIHUBMIX_SECRET }}
+          RENDERER_VITE_PPIO_APP_SECRET: ${{ vars.RENDERER_VITE_PPIO_APP_SECRET }}
 
       - name: Release
         uses: ncipollo/release-action@v1
@@ -118,38 +121,3 @@ jobs:
           tag: ${{ steps.get-tag.outputs.tag }}
           artifacts: 'dist/*.exe,dist/*.zip,dist/*.dmg,dist/*.AppImage,dist/*.snap,dist/*.deb,dist/*.rpm,dist/*.tar.gz,dist/latest*.yml,dist/rc*.yml,dist/*.blockmap'
           token: ${{ secrets.GITHUB_TOKEN }}
-
-  dispatch-docs-update:
-    needs: release
-    if: success() && github.repository == 'CherryHQ/cherry-studio' # 确保所有构建成功且在主仓库中运行
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get release tag
-        id: get-tag
-        shell: bash
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "tag=${{ github.event.inputs.tag }}" >> $GITHUB_OUTPUT
-          else
-            echo "tag=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Check if tag is pre-release
-        id: check-tag
-        shell: bash
-        run: |
-          TAG="${{ steps.get-tag.outputs.tag }}"
-          if [[ "$TAG" == *"rc"* || "$TAG" == *"pre-release"* ]]; then
-            echo "is_pre_release=true" >> $GITHUB_OUTPUT
-          else
-            echo "is_pre_release=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Dispatch update-download-version workflow to cherry-studio-docs
-        if: steps.check-tag.outputs.is_pre_release == 'false'
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ secrets.REPO_DISPATCH_TOKEN }}
-          repository: CherryHQ/cherry-studio-docs
-          event-type: update-download-version
-          client-payload: '{"version": "${{ steps.get-tag.outputs.tag }}"}'

.gitignore

@@ -46,6 +46,10 @@ local
 .aider*
 .cursorrules
 .cursor/*
+.claude/*
+.gemini/*
+.trae/*
+.claude-code-router/*
 
 # vitest
 coverage

.vscode/extensions.json

@@ -1,3 +1,3 @@
 {
-  "recommendations": ["dbaeumer.vscode-eslint"]
+  "recommendations": ["dbaeumer.vscode-eslint", "esbenp.prettier-vscode", "editorconfig.editorconfig"]
 }

.vscode/launch.json

@@ -10,7 +10,7 @@
       "windows": {
         "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron-vite.cmd"
       },
-      "runtimeArgs": ["--sourcemap"],
+      "runtimeArgs": ["--inspect", "--sourcemap"],
       "env": {
         "REMOTE_DEBUGGING_PORT": "9222"
       }
@@ -21,7 +21,7 @@
       "request": "attach",
       "type": "chrome",
       "webRoot": "${workspaceFolder}/src/renderer",
-      "timeout": 60000,
+      "timeout": 3000000,
       "presentation": {
         "hidden": true
       }

.vscode/settings.json

@@ -4,6 +4,7 @@
     "source.fixAll.eslint": "explicit",
     "source.organizeImports": "never"
   },
+  "files.eol": "\n",
   "search.exclude": {
     "**/dist/**": true,
     ".yarn/releases/**": true

CONTRIBUTING.md

@@ -1,4 +1,4 @@
-[中文](./docs/CONTRIBUTING.zh.md) | [English](./CONTRIBUTING.md)
+[中文](docs/CONTRIBUTING.zh.md) | [English](CONTRIBUTING.md)
 
 # Cherry Studio Contributor Guide
 
@@ -58,6 +58,10 @@ git commit --signoff -m "Your commit message"
 
 Maintainers are here to help you implement your use case within a reasonable timeframe. They will do their best to review your code and provide constructive feedback promptly. However, if you get stuck during the review process or feel your Pull Request is not receiving the attention it deserves, please contact us via comments in the Issue or through the [Community](README.md#-community).
 
+### Participating in the Test Plan
+
+The Test Plan aims to provide users with a more stable application experience and faster iteration speed. For details, please refer to the [Test Plan](docs/testplan-en.md).
+
 ### Other Suggestions
 
 - **Contact Developers**: Before submitting a PR, you can contact the developers first to discuss or get help.

README.md

@@ -47,6 +47,7 @@
 <div align="center">
   
 [![][github-release-shield]][github-release-link]
+[![][github-nightly-shield]][github-nightly-link]
 [![][github-contributors-shield]][github-contributors-link]
 [![][license-shield]][license-link]
 [![][commercial-shield]][commercial-link]
@@ -182,7 +183,7 @@ Refer to the [Branching Strategy](docs/branching-strategy-en.md) for contributio
 3. **Submit Changes**: Commit and push your changes.
 4. **Open a Pull Request**: Describe your changes and reasons.
 
-For more detailed guidelines, please refer to our [Contributing Guide](./CONTRIBUTING.md).
+For more detailed guidelines, please refer to our [Contributing Guide](CONTRIBUTING.md).
 
 Thank you for your support and contributions!
 
@@ -287,7 +288,7 @@ We believe the Enterprise Edition will become your team's AI productivity engine
 
 <!-- Links & Images -->
 
-[deepwiki-shield]: https://img.shields.io/badge/Deepwiki-CherryHQ-0088CC
+[deepwiki-shield]: https://img.shields.io/badge/Deepwiki-CherryHQ-0088CC?logo=data:image/svg+xml;base64,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
 [deepwiki-link]: https://deepwiki.com/CherryHQ/cherry-studio
 [twitter-shield]: https://img.shields.io/badge/Twitter-CherryStudioApp-0088CC?logo=x
 [twitter-link]: https://twitter.com/CherryStudioHQ
@@ -298,9 +299,11 @@ We believe the Enterprise Edition will become your team's AI productivity engine
 
 <!-- Links & Images -->
 
-[github-release-shield]: https://img.shields.io/github/v/release/CherryHQ/cherry-studio
+[github-release-shield]: https://img.shields.io/github/v/release/CherryHQ/cherry-studio?logo=github
 [github-release-link]: https://github.com/CherryHQ/cherry-studio/releases
-[github-contributors-shield]: https://img.shields.io/github/contributors/CherryHQ/cherry-studio
+[github-nightly-shield]: https://img.shields.io/github/actions/workflow/status/CherryHQ/cherry-studio/nightly-build.yml?label=nightly%20build&logo=github
+[github-nightly-link]: https://github.com/CherryHQ/cherry-studio/actions/workflows/nightly-build.yml
+[github-contributors-shield]: https://img.shields.io/github/contributors/CherryHQ/cherry-studio?logo=github
 [github-contributors-link]: https://github.com/CherryHQ/cherry-studio/graphs/contributors
 
 <!-- Links & Images -->

SECURITY.md

@@ -0,0 +1,64 @@
+# Security Policy
+
+## 📢 Reporting a Vulnerability
+
+At Cherry Studio, we take security seriously and appreciate your efforts to responsibly disclose vulnerabilities. If you discover a security issue, please report it as soon as possible.
+
+**Please do not create public issues for security-related reports.**
+
+- To report a security issue, please use the GitHub Security Advisories tab to "[Open a draft security advisory](https://github.com/CherryHQ/cherry-studio/security/advisories/new)".
+- Include a detailed description of the issue, steps to reproduce, potential impact, and any possible mitigations.
+- If applicable, please also attach proof-of-concept code or screenshots.
+
+We will acknowledge your report within **72 hours** and provide a status update as we investigate.
+
+---
+
+## 🔒 Supported Versions
+
+We aim to support the latest released version and one previous minor release.
+
+| Version         | Supported          |
+|-----------------|--------------------|
+| Latest (`main`) | ✅ Supported       |
+| Previous minor  | ✅ Supported       |
+| Older versions  | ❌ Not supported   |
+
+If you are using an unsupported version, we strongly recommend updating to the latest release to receive security fixes.
+
+---
+
+## 💡 Security Measures
+
+Cherry Studio integrates several security best practices, including:
+
+- Strict dependency updates and regular vulnerability scanning.
+- TypeScript strict mode and linting to reduce potential injection or runtime issues.
+- Enforced code formatting and pre-commit hooks.
+- Internal security reviews before releases.
+- Dedicated MCP (Model Context Protocol) safeguards for model interactions and data privacy.
+
+---
+
+## 🛡️ Disclosure Policy
+
+- We follow a **coordinated disclosure** approach.
+- We will not publicly disclose vulnerabilities until a fix has been developed and released.
+- Credit will be given to researchers who responsibly disclose vulnerabilities, if requested.
+
+---
+
+## 🤝 Acknowledgements
+
+We greatly appreciate contributions from the security community and strive to recognize all researchers who help keep Cherry Studio safe.
+
+---
+
+## 🌟 Questions?
+
+For any security-related questions not involving vulnerabilities, please reach out to:  
+**security@cherry-ai.com**
+
+---
+
+Thank you for helping keep Cherry Studio and its users secure!

docs/CONTRIBUTING.zh.md

@@ -1,6 +1,6 @@
 # Cherry Studio 贡献者指南
 
-[**English**](../CONTRIBUTING.md) | [**中文**](./CONTRIBUTING.zh.md)
+[**English**](../CONTRIBUTING.md) | [**中文**](CONTRIBUTING.zh.md)
 
 欢迎来到 Cherry Studio 的贡献者社区！我们致力于将 Cherry Studio 打造成一个长期提供价值的项目，并希望邀请更多的开发者加入我们的行列。无论您是经验丰富的开发者还是刚刚起步的初学者，您的贡献都将帮助我们更好地服务用户，提升软件质量。
 
@@ -24,7 +24,7 @@
 
 ## 开始之前
 
-请确保阅读了[行为准则](CODE_OF_CONDUCT.md)和[LICENSE](LICENSE)。
+请确保阅读了[行为准则](../CODE_OF_CONDUCT.md)和[LICENSE](../LICENSE)。
 
 ## 开始贡献
 
@@ -32,7 +32,7 @@
 
 ### 测试
 
-未经测试的功能等同于不存在。为确保代码真正有效，应通过单元测试和功能测试覆盖相关流程。因此，在考虑贡献时，也请考虑可测试性。所有测试均可本地运行，无需依赖 CI。请参阅[开发者指南](docs/dev.md#test)中的“Test”部分。
+未经测试的功能等同于不存在。为确保代码真正有效，应通过单元测试和功能测试覆盖相关流程。因此，在考虑贡献时，也请考虑可测试性。所有测试均可本地运行，无需依赖 CI。请参阅[开发者指南](dev.md#test)中的“Test”部分。
 
 ### 拉取请求的自动化测试
 
@@ -60,7 +60,11 @@ git commit --signoff -m "Your commit message"
 
 ### 获取代码审查/合并
 
-维护者在此帮助您在合理时间内实现您的用例。他们会尽力在合理时间内审查您的代码并提供建设性反馈。但如果您在审查过程中受阻，或认为您的 Pull Request 未得到应有的关注，请通过 Issue 中的评论或者[社群](README.md#-community)联系我们
+维护者在此帮助您在合理时间内实现您的用例。他们会尽力在合理时间内审查您的代码并提供建设性反馈。但如果您在审查过程中受阻，或认为您的 Pull Request 未得到应有的关注，请通过 Issue 中的评论或者[社群](README.zh.md#-community)联系我们
+
+### 参与测试计划
+
+测试计划旨在为用户提供更稳定的应用体验和更快的迭代速度，详细情况请参阅[测试计划](testplan-zh.md)。
 
 ### 其他建议
 

docs/README.zh.md

@@ -190,7 +190,7 @@ https://docs.cherry-ai.com
 3. **提交更改**：提交并推送您的更改
 4. **打开 Pull Request**：描述您的更改和原因
 
-有关更详细的指南，请参阅我们的 [贡献指南](./CONTRIBUTING.zh.md)
+有关更详细的指南，请参阅我们的 [贡献指南](CONTRIBUTING.zh.md)
 
 感谢您的支持和贡献！
 

docs/branching-strategy-en.md

@@ -16,6 +16,8 @@ Cherry Studio implements a structured branching strategy to maintain code qualit
   - Only accepts documentation updates and bug fixes
   - Thoroughly tested before production deployment
 
+For details about the `testplan` branch used in the Test Plan, please refer to the [Test Plan](testplan-en.md).
+
 ## Contributing Branches
 
 When contributing to Cherry Studio, please follow these guidelines:

docs/branching-strategy-zh.md

@@ -16,6 +16,8 @@ Cherry Studio 采用结构化的分支策略来维护代码质量并简化开发
   - 只接受文档更新和 bug 修复
   - 经过完整测试后可以发布到生产环境
 
+关于测试计划所使用的`testplan`分支，请查阅[测试计划](testplan-zh.md)。
+
 ## 贡献分支
 
 在为 Cherry Studio 贡献代码时，请遵循以下准则：

docs/features/memory-guide-zh.md

@@ -0,0 +1,222 @@
+# Cherry Studio 记忆功能指南
+
+## 功能介绍
+
+Cherry Studio 的记忆功能是一个强大的工具，能够帮助 AI 助手记住对话中的重要信息、用户偏好和上下文。通过记忆功能，您的 AI 助手可以：
+
+- 📝 **记住重要信息**：自动从对话中提取并存储关键事实和信息
+- 🧠 **个性化响应**：基于存储的记忆提供更加个性化和相关的回答
+- 🔍 **智能检索**：在需要时自动搜索相关记忆，增强对话的连贯性
+- 👥 **多用户支持**：为不同用户维护独立的记忆上下文
+
+记忆功能特别适用于需要长期保持上下文的场景，例如个人助手、客户服务、教育辅导等。
+
+## 如何启用记忆功能
+
+### 1. 全局配置（首次设置）
+
+在使用记忆功能之前，您需要先进行全局配置：
+
+1. 点击侧边栏的 **记忆** 图标（记忆棒图标）进入记忆管理页面
+2. 点击右上角的 **更多** 按钮（三个点），选择 **设置**
+3. 在设置弹窗中配置以下必要项：
+   - **LLM 模型**：选择用于处理记忆的语言模型（推荐使用 GPT-4 或 Claude 等高级模型）
+   - **嵌入模型**：选择用于生成向量嵌入的模型（如 text-embedding-3-small）
+   - **嵌入维度**：输入嵌入模型的维度（通常为 1536）
+4. 点击 **确定** 保存配置
+
+> ⚠️ **注意**：嵌入模型和维度一旦设置后无法更改，请谨慎选择。
+
+### 2. 为助手启用记忆
+
+完成全局配置后，您可以为特定助手启用记忆功能：
+
+1. 进入 **助手** 页面
+2. 选择要启用记忆的助手，点击 **编辑**
+3. 在助手设置中找到 **记忆** 部分
+4. 打开记忆功能开关
+5. 保存助手设置
+
+启用后，该助手将在对话过程中自动提取和使用记忆。
+
+## 使用方法
+
+### 查看记忆
+
+1. 点击侧边栏的 **记忆** 图标进入记忆管理页面
+2. 您可以看到所有存储的记忆卡片，包括：
+   - 记忆内容
+   - 创建时间
+   - 所属用户
+
+### 添加记忆
+
+手动添加记忆有两种方式：
+
+**方式一：在记忆管理页面添加**
+
+1. 点击右上角的 **添加记忆** 按钮
+2. 在弹窗中输入记忆内容
+3. 点击 **添加** 保存
+
+**方式二：在对话中自动提取**
+
+- 当助手启用记忆功能后，系统会自动从对话中提取重要信息并存储为记忆
+
+### 编辑记忆
+
+1. 在记忆卡片上点击 **更多** 按钮（三个点）
+2. 选择 **编辑**
+3. 修改记忆内容
+4. 点击 **保存**
+
+### 删除记忆
+
+1. 在记忆卡片上点击 **更多** 按钮
+2. 选择 **删除**
+3. 确认删除操作
+
+## 记忆搜索
+
+记忆管理页面提供了强大的搜索功能：
+
+1. 在页面顶部的搜索框中输入关键词
+2. 系统会实时过滤显示匹配的记忆
+3. 搜索支持模糊匹配，可以搜索记忆内容的任何部分
+
+## 用户管理
+
+记忆功能支持多用户，您可以为不同的用户维护独立的记忆库：
+
+### 切换用户
+
+1. 在记忆管理页面，点击右上角的用户选择器
+2. 选择要切换到的用户
+3. 页面会自动加载该用户的记忆
+
+### 添加新用户
+
+1. 点击用户选择器
+2. 选择 **添加新用户**
+3. 输入用户 ID（支持字母、数字、下划线和连字符）
+4. 点击 **添加**
+
+### 删除用户
+
+1. 切换到要删除的用户
+2. 点击右上角的 **更多** 按钮
+3. 选择 **删除用户**
+4. 确认删除（注意：这将删除该用户的所有记忆）
+
+> 💡 **提示**：默认用户（default-user）无法删除。
+
+## 设置说明
+
+### LLM 模型
+
+- 用于处理记忆提取和更新的语言模型
+- 建议选择能力较强的模型以获得更好的记忆提取效果
+- 可随时更改
+
+### 嵌入模型
+
+- 用于将文本转换为向量，支持语义搜索
+- 一旦设置后无法更改（为了保证现有记忆的兼容性）
+- 推荐使用 OpenAI 的 text-embedding 系列模型
+
+### 嵌入维度
+
+- 嵌入向量的维度，需要与选择的嵌入模型匹配
+- 常见维度：
+  - text-embedding-3-small: 1536
+  - text-embedding-3-large: 3072
+  - text-embedding-ada-002: 1536
+
+### 自定义提示词（可选）
+
+- **事实提取提示词**：自定义如何从对话中提取信息
+- **记忆更新提示词**：自定义如何更新现有记忆
+
+## 最佳实践
+
+### 1. 合理组织记忆
+
+- 保持记忆简洁明了，每条记忆专注于一个具体信息
+- 使用清晰的语言描述事实，避免模糊表达
+- 定期审查和清理过时或不准确的记忆
+
+### 2. 多用户场景
+
+- 为不同的使用场景创建独立用户（如工作、个人、学习等）
+- 使用有意义的用户 ID，便于识别和管理
+- 定期备份重要用户的记忆数据
+
+### 3. 模型选择建议
+
+- **LLM 模型**：GPT-4、Claude 3 等高级模型能更准确地提取和理解信息
+- **嵌入模型**：选择与您的主要使用语言匹配的模型
+
+### 4. 性能优化
+
+- 避免存储过多冗余记忆，这可能影响搜索性能
+- 定期整理和合并相似的记忆
+- 对于大量记忆的场景，考虑按主题或时间进行分类管理
+
+## 常见问题
+
+### Q: 为什么我无法启用记忆功能？
+
+A: 请确保您已经完成全局配置，包括选择 LLM 模型和嵌入模型。
+
+### Q: 记忆会自动同步到所有助手吗？
+
+A: 不会。每个助手的记忆功能需要单独启用，且记忆是按用户隔离的。
+
+### Q: 如何导出我的记忆数据？
+
+A: 目前系统暂不支持直接导出功能，但所有记忆都存储在本地数据库中。
+
+### Q: 删除的记忆可以恢复吗？
+
+A: 删除操作是永久的，无法恢复。建议在删除前仔细确认。
+
+### Q: 记忆功能会影响对话速度吗？
+
+A: 记忆功能在后台异步处理，不会明显影响对话响应速度。但过多的记忆可能会略微增加搜索时间。
+
+### Q: 如何清空所有记忆？
+
+A: 您可以删除当前用户并重新创建，或者手动删除所有记忆条目。
+
+## 注意事项
+
+### 隐私保护
+
+- 所有记忆数据都存储在您的本地设备上，不会上传到云端
+- 请勿在记忆中存储敏感信息（如密码、私钥等）
+- 定期审查记忆内容，确保没有意外存储的隐私信息
+
+### 数据安全
+
+- 记忆数据存储在本地数据库中
+- 建议定期备份重要数据
+- 更换设备时请注意迁移记忆数据
+
+### 使用限制
+
+- 单条记忆的长度建议不超过 500 字
+- 每个用户的记忆数量建议控制在 1000 条以内
+- 过多的记忆可能影响系统性能
+
+## 技术细节
+
+记忆功能使用了先进的 RAG（检索增强生成）技术：
+
+1. **信息提取**：使用 LLM 从对话中智能提取关键信息
+2. **向量化存储**：通过嵌入模型将文本转换为向量，支持语义搜索
+3. **智能检索**：在对话时自动搜索相关记忆，提供给 AI 作为上下文
+4. **持续学习**：随着对话进行，不断更新和完善记忆库
+
+---
+
+💡 **提示**：记忆功能是 Cherry Studio 的高级特性，合理使用可以大大提升 AI 助手的智能程度和用户体验。如有更多问题，欢迎查阅文档或联系支持团队。

docs/technical/db.settings.md

@@ -0,0 +1,11 @@
+# 数据库设置字段
+
+此文档包含部分字段的数据类型说明。
+
+## 字段
+
+| 字段名                         | 类型                           | 说明         |
+| ------------------------------ | ------------------------------ | ------------ |
+| `translate:target:language`    | `LanguageCode`                 | 翻译目标语言 |
+| `translate:source:language`    | `LanguageCode`                 | 翻译源语言   |
+| `translate:bidirectional:pair` | `[LanguageCode, LanguageCode]` | 双向翻译对   |

docs/testplan-en.md

@@ -0,0 +1,99 @@
+# Test Plan
+
+To provide users with a more stable application experience and faster iteration speed, Cherry Studio has launched the "Test Plan".
+
+## User Guide
+
+The Test Plan is divided into the RC channel and the Beta channel, with the following differences:
+
+- **RC (Release Candidate)**: The features are stable, with fewer bugs, and it is close to the official release.
+- **Beta**: Features may change at any time, and there may be more bugs, but users can experience future features earlier.
+
+Users can enable the "Test Plan" and select the version channel in the software's `Settings` > `About`. Please note that the versions in the "Test Plan" cannot guarantee data consistency, so be sure to back up your data before using them.
+
+Users are welcome to submit issues or provide feedback through other channels for any bugs encountered during testing. Your feedback is very important to us.
+
+## Developer Guide
+
+### Participating in the Test Plan
+
+Developers should submit `PRs` according to the [Contributor Guide](../CONTRIBUTING.md) (and ensure the target branch is `main`). The repository maintainers will evaluate whether the `PR` should be included in the Test Plan based on factors such as the impact of the feature on the application, its importance, and whether broader testing is needed.
+
+If the `PR` is added to the Test Plan, the repository maintainers will:
+
+- Notify the `PR` submitter.
+- Set the PR to `draft` status (to avoid accidental merging into `main` before testing is complete).
+- Set the `milestone` to the specific Test Plan version.
+- Modify the `PR` title.
+
+During participation in the Test Plan, `PR` submitters should:
+
+- Keep the `PR` branch synchronized with the latest `main` (i.e., the `PR` branch should always be based on the latest `main` code).
+- Ensure the `PR` branch is conflict-free.
+- Actively respond to comments & reviews and fix bugs.
+- Enable maintainers to modify the `PR` branch to allow for bug fixes at any time.
+
+Inclusion in the Test Plan does not guarantee the final merging of the `PR`. It may be shelved due to immature features or poor testing feedback.
+
+### Test Plan Lead
+
+A maintainer will be assigned as the lead for a specific version (e.g., `1.5.0-rc`). The responsibilities of the Test Plan lead include:
+
+- Determining whether a `PR` meets the Test Plan requirements and deciding whether it should be included in the current Test Plan.
+- Modifying the status of `PRs` added to the Test Plan and communicating relevant matters with the `PR` submitter.
+- Before the Test Plan release, merging the branches of `PRs` added to the Test Plan (using squash merge) into the corresponding version branch of `testplan` and resolving conflicts.
+- Ensuring the `testplan` branch is synchronized with the latest `main`.
+- Overseeing the Test Plan release.
+
+## In-Depth Understanding
+
+### About `PRs`
+
+A `PR` is a collection of a specific branch (and commits), comments, reviews, and other information, and it is the **smallest management unit** of the Test Plan.
+
+Compared to submitting all features to a single branch, the Test Plan manages features through `PRs`, which offers greater flexibility and efficiency:
+
+- Features can be added or removed between different versions of the Test Plan without cumbersome `revert` operations.
+- Clear feature boundaries and responsibilities are established. Bug fixes are completed within their respective `PRs`, isolating cross-impact and better tracking progress.
+- The `PR` submitter is responsible for resolving conflicts with the latest `main`. The Test Plan lead is responsible for resolving conflicts between `PR` branches. However, since features added to the Test Plan are relatively independent (in other words, if a feature has broad implications, it should be independently included in the Test Plan), conflicts are generally few or simple.
+
+### The `testplan` Branch
+
+The `testplan` branch is a **temporary** branch used for Test Plan releases.
+
+Note:
+
+- **Do not develop based on this branch**. It may change or even be deleted at any time, and there is no guarantee of commit completeness or order.
+- **Do not submit `commits` or `PRs` to this branch**, as they will not be retained.
+- The `testplan` branch is always based on the latest `main` branch (not on a released version), with features added on top.
+
+#### RC Branch
+
+Branch name: `testplan/rc/x.y.z`
+
+Used for RC releases, where `x.y.z` is the target version number. Note that whether it is rc.1 or rc.5, as long as the major version number is `x.y.z`, it is completed in this branch.
+
+Generally, the version number for releases from this branch is named `x.y.z-rc.n`.
+
+#### Beta Branch
+
+Branch name: `testplan/beta/x.y.z`
+
+Used for Beta releases, where `x.y.z` is the target version number. Note that whether it is beta.1 or beta.5, as long as the major version number is `x.y.z`, it is completed in this branch.
+
+Generally, the version number for releases from this branch is named `x.y.z-beta.n`.
+
+### Version Rules
+
+The application version number for the Test Plan is: `x.y.z-CHA.n`, where:
+
+- `x.y.z` is the conventional version number, referred to here as the **target version number**.
+- `CHA` is the channel code (Channel), currently divided into `rc` and `beta`.
+- `n` is the release number, starting from `1`.
+
+Examples of complete version numbers: `1.5.0-rc.3`, `1.5.1-beta.1`, `1.6.0-beta.6`.
+
+The **target version number** of the Test Plan points to the official version number where these features are expected to be added. For example:
+
+- `1.5.0-rc.3` means this is a preview of the `1.5.0` official release (the current latest official release is `1.4.9`, and `1.5.0` has not yet been officially released).
+- `1.5.1-beta.1` means this is a beta version of the `1.5.1` official release (the current latest official release is `1.5.0`, and `1.5.1` has not yet been officially released).

docs/testplan-zh.md

@@ -0,0 +1,99 @@
+# 测试计划
+
+为了给用户提供更稳定的应用体验，并提供更快的迭代速度，Cherry Studio推出“测试计划”。
+
+## 用户指南
+
+测试计划分为RC版通道和Beta版通道吗，区别在于：
+
+- **RC版（预览版）**：RC即Release Candidate，功能已经稳定，BUG较少，接近正式版
+- **Beta版（测试版）**：功能可能随时变化，BUG较多，可以较早体验未来功能
+
+用户可以在软件的`设置`-`关于`中，开启“测试计划”并选择版本通道。请注意“测试计划”的版本无法保证数据的一致性，请使用前一定要备份数据。
+
+用户在测试过程中发现的BUG，欢迎提交issue或通过其他渠道反馈。用户的反馈对我们非常重要。
+
+## 开发者指南
+
+### 参与测试计划
+
+开发者按照[贡献者指南](CONTRIBUTING.zh.md)要求正常提交`PR`（并注意提交target为`main`）。仓库维护者会综合考虑（例如该功能对应用的影响程度，功能的重要性，是否需要更广泛的测试等），决定该`PR`是否应加入测试计划。
+
+若该`PR`加入测试计划，仓库维护者会做如下操作：
+
+- 通知`PR`提交人
+- 设置PR为`draft`状态（避免在测试完成前意外并入`main`）
+- `milestone`设置为具体测试计划版本
+- 修改`PR`标题
+
+`PR`提交人在参与测试计划过程中，应做到：
+
+- 保持`PR`分支与最新`main`同步（即`PR`分支总是应基于最新`main`代码）
+- 保持`PR`分支为无冲突状态
+- 积极响应 comments & reviews，修复bug
+- 开启维护者可以修改`PR`分支的权限，以便维护者能随时修改BUG
+
+加入测试计划并不保证`PR`的最终合并，也有可能由于功能不成熟或测试反馈不佳而搁置
+
+### 测试计划负责人
+
+某个维护者会被指定为某个版本期间（例如`1.5.0-rc`）的测试计划负责人。测试计划负责人的工作为：
+
+- 判断某个`PR`是否符合测试计划要求，并决定是否应合入当期测试计划
+- 修改加入测试计划的`PR`状态，并与`PR`提交人沟通相关事宜
+- 在测试计划发版前，将加入测试计划的`PR`分支逐一合并（采用squash merge）至`testplan`对应版本分支，并解决冲突
+- 保证`testplan`分支与最新`main`同步
+- 负责测试计划发版
+
+## 深入理解
+
+### 关于`PR`
+
+`PR`是特定分支（及commits）、comments、reviews等各种信息的集合，也是测试计划的**最小管理单元**。
+
+相比将所有功能都提交到某个分支，测试计划通过`PR`来管理功能，这可以带来极大的灵活度和效率：
+
+- 测试计划的各个版本间，可以随意增减功能，而无需繁琐的`revert`操作
+- 明确了功能边界和负责人，bug修复在各自`PR`中完成，隔离了交叉影响，也能更好观察进度
+- `PR`提交人负责与最新`main`之间的冲突；测试计划负责人负责各`PR`分支之间的冲突，但因加入测试计划的各功能相对比较独立（话句话说，如果功能牵涉较广，则应独立上测试计划），冲突一般比较少或简单。
+
+### `testplan`分支
+
+`testplan`分支是用于测试计划发版所用的**临时**分支。
+
+注意：
+
+- **请勿基于该分支开发**。该分支随时会变化甚至删除，且并不保证commit的完整和顺序。
+- **请勿向该分支提交`commit`及`PR`**，将不会得到保留
+- `testplan`分支总是基于最新`main`分支（而不是基于已发布版本），在其之上添加功能
+
+#### RC版分支
+
+分支名称：`testplan/rc/x.y.z`
+
+用于RC版的发版，x.y.z为目标版本号，注意无论是rc.1还是rc.5，只要主版本号为x.y.z，都在该分支完成。
+
+一般而言，该分支发版的版本号命名为`x.y.z-rc.n`
+
+#### Beta版分支
+
+分支名称：`testplan/beta/x.y.z`
+
+用于Beta版的发版，x.y.z为目标版本号，注意无论是beta.1还是beta.5，只要主版本号为x.y.z，都在该分支完成。
+
+一般而言，该分支发版的版本号命名为`x.y.z-beta.n`
+
+### 版本规则
+
+测试计划的应用版本号为：`x.y.z-CHA.n`，其中：
+
+- `x.y.z`为一般意义上的版本号，在这里称为**目标版本号**
+- `CHA`为通道号（Channel），现在分为`rc`和`beta`
+- `n`为发版编号，从`1`计数
+
+完整的版本号举例：`1.5.0-rc.3`、`1.5.1-beta.1`、`1.6.0-beta.6`
+
+测试计划的**目标版本号**指向希望添加这些功能的正式版版本号。例如：
+
+- `1.5.0-rc.3`是指，这是`1.5.0`正式版的预览版（当前最新正式版是`1.4.9`，而`1.5.0`正式版还未发布）
+- `1.5.1-beta.1`是指，这是`1.5.1`正式版的测试版（当前最新正式版是`1.5.0`，而`1.5.1`正式版还未发布）

electron-builder.yml

@@ -117,9 +117,8 @@ afterSign: scripts/notarize.js
 artifactBuildCompleted: scripts/artifact-build-completed.js
 releaseInfo:
   releaseNotes: |
-    划词助手：支持 macOS 系统
-    文档处理：增加 MinerU、Doc2x，Mistral 等服务商支持
-    知识库：新的知识库界面，增加扫描版 PDF 支持
-    OCR：macOS 增加系统 OCR 支持
-    服务商：支持一键添加服务商，新增 PH8 大模型开放平台, 支持 PPIO OAuth 登录
-    修复：Linux下数据目录移动问题
+    新增全局记忆功能
+    MCP 支持 DXT 格式导入
+    全局快捷键支持 Linux 系统
+    模型思考过程增加动画效果
+    错误修复和性能优化

electron.vite.config.ts

@@ -8,6 +8,9 @@ const visualizerPlugin = (type: 'renderer' | 'main') => {
   return process.env[`VISUALIZER_${type.toUpperCase()}`] ? [visualizer({ open: true })] : []
 }
 
+const isDev = process.env.NODE_ENV === 'development'
+const isProd = process.env.NODE_ENV === 'production'
+
 export default defineConfig({
   main: {
     plugins: [externalizeDepsPlugin(), ...visualizerPlugin('main')],
@@ -22,16 +25,15 @@ export default defineConfig({
       rollupOptions: {
         external: ['@libsql/client', 'bufferutil', 'utf-8-validate', '@cherrystudio/mac-system-ocr'],
         output: {
-          // 彻底禁用代码分割 - 返回 null 强制单文件打包
-          manualChunks: undefined,
-          // 内联所有动态导入，这是关键配置
-          inlineDynamicImports: true
+          manualChunks: undefined, // 彻底禁用代码分割 - 返回 null 强制单文件打包
+          inlineDynamicImports: true // 内联所有动态导入，这是关键配置
         }
       },
-      sourcemap: process.env.NODE_ENV === 'development'
+      sourcemap: isDev
     },
+    esbuild: isProd ? { legalComments: 'none' } : {},
     optimizeDeps: {
-      noDiscovery: process.env.NODE_ENV === 'development'
+      noDiscovery: isDev
     }
   },
   preload: {
@@ -42,7 +44,7 @@ export default defineConfig({
       }
     },
     build: {
-      sourcemap: process.env.NODE_ENV === 'development'
+      sourcemap: isDev
     }
   },
   renderer: {
@@ -60,14 +62,7 @@ export default defineConfig({
           ]
         ]
       }),
-      // 只在开发环境下启用 CodeInspectorPlugin
-      ...(process.env.NODE_ENV === 'development'
-        ? [
-            CodeInspectorPlugin({
-              bundler: 'vite'
-            })
-          ]
-        : []),
+      ...(isDev ? [CodeInspectorPlugin({ bundler: 'vite' })] : []), // 只在开发环境下启用 CodeInspectorPlugin
       ...visualizerPlugin('renderer')
     ],
     resolve: {
@@ -95,6 +90,7 @@ export default defineConfig({
           selectionAction: resolve(__dirname, 'src/renderer/selectionAction.html')
         }
       }
-    }
+    },
+    esbuild: isProd ? { legalComments: 'none' } : {}
   }
 })

eslint.config.mjs

@@ -26,7 +26,7 @@ export default defineConfig([
       'simple-import-sort/exports': 'error',
       'unused-imports/no-unused-imports': 'error',
       '@eslint-react/no-prop-types': 'error',
-      'prettier/prettier': ['error', { endOfLine: 'auto' }]
+      'prettier/prettier': ['error']
     }
   },
   // Configuration for ensuring compatibility with the original ESLint(8.x) rules

package.json

@@ -1,6 +1,6 @@
 {
   "name": "CherryStudio",
-  "version": "1.4.8",
+  "version": "1.5.1",
   "private": true,
   "description": "A powerful AI assistant for producer.",
   "main": "./out/main/index.js",
@@ -27,12 +27,12 @@
     "build:win": "dotenv npm run build && electron-builder --win --x64 --arm64",
     "build:win:x64": "dotenv npm run build && electron-builder --win --x64",
     "build:win:arm64": "dotenv npm run build && electron-builder --win --arm64",
-    "build:mac": "dotenv electron-vite build && electron-builder --mac --arm64 --x64",
-    "build:mac:arm64": "dotenv electron-vite build && electron-builder --mac --arm64",
-    "build:mac:x64": "dotenv electron-vite build && electron-builder --mac --x64",
-    "build:linux": "dotenv electron-vite build && electron-builder --linux --x64 --arm64",
-    "build:linux:arm64": "dotenv electron-vite build && electron-builder --linux --arm64",
-    "build:linux:x64": "dotenv electron-vite build && electron-builder --linux --x64",
+    "build:mac": "dotenv npm run build && electron-builder --mac --arm64 --x64",
+    "build:mac:arm64": "dotenv npm run build && electron-builder --mac --arm64",
+    "build:mac:x64": "dotenv npm run build && electron-builder --mac --x64",
+    "build:linux": "dotenv npm run build && electron-builder --linux --x64 --arm64",
+    "build:linux:arm64": "dotenv npm run build && electron-builder --linux --arm64",
+    "build:linux:x64": "dotenv npm run build && electron-builder --linux --x64",
     "build:npm": "node scripts/build-npm.js",
     "release": "node scripts/version.js",
     "publish": "yarn build:check && yarn release patch push",
@@ -55,20 +55,24 @@
     "test:lint": "eslint . --ext .js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts",
     "format": "prettier --write .",
     "lint": "eslint . --ext .js,.jsx,.cjs,.mjs,.ts,.tsx,.cts,.mts --fix",
-    "prepare": "husky"
+    "prepare": "git config blame.ignoreRevsFile .git-blame-ignore-revs && husky"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.840.0",
     "@cherrystudio/pdf-to-img-napi": "^0.0.1",
     "@libsql/client": "0.14.0",
     "@libsql/win32-x64-msvc": "^0.4.7",
     "@strongtz/win32-arm64-msvc": "^0.4.7",
+    "iconv-lite": "^0.6.3",
+    "jaison": "^2.0.2",
+    "jschardet": "^3.1.4",
     "jsdom": "26.1.0",
     "macos-release": "^3.4.0",
     "node-stream-zip": "^1.15.0",
     "notion-helper": "^1.3.22",
     "os-proxy-config": "^1.1.2",
     "pdfjs-dist": "4.10.38",
-    "selection-hook": "^1.0.4",
+    "selection-hook": "^1.0.6",
     "turndown": "7.2.0"
   },
   "devDependencies": {
@@ -89,6 +93,7 @@
     "@cherrystudio/embedjs-loader-xml": "^0.1.31",
     "@cherrystudio/embedjs-ollama": "^0.1.31",
     "@cherrystudio/embedjs-openai": "^0.1.31",
+    "@codemirror/view": "^6.0.0",
     "@electron-toolkit/eslint-config-prettier": "^3.0.0",
     "@electron-toolkit/eslint-config-ts": "^3.0.0",
     "@electron-toolkit/preload": "^3.0.0",
@@ -104,7 +109,7 @@
     "@langchain/community": "^0.3.36",
     "@langchain/ollama": "^0.2.1",
     "@mistralai/mistralai": "^1.6.0",
-    "@modelcontextprotocol/sdk": "^1.11.4",
+    "@modelcontextprotocol/sdk": "^1.12.3",
     "@mozilla/readability": "^0.6.0",
     "@notionhq/client": "^2.2.15",
     "@playwright/test": "^1.52.0",
@@ -138,6 +143,8 @@
     "@vitest/coverage-v8": "^3.1.4",
     "@vitest/ui": "^3.1.4",
     "@vitest/web-worker": "^3.1.4",
+    "@viz-js/lang-dot": "^1.0.5",
+    "@viz-js/viz": "^3.14.0",
     "@xyflow/react": "^12.4.4",
     "antd": "patch:antd@npm%3A5.24.7#~/.yarn/patches/antd-npm-5.24.7-356a553ae5.patch",
     "archiver": "^7.0.1",
@@ -170,6 +177,7 @@
     "eslint-plugin-unused-imports": "^4.1.4",
     "fast-diff": "^1.3.0",
     "fast-xml-parser": "^5.2.0",
+    "fetch-socks": "1.3.2",
     "franc-min": "^6.2.0",
     "fs-extra": "^11.2.0",
     "google-auth-library": "^9.15.1",
@@ -222,6 +230,8 @@
     "tiny-pinyin": "^1.3.2",
     "tokenx": "^1.1.0",
     "typescript": "^5.6.2",
+    "undici": "6.21.2",
+    "unified": "^11.0.5",
     "uuid": "^10.0.0",
     "vite": "6.2.6",
     "vitest": "^3.1.4",
@@ -242,7 +252,8 @@
     "app-builder-lib@npm:26.0.13": "patch:app-builder-lib@npm%3A26.0.13#~/.yarn/patches/app-builder-lib-npm-26.0.13-a064c9e1d0.patch",
     "openai@npm:^4.87.3": "patch:openai@npm%3A5.1.0#~/.yarn/patches/openai-npm-5.1.0-0e7b3ccb07.patch",
     "app-builder-lib@npm:26.0.15": "patch:app-builder-lib@npm%3A26.0.15#~/.yarn/patches/app-builder-lib-npm-26.0.15-360e5b0476.patch",
-    "@langchain/core@npm:^0.3.26": "patch:@langchain/core@npm%3A0.3.44#~/.yarn/patches/@langchain-core-npm-0.3.44-41d5c3cb0a.patch"
+    "@langchain/core@npm:^0.3.26": "patch:@langchain/core@npm%3A0.3.44#~/.yarn/patches/@langchain-core-npm-0.3.44-41d5c3cb0a.patch",
+    "undici": "6.21.2"
   },
   "packageManager": "yarn@4.9.1",
   "lint-staged": {

packages/shared/IpcChannel.ts

@@ -36,6 +36,7 @@ export enum IpcChannel {
   App_MacRequestProcessTrust = 'app:mac-request-process-trust',
 
   App_QuoteToMain = 'app:quote-to-main',
+  App_SetDisableHardwareAcceleration = 'app:set-disable-hardware-acceleration',
 
   Notification_Send = 'notification:send',
   Notification_OnClick = 'notification:on-click',
@@ -73,6 +74,10 @@ export enum IpcChannel {
   Mcp_ServersChanged = 'mcp:servers-changed',
   Mcp_ServersUpdated = 'mcp:servers-updated',
   Mcp_CheckConnectivity = 'mcp:check-connectivity',
+  Mcp_UploadDxt = 'mcp:upload-dxt',
+  Mcp_SetProgress = 'mcp:set-progress',
+  Mcp_AbortTool = 'mcp:abort-tool',
+  Mcp_GetServerVersion = 'mcp:get-server-version',
 
   // Python
   Python_Execute = 'python:execute',
@@ -144,6 +149,7 @@ export enum IpcChannel {
   File_Base64File = 'file:base64File',
   File_GetPdfInfo = 'file:getPdfInfo',
   Fs_Read = 'fs:read',
+  File_OpenWithRelativePath = 'file:openWithRelativePath',
 
   // file service
   FileService_Upload = 'file-service:upload',
@@ -164,6 +170,16 @@ export enum IpcChannel {
   Backup_CheckConnection = 'backup:checkConnection',
   Backup_CreateDirectory = 'backup:createDirectory',
   Backup_DeleteWebdavFile = 'backup:deleteWebdavFile',
+  Backup_BackupToLocalDir = 'backup:backupToLocalDir',
+  Backup_RestoreFromLocalBackup = 'backup:restoreFromLocalBackup',
+  Backup_ListLocalBackupFiles = 'backup:listLocalBackupFiles',
+  Backup_DeleteLocalBackupFile = 'backup:deleteLocalBackupFile',
+  Backup_SetLocalBackupDir = 'backup:setLocalBackupDir',
+  Backup_BackupToS3 = 'backup:backupToS3',
+  Backup_RestoreFromS3 = 'backup:restoreFromS3',
+  Backup_ListS3Files = 'backup:listS3Files',
+  Backup_DeleteS3File = 'backup:deleteS3File',
+  Backup_CheckS3Connection = 'backup:checkS3Connection',
 
   // zip
   Zip_Compress = 'zip:compress',
@@ -228,5 +244,17 @@ export enum IpcChannel {
   Selection_ActionWindowMinimize = 'selection:action-window-minimize',
   Selection_ActionWindowPin = 'selection:action-window-pin',
   Selection_ProcessAction = 'selection:process-action',
-  Selection_UpdateActionData = 'selection:update-action-data'
+  Selection_UpdateActionData = 'selection:update-action-data',
+
+  // Memory
+  Memory_Add = 'memory:add',
+  Memory_Search = 'memory:search',
+  Memory_List = 'memory:list',
+  Memory_Delete = 'memory:delete',
+  Memory_Update = 'memory:update',
+  Memory_Get = 'memory:get',
+  Memory_SetConfig = 'memory:set-config',
+  Memory_DeleteUser = 'memory:delete-user',
+  Memory_DeleteAllMemoriesForUser = 'memory:delete-all-memories-for-user',
+  Memory_GetUsersList = 'memory:get-users-list'
 }

packages/shared/config/constant.ts

@@ -193,6 +193,7 @@ const textExtsByCategory = new Map([
       '.htm',
       '.xhtml', // HTML
       '.xml', // XML
+      '.fxml', // JavaFX XML
       '.org', // Org-mode
       '.wiki', // Wiki
       '.tex',

resources/scripts/install-bun.js

@@ -43,7 +43,7 @@ async function downloadBunBinary(platform, arch, version = DEFAULT_BUN_VERSION,
 
   if (!packageName) {
     console.error(`No binary available for ${platformKey}`)
-    return false
+    return 101
   }
 
   // Create output directory structure
@@ -86,7 +86,7 @@ async function downloadBunBinary(platform, arch, version = DEFAULT_BUN_VERSION,
             fs.chmodSync(outputPath, 0o755)
           } catch (chmodError) {
             console.error(`Warning: Failed to set executable permissions on ${filename}`)
-            return false
+            return 102
           }
         }
         console.log(`Extracted ${entry.name} -> ${outputPath}`)
@@ -97,8 +97,10 @@ async function downloadBunBinary(platform, arch, version = DEFAULT_BUN_VERSION,
     // Clean up
     fs.unlinkSync(tempFilename)
     console.log(`Successfully installed bun ${version} for ${platformKey}`)
-    return true
+    return 0
   } catch (error) {
+    let retCode = 103
+
     console.error(`Error installing bun for ${platformKey}: ${error.message}`)
     // Clean up temporary file if it exists
     if (fs.existsSync(tempFilename)) {
@@ -114,9 +116,10 @@ async function downloadBunBinary(platform, arch, version = DEFAULT_BUN_VERSION,
       }
     } catch (cleanupError) {
       console.warn(`Warning: Failed to clean up directory: ${cleanupError.message}`)
+      retCode = 104
     }
 
-    return false
+    return retCode
   }
 }
 
@@ -159,16 +162,21 @@ async function installBun() {
     `Installing bun ${version} for ${platform}-${arch}${isMusl ? ' (MUSL)' : ''}${isBaseline ? ' (baseline)' : ''}...`
   )
 
-  await downloadBunBinary(platform, arch, version, isMusl, isBaseline)
+  return await downloadBunBinary(platform, arch, version, isMusl, isBaseline)
 }
 
 // Run the installation
 installBun()
-  .then(() => {
-    console.log('Installation successful')
-    process.exit(0)
+  .then((retCode) => {
+    if (retCode === 0) {
+      console.log('Installation successful')
+      process.exit(0)
+    } else {
+      console.error('Installation failed')
+      process.exit(retCode)
+    }
   })
   .catch((error) => {
     console.error('Installation failed:', error)
-    process.exit(1)
+    process.exit(100)
   })

resources/scripts/install-uv.js

@@ -44,7 +44,7 @@ async function downloadUvBinary(platform, arch, version = DEFAULT_UV_VERSION, is
 
   if (!packageName) {
     console.error(`No binary available for ${platformKey}`)
-    return false
+    return 101
   }
 
   // Create output directory structure
@@ -85,7 +85,7 @@ async function downloadUvBinary(platform, arch, version = DEFAULT_UV_VERSION, is
             fs.chmodSync(outputPath, 0o755)
           } catch (chmodError) {
             console.error(`Warning: Failed to set executable permissions on ${filename}`)
-            return false
+            return 102
           }
         }
         console.log(`Extracted ${entry.name} -> ${outputPath}`)
@@ -95,8 +95,10 @@ async function downloadUvBinary(platform, arch, version = DEFAULT_UV_VERSION, is
     await zip.close()
     fs.unlinkSync(tempFilename)
     console.log(`Successfully installed uv ${version} for ${platform}-${arch}`)
-    return true
+    return 0
   } catch (error) {
+    let retCode = 103
+
     console.error(`Error installing uv for ${platformKey}: ${error.message}`)
 
     if (fs.existsSync(tempFilename)) {
@@ -112,9 +114,10 @@ async function downloadUvBinary(platform, arch, version = DEFAULT_UV_VERSION, is
       }
     } catch (cleanupError) {
       console.warn(`Warning: Failed to clean up directory: ${cleanupError.message}`)
+      retCode = 104
     }
 
-    return false
+    return retCode
   }
 }
 
@@ -154,16 +157,21 @@ async function installUv() {
 
   console.log(`Installing uv ${version} for ${platform}-${arch}${isMusl ? ' (MUSL)' : ''}...`)
 
-  await downloadUvBinary(platform, arch, version, isMusl)
+  return await downloadUvBinary(platform, arch, version, isMusl)
 }
 
 // Run the installation
 installUv()
-  .then(() => {
-    console.log('Installation successful')
-    process.exit(0)
+  .then((retCode) => {
+    if (retCode === 0) {
+      console.log('Installation successful')
+      process.exit(0)
+    } else {
+      console.error('Installation failed')
+      process.exit(retCode)
+    }
   })
   .catch((error) => {
     console.error('Installation failed:', error)
-    process.exit(1)
+    process.exit(100)
   })

scripts/check-i18n.js

@@ -1,9 +1,60 @@
 'use strict'
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k
+        var desc = Object.getOwnPropertyDescriptor(m, k)
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k]
+            }
+          }
+        }
+        Object.defineProperty(o, k2, desc)
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k
+        o[k2] = m[k]
+      })
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v })
+      }
+    : function (o, v) {
+        o['default'] = v
+      })
+var __importStar =
+  (this && this.__importStar) ||
+  (function () {
+    var ownKeys = function (o) {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        function (o) {
+          var ar = []
+          for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k
+          return ar
+        }
+      return ownKeys(o)
+    }
+    return function (mod) {
+      if (mod && mod.__esModule) return mod
+      var result = {}
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== 'default') __createBinding(result, mod, k[i])
+      __setModuleDefault(result, mod)
+      return result
+    }
+  })()
 Object.defineProperty(exports, '__esModule', { value: true })
-var fs = require('fs')
-var path = require('path')
+var fs = __importStar(require('fs'))
+var path = __importStar(require('path'))
 var translationsDir = path.join(__dirname, '../src/renderer/src/i18n/locales')
-var baseLocale = 'en-us'
+var baseLocale = 'zh-cn'
 var baseFileName = ''.concat(baseLocale, '.json')
 var baseFilePath = path.join(translationsDir, baseFileName)
 /**
@@ -48,12 +99,43 @@ function syncRecursively(target, template) {
   }
   return isUpdated
 }
+/**
+ * 检查 JSON 对象中是否存在重复键，并收集所有重复键
+ * @param obj 要检查的对象
+ * @returns 返回重复键的数组（若无重复则返回空数组）
+ */
+function checkDuplicateKeys(obj) {
+  var keys = new Set()
+  var duplicateKeys = []
+  var checkObject = function (obj, path) {
+    if (path === void 0) {
+      path = ''
+    }
+    for (var key in obj) {
+      var fullPath = path ? ''.concat(path, '.').concat(key) : key
+      if (keys.has(fullPath)) {
+        // 发现重复键时，添加到数组中（避免重复添加）
+        if (!duplicateKeys.includes(fullPath)) {
+          duplicateKeys.push(fullPath)
+        }
+      } else {
+        keys.add(fullPath)
+      }
+      // 递归检查子对象
+      if (typeof obj[key] === 'object' && obj[key] !== null) {
+        checkObject(obj[key], fullPath)
+      }
+    }
+  }
+  checkObject(obj)
+  return duplicateKeys
+}
 function syncTranslations() {
   if (!fs.existsSync(baseFilePath)) {
     console.error(
       '\u4E3B\u6A21\u677F\u6587\u4EF6 '.concat(
         baseFileName,
-        ' \u4E0D\u5B58\u5728\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u6216\u6587\u4EF6\u540D\u3002'
+        ' \u4E0D\u5B58\u5728\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u6216\u6587\u4EF6\u540D'
       )
     )
     return
@@ -63,9 +145,18 @@ function syncTranslations() {
   try {
     baseJson = JSON.parse(baseContent)
   } catch (error) {
-    console.error('\u89E3\u6790 '.concat(baseFileName, ' \u51FA\u9519:'), error)
+    console.error('\u89E3\u6790 '.concat(baseFileName, ' \u51FA\u9519\u3002').concat(error))
     return
   }
+  // 检查主模板是否存在重复键
+  var duplicateKeys = checkDuplicateKeys(baseJson)
+  if (duplicateKeys.length > 0) {
+    throw new Error(
+      '\u4E3B\u6A21\u677F\u6587\u4EF6 '
+        .concat(baseFileName, ' \u5B58\u5728\u4EE5\u4E0B\u91CD\u590D\u952E\uFF1A\n')
+        .concat(duplicateKeys.join('\n'))
+    )
+  }
   var files = fs.readdirSync(translationsDir).filter(function (file) {
     return file.endsWith('.json') && file !== baseFileName
   })
@@ -77,27 +168,19 @@ function syncTranslations() {
       var fileContent = fs.readFileSync(filePath, 'utf-8')
       targetJson = JSON.parse(fileContent)
     } catch (error) {
-      console.error(
-        '\u89E3\u6790 '.concat(
-          file,
-          ' \u51FA\u9519\uFF0C\u8DF3\u8FC7\u6B64\u6587\u4EF6\u3002\u9519\u8BEF\u4FE1\u606F:'
-        ),
-        error
-      )
+      console.error('\u89E3\u6790 '.concat(file, ' \u51FA\u9519\uFF0C\u8DF3\u8FC7\u6B64\u6587\u4EF6\u3002'), error)
       continue
     }
     var isUpdated = syncRecursively(targetJson, baseJson)
     if (isUpdated) {
       try {
-        fs.writeFileSync(filePath, JSON.stringify(targetJson, null, 2), 'utf-8')
-        console.log(
-          '\u6587\u4EF6 '.concat(file, ' \u5DF2\u66F4\u65B0\u540C\u6B65\u4E3B\u6A21\u677F\u7684\u5185\u5BB9\u3002')
-        )
+        fs.writeFileSync(filePath, JSON.stringify(targetJson, null, 2) + '\n', 'utf-8')
+        console.log('\u6587\u4EF6 '.concat(file, ' \u5DF2\u66F4\u65B0\u540C\u6B65\u4E3B\u6A21\u677F\u7684\u5185\u5BB9'))
       } catch (error) {
-        console.error('\u5199\u5165 '.concat(file, ' \u51FA\u9519:'), error)
+        console.error('\u5199\u5165 '.concat(file, ' \u51FA\u9519\u3002').concat(error))
       }
     } else {
-      console.log('\u6587\u4EF6 '.concat(file, ' \u65E0\u9700\u66F4\u65B0\u3002'))
+      console.log('\u6587\u4EF6 '.concat(file, ' \u65E0\u9700\u66F4\u65B0'))
     }
   }
 }

scripts/check-i18n.ts

@@ -2,7 +2,7 @@ import * as fs from 'fs'
 import * as path from 'path'
 
 const translationsDir = path.join(__dirname, '../src/renderer/src/i18n/locales')
-const baseLocale = 'zh-CN'
+const baseLocale = 'zh-cn'
 const baseFileName = `${baseLocale}.json`
 const baseFilePath = path.join(translationsDir, baseFileName)
 
@@ -52,6 +52,39 @@ function syncRecursively(target: any, template: any): boolean {
   return isUpdated
 }
 
+/**
+ * 检查 JSON 对象中是否存在重复键，并收集所有重复键
+ * @param obj 要检查的对象
+ * @returns 返回重复键的数组（若无重复则返回空数组）
+ */
+function checkDuplicateKeys(obj: Record<string, any>): string[] {
+  const keys = new Set<string>()
+  const duplicateKeys: string[] = []
+
+  const checkObject = (obj: Record<string, any>, path: string = '') => {
+    for (const key in obj) {
+      const fullPath = path ? `${path}.${key}` : key
+
+      if (keys.has(fullPath)) {
+        // 发现重复键时，添加到数组中（避免重复添加）
+        if (!duplicateKeys.includes(fullPath)) {
+          duplicateKeys.push(fullPath)
+        }
+      } else {
+        keys.add(fullPath)
+      }
+
+      // 递归检查子对象
+      if (typeof obj[key] === 'object' && obj[key] !== null) {
+        checkObject(obj[key], fullPath)
+      }
+    }
+  }
+
+  checkObject(obj)
+  return duplicateKeys
+}
+
 function syncTranslations() {
   if (!fs.existsSync(baseFilePath)) {
     console.error(`主模板文件 ${baseFileName} 不存在，请检查路径或文件名`)
@@ -63,10 +96,16 @@ function syncTranslations() {
   try {
     baseJson = JSON.parse(baseContent)
   } catch (error) {
-    console.error(`解析 ${baseFileName} 出错:`, error)
+    console.error(`解析 ${baseFileName} 出错。${error}`)
     return
   }
 
+  // 检查主模板是否存在重复键
+  const duplicateKeys = checkDuplicateKeys(baseJson)
+  if (duplicateKeys.length > 0) {
+    throw new Error(`主模板文件 ${baseFileName} 存在以下重复键：\n${duplicateKeys.join('\n')}`)
+  }
+
   const files = fs.readdirSync(translationsDir).filter((file) => file.endsWith('.json') && file !== baseFileName)
 
   for (const file of files) {
@@ -76,7 +115,7 @@ function syncTranslations() {
       const fileContent = fs.readFileSync(filePath, 'utf-8')
       targetJson = JSON.parse(fileContent)
     } catch (error) {
-      console.error(`解析 ${file} 出错，跳过此文件。错误信息:`, error)
+      console.error(`解析 ${file} 出错，跳过此文件。`, error)
       continue
     }
 
@@ -87,7 +126,7 @@ function syncTranslations() {
         fs.writeFileSync(filePath, JSON.stringify(targetJson, null, 2) + '\n', 'utf-8')
         console.log(`文件 ${file} 已更新同步主模板的内容`)
       } catch (error) {
-        console.error(`写入 ${file} 出错:`, error)
+        console.error(`写入 ${file} 出错。${error}`)
       }
     } else {
       console.log(`文件 ${file} 无需更新`)

src/main/index.ts

@@ -11,7 +11,7 @@ import { app } from 'electron'
 import installExtension, { REACT_DEVELOPER_TOOLS, REDUX_DEVTOOLS } from 'electron-devtools-installer'
 import Logger from 'electron-log'
 
-import { isDev, isWin } from './constant'
+import { isDev, isWin, isLinux } from './constant'
 import { registerIpc } from './ipc'
 import { configManager } from './services/ConfigManager'
 import mcpService from './services/MCPService'
@@ -28,6 +28,14 @@ import { windowService } from './services/WindowService'
 
 Logger.initialize()
 
+/**
+ * Disable hardware acceleration if setting is enabled
+ */
+const disableHardwareAcceleration = configManager.getDisableHardwareAcceleration()
+if (disableHardwareAcceleration) {
+  app.disableHardwareAcceleration()
+}
+
 /**
  * Disable chromium's window animations
  * main purpose for this is to avoid the transparent window flashing when it is shown
@@ -38,6 +46,14 @@ if (isWin) {
   app.commandLine.appendSwitch('wm-window-animations-disabled')
 }
 
+/**
+ * Enable GlobalShortcutsPortal for Linux Wayland Protocol
+ * see: https://www.electronjs.org/docs/latest/api/global-shortcut
+ */
+if (isLinux && process.env.XDG_SESSION_TYPE === 'wayland') {
+  app.commandLine.appendSwitch('enable-features', 'GlobalShortcutsPortal')
+}
+
 // Enable features for unresponsive renderer js call stacks
 app.commandLine.appendSwitch('enable-features', 'DocumentPolicyIncludeJSCallStacksInCrashReports')
 app.on('web-contents-created', (_, webContents) => {

src/main/ipc.ts

@@ -8,23 +8,26 @@ import { handleZoomFactor } from '@main/utils/zoom'
 import { UpgradeChannel } from '@shared/config/constant'
 import { IpcChannel } from '@shared/IpcChannel'
 import { FileMetadata, Provider, Shortcut, ThemeMode } from '@types'
-import { BrowserWindow, dialog, ipcMain, session, shell, systemPreferences, webContents } from 'electron'
+import { BrowserWindow, dialog, ipcMain, ProxyConfig, session, shell, systemPreferences, webContents } from 'electron'
 import log from 'electron-log'
 import { Notification } from 'src/renderer/src/types/notification'
 
+import appService from './services/AppService'
 import AppUpdater from './services/AppUpdater'
 import BackupManager from './services/BackupManager'
 import { configManager } from './services/ConfigManager'
 import CopilotService from './services/CopilotService'
+import DxtService from './services/DxtService'
 import { ExportService } from './services/ExportService'
 import FileStorage from './services/FileStorage'
 import FileService from './services/FileSystemService'
 import KnowledgeService from './services/KnowledgeService'
 import mcpService from './services/MCPService'
+import MemoryService from './services/memory/MemoryService'
 import NotificationService from './services/NotificationService'
 import * as NutstoreService from './services/NutstoreService'
 import ObsidianVaultService from './services/ObsidianVaultService'
-import { ProxyConfig, proxyManager } from './services/ProxyManager'
+import { proxyManager } from './services/ProxyManager'
 import { pythonService } from './services/PythonService'
 import { FileServiceManager } from './services/remotefile/FileServiceManager'
 import { searchService } from './services/SearchService'
@@ -45,6 +48,8 @@ const backupManager = new BackupManager()
 const exportService = new ExportService(fileManager)
 const obsidianVaultService = new ObsidianVaultService()
 const vertexAIService = VertexAIService.getInstance()
+const memoryService = MemoryService.getInstance()
+const dxtService = new DxtService()
 
 export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
   const appUpdater = new AppUpdater(mainWindow)
@@ -73,9 +78,9 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
     if (proxy === 'system') {
       proxyConfig = { mode: 'system' }
     } else if (proxy) {
-      proxyConfig = { mode: 'custom', url: proxy }
+      proxyConfig = { mode: 'fixed_servers', proxyRules: proxy }
     } else {
-      proxyConfig = { mode: 'none' }
+      proxyConfig = { mode: 'direct' }
     }
 
     await proxyManager.configureProxy(proxyConfig)
@@ -114,12 +119,8 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
   })
 
   // launch on boot
-  ipcMain.handle(IpcChannel.App_SetLaunchOnBoot, (_, openAtLogin: boolean) => {
-    // Set login item settings for windows and mac
-    // linux is not supported because it requires more file operations
-    if (isWin || isMac) {
-      app.setLoginItemSettings({ openAtLogin })
-    }
+  ipcMain.handle(IpcChannel.App_SetLaunchOnBoot, (_, isLaunchOnBoot: boolean) => {
+    appService.setAppLaunchOnBoot(isLaunchOnBoot)
   })
 
   // launch to tray
@@ -368,6 +369,16 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
   ipcMain.handle(IpcChannel.Backup_CheckConnection, backupManager.checkConnection)
   ipcMain.handle(IpcChannel.Backup_CreateDirectory, backupManager.createDirectory)
   ipcMain.handle(IpcChannel.Backup_DeleteWebdavFile, backupManager.deleteWebdavFile)
+  ipcMain.handle(IpcChannel.Backup_BackupToLocalDir, backupManager.backupToLocalDir)
+  ipcMain.handle(IpcChannel.Backup_RestoreFromLocalBackup, backupManager.restoreFromLocalBackup)
+  ipcMain.handle(IpcChannel.Backup_ListLocalBackupFiles, backupManager.listLocalBackupFiles)
+  ipcMain.handle(IpcChannel.Backup_DeleteLocalBackupFile, backupManager.deleteLocalBackupFile)
+  ipcMain.handle(IpcChannel.Backup_SetLocalBackupDir, backupManager.setLocalBackupDir)
+  ipcMain.handle(IpcChannel.Backup_BackupToS3, backupManager.backupToS3)
+  ipcMain.handle(IpcChannel.Backup_RestoreFromS3, backupManager.restoreFromS3)
+  ipcMain.handle(IpcChannel.Backup_ListS3Files, backupManager.listS3Files)
+  ipcMain.handle(IpcChannel.Backup_DeleteS3File, backupManager.deleteS3File)
+  ipcMain.handle(IpcChannel.Backup_CheckS3Connection, backupManager.checkS3Connection)
 
   // file
   ipcMain.handle(IpcChannel.File_Open, fileManager.open)
@@ -392,6 +403,7 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
   ipcMain.handle(IpcChannel.File_Download, fileManager.downloadFile)
   ipcMain.handle(IpcChannel.File_Copy, fileManager.copyFile)
   ipcMain.handle(IpcChannel.File_BinaryImage, fileManager.binaryImage)
+  ipcMain.handle(IpcChannel.File_OpenWithRelativePath, fileManager.openFileWithRelativePath)
 
   // file service
   ipcMain.handle(IpcChannel.FileService_Upload, async (_, provider: Provider, file: FileMetadata) => {
@@ -445,6 +457,38 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
   ipcMain.handle(IpcChannel.KnowledgeBase_Rerank, KnowledgeService.rerank)
   ipcMain.handle(IpcChannel.KnowledgeBase_Check_Quota, KnowledgeService.checkQuota)
 
+  // memory
+  ipcMain.handle(IpcChannel.Memory_Add, async (_, messages, config) => {
+    return await memoryService.add(messages, config)
+  })
+  ipcMain.handle(IpcChannel.Memory_Search, async (_, query, config) => {
+    return await memoryService.search(query, config)
+  })
+  ipcMain.handle(IpcChannel.Memory_List, async (_, config) => {
+    return await memoryService.list(config)
+  })
+  ipcMain.handle(IpcChannel.Memory_Delete, async (_, id) => {
+    return await memoryService.delete(id)
+  })
+  ipcMain.handle(IpcChannel.Memory_Update, async (_, id, memory, metadata) => {
+    return await memoryService.update(id, memory, metadata)
+  })
+  ipcMain.handle(IpcChannel.Memory_Get, async (_, memoryId) => {
+    return await memoryService.get(memoryId)
+  })
+  ipcMain.handle(IpcChannel.Memory_SetConfig, async (_, config) => {
+    memoryService.setConfig(config)
+  })
+  ipcMain.handle(IpcChannel.Memory_DeleteUser, async (_, userId) => {
+    return await memoryService.deleteUser(userId)
+  })
+  ipcMain.handle(IpcChannel.Memory_DeleteAllMemoriesForUser, async (_, userId) => {
+    return await memoryService.deleteAllMemoriesForUser(userId)
+  })
+  ipcMain.handle(IpcChannel.Memory_GetUsersList, async () => {
+    return await memoryService.getUsersList()
+  })
+
   // window
   ipcMain.handle(IpcChannel.Windows_SetMinimumSize, (_, width: number, height: number) => {
     mainWindow?.setMinimumSize(width, height)
@@ -494,6 +538,29 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
   ipcMain.handle(IpcChannel.Mcp_GetResource, mcpService.getResource)
   ipcMain.handle(IpcChannel.Mcp_GetInstallInfo, mcpService.getInstallInfo)
   ipcMain.handle(IpcChannel.Mcp_CheckConnectivity, mcpService.checkMcpConnectivity)
+  ipcMain.handle(IpcChannel.Mcp_AbortTool, mcpService.abortTool)
+  ipcMain.handle(IpcChannel.Mcp_GetServerVersion, mcpService.getServerVersion)
+  ipcMain.handle(IpcChannel.Mcp_SetProgress, (_, progress: number) => {
+    mainWindow.webContents.send('mcp-progress', progress)
+  })
+
+  // DXT upload handler
+  ipcMain.handle(IpcChannel.Mcp_UploadDxt, async (event, fileBuffer: ArrayBuffer, fileName: string) => {
+    try {
+      // Create a temporary file with the uploaded content
+      const tempPath = await fileManager.createTempFile(event, fileName)
+      await fileManager.writeFile(event, tempPath, Buffer.from(fileBuffer))
+
+      // Process DXT file using the temporary path
+      return await dxtService.uploadDxt(event, tempPath)
+    } catch (error) {
+      log.error('[IPC] DXT upload error:', error)
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Failed to upload DXT file'
+      }
+    }
+  })
 
   // Register Python execution handler
   ipcMain.handle(
@@ -561,4 +628,8 @@ export function registerIpc(mainWindow: BrowserWindow, app: Electron.App) {
   SelectionService.registerIpcHandler()
 
   ipcMain.handle(IpcChannel.App_QuoteToMain, (_, text: string) => windowService.quoteToMainWindow(text))
+
+  ipcMain.handle(IpcChannel.App_SetDisableHardwareAcceleration, (_, isDisable: boolean) => {
+    configManager.setDisableHardwareAcceleration(isDisable)
+  })
 }

src/main/knowledage/preprocess/Doc2xPreprocessProvider.ts

@@ -217,7 +217,7 @@ export default class Doc2xPreprocessProvider extends BasePreprocessProvider {
    * @param filePath 文件路径
    */
   private async convertFile(uid: string, filePath: string): Promise<void> {
-    const fileName = path.basename(filePath).split('.')[0]
+    const fileName = path.parse(filePath).name
     const config = {
       ...this.createAuthConfig(),
       headers: {

src/main/knowledage/preprocess/MineruPreprocessProvider.ts

@@ -111,7 +111,6 @@ export default class MineruPreprocessProvider extends BasePreprocessProvider {
   }
 
   private async validateFile(filePath: string): Promise<void> {
-    const quota = await this.checkQuota()
     const pdfBuffer = await fs.promises.readFile(filePath)
 
     const doc = await this.readPdf(new Uint8Array(pdfBuffer))
@@ -125,10 +124,6 @@ export default class MineruPreprocessProvider extends BasePreprocessProvider {
       const fileSizeMB = Math.round(pdfBuffer.length / (1024 * 1024))
       throw new Error(`PDF file size (${fileSizeMB}MB) exceeds the limit of 200MB`)
     }
-    // 检查配额
-    if (quota <= 0 || quota - doc.numPages <= 0) {
-      throw new Error('MinerU解析配额不足，请申请企业账户或自行部署，剩余额度：' + quota)
-    }
   }
 
   private createProcessedFileInfo(file: FileMetadata, outputPath: string): FileMetadata {

src/main/knowledge/embeddings/Embeddings.ts

@@ -1,19 +1,15 @@
 import type { BaseEmbeddings } from '@cherrystudio/embedjs-interfaces'
-import { KnowledgeBaseParams } from '@types'
+import { ApiClient } from '@types'
 
 import EmbeddingsFactory from './EmbeddingsFactory'
 
 export default class Embeddings {
   private sdk: BaseEmbeddings
-  constructor({ model, provider, apiKey, apiVersion, baseURL, dimensions }: KnowledgeBaseParams) {
+  constructor({ embedApiClient, dimensions }: { embedApiClient: ApiClient; dimensions?: number }) {
     this.sdk = EmbeddingsFactory.create({
-      model,
-      provider,
-      apiKey,
-      apiVersion,
-      baseURL,
+      embedApiClient,
       dimensions
-    } as KnowledgeBaseParams)
+    })
   }
   public async init(): Promise<void> {
     return this.sdk.init()

src/main/knowledge/embeddings/EmbeddingsFactory.ts

@@ -3,28 +3,22 @@ import { OllamaEmbeddings } from '@cherrystudio/embedjs-ollama'
 import { OpenAiEmbeddings } from '@cherrystudio/embedjs-openai'
 import { AzureOpenAiEmbeddings } from '@cherrystudio/embedjs-openai/src/azure-openai-embeddings'
 import { getInstanceName } from '@main/utils'
-import { KnowledgeBaseParams } from '@types'
+import { ApiClient } from '@types'
 
-import { SUPPORTED_DIM_MODELS as VOYAGE_SUPPORTED_DIM_MODELS, VoyageEmbeddings } from './VoyageEmbeddings'
+import { VOYAGE_SUPPORTED_DIM_MODELS } from './utils'
+import { VoyageEmbeddings } from './VoyageEmbeddings'
 
 export default class EmbeddingsFactory {
-  static create({ model, provider, apiKey, apiVersion, baseURL, dimensions }: KnowledgeBaseParams): BaseEmbeddings {
+  static create({ embedApiClient, dimensions }: { embedApiClient: ApiClient; dimensions?: number }): BaseEmbeddings {
     const batchSize = 10
+    const { model, provider, apiKey, apiVersion, baseURL } = embedApiClient
     if (provider === 'voyageai') {
-      if (VOYAGE_SUPPORTED_DIM_MODELS.includes(model)) {
-        return new VoyageEmbeddings({
-          modelName: model,
-          apiKey,
-          outputDimension: dimensions,
-          batchSize: 8
-        })
-      } else {
-        return new VoyageEmbeddings({
-          modelName: model,
-          apiKey,
-          batchSize: 8
-        })
-      }
+      return new VoyageEmbeddings({
+        modelName: model,
+        apiKey,
+        outputDimension: VOYAGE_SUPPORTED_DIM_MODELS.includes(model) ? dimensions : undefined,
+        batchSize: 8
+      })
     }
     if (provider === 'ollama') {
       if (baseURL.includes('v1/')) {

src/main/knowledge/embeddings/VoyageEmbeddings.ts

@@ -1,27 +1,29 @@
 import { BaseEmbeddings } from '@cherrystudio/embedjs-interfaces'
 import { VoyageEmbeddings as _VoyageEmbeddings } from '@langchain/community/embeddings/voyage'
 
+import { VOYAGE_SUPPORTED_DIM_MODELS } from './utils'
+
 /**
  * 支持设置嵌入维度的模型
  */
-export const SUPPORTED_DIM_MODELS = ['voyage-3-large', 'voyage-3.5', 'voyage-3.5-lite', 'voyage-code-3']
 export class VoyageEmbeddings extends BaseEmbeddings {
   private model: _VoyageEmbeddings
   constructor(private readonly configuration?: ConstructorParameters<typeof _VoyageEmbeddings>[0]) {
     super()
-    if (!this.configuration) this.configuration = {}
-    if (!this.configuration.modelName) this.configuration.modelName = 'voyage-3'
-    if (!SUPPORTED_DIM_MODELS.includes(this.configuration.modelName) && this.configuration.outputDimension) {
-      throw new Error(`VoyageEmbeddings only supports ${SUPPORTED_DIM_MODELS.join(', ')}`)
+    if (!this.configuration) {
+      throw new Error('Pass in a configuration.')
     }
+    if (!this.configuration.modelName) this.configuration.modelName = 'voyage-3'
 
-    this.model = new _VoyageEmbeddings(this.configuration)
+    if (!VOYAGE_SUPPORTED_DIM_MODELS.includes(this.configuration.modelName) && this.configuration.outputDimension) {
+      console.error(`VoyageEmbeddings only supports ${VOYAGE_SUPPORTED_DIM_MODELS.join(', ')} to set outputDimension.`)
+      this.model = new _VoyageEmbeddings({ ...this.configuration, outputDimension: undefined })
+    } else {
+      this.model = new _VoyageEmbeddings(this.configuration)
+    }
   }
   override async getDimensions(): Promise<number> {
-    if (!this.configuration?.outputDimension) {
-      throw new Error('You need to pass in the optional dimensions parameter for this model')
-    }
-    return this.configuration?.outputDimension
+    return this.configuration?.outputDimension ?? (this.configuration?.modelName === 'voyage-code-2' ? 1536 : 1024)
   }
 
   override async embedDocuments(texts: string[]): Promise<number[][]> {

src/main/knowledge/embeddings/utils.ts

@@ -0,0 +1,45 @@
+export const VOYAGE_SUPPORTED_DIM_MODELS = ['voyage-3-large', 'voyage-3.5', 'voyage-3.5-lite', 'voyage-code-3']
+
+// NOTE: 下面的暂时没用上，但先留着吧
+export const OPENAI_SUPPORTED_DIM_MODELS = ['text-embedding-3-small', 'text-embedding-3-large']
+
+export const DASHSCOPE_SUPPORTED_DIM_MODELS = ['text-embedding-v3', 'text-embedding-v4']
+
+export const OPENSOURCE_SUPPORTED_DIM_MODELS = ['qwen3-embedding-0.6B', 'qwen3-embedding-4B', 'qwen3-embedding-8B']
+
+export const GOOGLE_SUPPORTED_DIM_MODELS = ['gemini-embedding-exp-03-07', 'gemini-embedding-exp']
+
+export const SUPPORTED_DIM_MODELS = [
+  ...VOYAGE_SUPPORTED_DIM_MODELS,
+  ...OPENAI_SUPPORTED_DIM_MODELS,
+  ...DASHSCOPE_SUPPORTED_DIM_MODELS,
+  ...OPENSOURCE_SUPPORTED_DIM_MODELS,
+  ...GOOGLE_SUPPORTED_DIM_MODELS
+]
+
+/**
+ * 从模型 ID 中提取基础名称。
+ * 例如：
+ * - 'deepseek/deepseek-r1' => 'deepseek-r1'
+ * - 'deepseek-ai/deepseek/deepseek-r1' => 'deepseek-r1'
+ * @param {string} id 模型 ID
+ * @param {string} [delimiter='/'] 分隔符，默认为 '/'
+ * @returns {string} 基础名称
+ */
+export const getBaseModelName = (id: string, delimiter: string = '/'): string => {
+  const parts = id.split(delimiter)
+  return parts[parts.length - 1]
+}
+
+/**
+ * 从模型 ID 中提取基础名称并转换为小写。
+ * 例如：
+ * - 'deepseek/DeepSeek-R1' => 'deepseek-r1'
+ * - 'deepseek-ai/deepseek/DeepSeek-R1' => 'deepseek-r1'
+ * @param {string} id 模型 ID
+ * @param {string} [delimiter='/'] 分隔符，默认为 '/'
+ * @returns {string} 小写的基础名称
+ */
+export const getLowerBaseModelName = (id: string, delimiter: string = '/'): string => {
+  return getBaseModelName(id, delimiter).toLowerCase()
+}

src/main/knowledge/loader/index.ts

@@ -1,8 +1,7 @@
-import * as fs from 'node:fs'
-
 import { JsonLoader, LocalPathLoader, RAGApplication, TextLoader } from '@cherrystudio/embedjs'
 import type { AddLoaderReturn } from '@cherrystudio/embedjs-interfaces'
 import { WebLoader } from '@cherrystudio/embedjs-loader-web'
+import { readTextFileWithAutoEncoding } from '@main/utils/file'
 import { LoaderReturn } from '@shared/config/types'
 import { FileMetadata, KnowledgeBaseParams } from '@types'
 import Logger from 'electron-log'
@@ -115,7 +114,7 @@ export async function addFileLoader(
       // HTML类型处理
       loaderReturn = await ragApplication.addLoader(
         new WebLoader({
-          urlOrContent: fs.readFileSync(file.path, 'utf-8'),
+          urlOrContent: await readTextFileWithAutoEncoding(file.path),
           chunkSize: base.chunkSize,
           chunkOverlap: base.chunkOverlap
         }) as any,
@@ -125,7 +124,7 @@ export async function addFileLoader(
 
     case 'json':
       try {
-        jsonObject = JSON.parse(fs.readFileSync(file.path, 'utf-8'))
+        jsonObject = JSON.parse(await readTextFileWithAutoEncoding(file.path))
       } catch (error) {
         jsonParsed = false
         Logger.warn('[KnowledgeBase] failed parsing json file, falling back to text processing:', file.path, error)
@@ -141,7 +140,7 @@ export async function addFileLoader(
       // 如果是其他文本类型且尚未读取文件，则读取文件
       loaderReturn = await ragApplication.addLoader(
         new TextLoader({
-          text: fs.readFileSync(file.path, 'utf-8'),
+          text: await readTextFileWithAutoEncoding(file.path),
           chunkSize: base.chunkSize,
           chunkOverlap: base.chunkOverlap
         }) as any,

src/main/knowledge/reranker/BaseReranker.ts

@@ -5,7 +5,7 @@ export default abstract class BaseReranker {
   protected base: KnowledgeBaseParams
 
   constructor(base: KnowledgeBaseParams) {
-    if (!base.rerankModel) {
+    if (!base.rerankApiClient) {
       throw new Error('Rerank model is required')
     }
     this.base = base
@@ -17,11 +17,11 @@ export default abstract class BaseReranker {
    * Get Rerank Request Url
    */
   protected getRerankUrl() {
-    if (this.base.rerankModelProvider === 'bailian') {
+    if (this.base.rerankApiClient?.provider === 'bailian') {
       return 'https://dashscope.aliyuncs.com/api/v1/services/rerank/text-rerank/text-rerank'
     }
 
-    let baseURL = this.base.rerankBaseURL
+    let baseURL = this.base.rerankApiClient?.baseURL
 
     if (baseURL && baseURL.endsWith('/')) {
       // `/` 结尾强制使用rerankBaseURL
@@ -39,20 +39,20 @@ export default abstract class BaseReranker {
    * Get Rerank Request Body
    */
   protected getRerankRequestBody(query: string, searchResults: ExtractChunkData[]) {
-    const provider = this.base.rerankModelProvider
+    const provider = this.base.rerankApiClient?.provider
     const documents = searchResults.map((doc) => doc.pageContent)
     const topN = this.base.documentCount
 
     if (provider === 'voyageai') {
       return {
-        model: this.base.rerankModel,
+        model: this.base.rerankApiClient?.model,
         query,
         documents,
         top_k: topN
       }
     } else if (provider === 'bailian') {
       return {
-        model: this.base.rerankModel,
+        model: this.base.rerankApiClient?.model,
         input: {
           query,
           documents
@@ -69,7 +69,7 @@ export default abstract class BaseReranker {
       }
     } else {
       return {
-        model: this.base.rerankModel,
+        model: this.base.rerankApiClient?.model,
         query,
         documents,
         top_n: topN
@@ -81,7 +81,7 @@ export default abstract class BaseReranker {
    * Extract Rerank Result
    */
   protected extractRerankResult(data: any) {
-    const provider = this.base.rerankModelProvider
+    const provider = this.base.rerankApiClient?.provider
     if (provider === 'bailian') {
       return data.output.results
     } else if (provider === 'voyageai') {
@@ -129,7 +129,7 @@ export default abstract class BaseReranker {
 
   public defaultHeaders() {
     return {
-      Authorization: `Bearer ${this.base.rerankApiKey}`,
+      Authorization: `Bearer ${this.base.rerankApiClient?.apiKey}`,
       'Content-Type': 'application/json'
     }
   }

src/main/knowledge/reranker/GeneralReranker.ts

@@ -1,6 +1,6 @@
 import { ExtractChunkData } from '@cherrystudio/embedjs-interfaces'
-import AxiosProxy from '@main/services/AxiosProxy'
 import { KnowledgeBaseParams } from '@types'
+import axios from 'axios'
 
 import BaseReranker from './BaseReranker'
 
@@ -15,7 +15,7 @@ export default class GeneralReranker extends BaseReranker {
     const requestBody = this.getRerankRequestBody(query, searchResults)
 
     try {
-      const { data } = await AxiosProxy.axios.post(url, requestBody, { headers: this.defaultHeaders() })
+      const { data } = await axios.post(url, requestBody, { headers: this.defaultHeaders() })
 
       const rerankResults = this.extractRerankResult(data)
       return this.getRerankResult(searchResults, rerankResults)

src/main/services/AppService.ts

@@ -0,0 +1,81 @@
+import { isDev, isLinux, isMac, isWin } from '@main/constant'
+import { app } from 'electron'
+import log from 'electron-log'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+
+export class AppService {
+  private static instance: AppService
+
+  private constructor() {
+    // Private constructor to prevent direct instantiation
+  }
+
+  public static getInstance(): AppService {
+    if (!AppService.instance) {
+      AppService.instance = new AppService()
+    }
+    return AppService.instance
+  }
+
+  public async setAppLaunchOnBoot(isLaunchOnBoot: boolean): Promise<void> {
+    // Set login item settings for windows and mac
+    // linux is not supported because it requires more file operations
+    if (isWin || isMac) {
+      app.setLoginItemSettings({ openAtLogin: isLaunchOnBoot })
+    } else if (isLinux) {
+      try {
+        const autostartDir = path.join(os.homedir(), '.config', 'autostart')
+        const desktopFile = path.join(autostartDir, isDev ? 'cherry-studio-dev.desktop' : 'cherry-studio.desktop')
+
+        if (isLaunchOnBoot) {
+          // Ensure autostart directory exists
+          try {
+            await fs.promises.access(autostartDir)
+          } catch {
+            await fs.promises.mkdir(autostartDir, { recursive: true })
+          }
+
+          // Get executable path
+          let executablePath = app.getPath('exe')
+          if (process.env.APPIMAGE) {
+            // For AppImage packaged apps, use APPIMAGE environment variable
+            executablePath = process.env.APPIMAGE
+          }
+
+          // Create desktop file content
+          const desktopContent = `[Desktop Entry]
+  Type=Application
+  Name=Cherry Studio
+  Comment=A powerful AI assistant for producer.
+  Exec=${executablePath}
+  Icon=cherrystudio
+  Terminal=false
+  StartupNotify=false
+  Categories=Development;Utility;
+  X-GNOME-Autostart-enabled=true
+  Hidden=false`
+
+          // Write desktop file
+          await fs.promises.writeFile(desktopFile, desktopContent)
+          log.info('Created autostart desktop file for Linux')
+        } else {
+          // Remove desktop file
+          try {
+            await fs.promises.access(desktopFile)
+            await fs.promises.unlink(desktopFile)
+            log.info('Removed autostart desktop file for Linux')
+          } catch {
+            // File doesn't exist, no need to remove
+          }
+        }
+      } catch (error) {
+        log.error('Failed to set launch on boot for Linux:', error)
+      }
+    }
+  }
+}
+
+// Default export as singleton instance
+export default AppService.getInstance()

src/main/services/AxiosProxy.ts

@@ -1,29 +0,0 @@
-import { AxiosInstance, default as axios_ } from 'axios'
-import { ProxyAgent } from 'proxy-agent'
-
-import { proxyManager } from './ProxyManager'
-
-class AxiosProxy {
-  private cacheAxios: AxiosInstance | null = null
-  private proxyAgent: ProxyAgent | null = null
-
-  get axios(): AxiosInstance {
-    const currentProxyAgent = proxyManager.getProxyAgent()
-
-    // 如果代理发生变化或尚未初始化，则重新创建 axios 实例
-    if (this.cacheAxios === null || (currentProxyAgent !== null && this.proxyAgent !== currentProxyAgent)) {
-      this.proxyAgent = currentProxyAgent
-
-      // 创建带有代理配置的 axios 实例
-      this.cacheAxios = axios_.create({
-        proxy: false,
-        httpAgent: currentProxyAgent || undefined,
-        httpsAgent: currentProxyAgent || undefined
-      })
-    }
-
-    return this.cacheAxios
-  }
-}
-
-export default new AxiosProxy()

src/main/services/BackupManager.ts

@@ -1,5 +1,6 @@
 import { IpcChannel } from '@shared/IpcChannel'
 import { WebDavConfig } from '@types'
+import { S3Config } from '@types'
 import archiver from 'archiver'
 import { exec } from 'child_process'
 import { app } from 'electron'
@@ -10,6 +11,7 @@ import * as path from 'path'
 import { CreateDirectoryOptions, FileStat } from 'webdav'
 
 import { getDataPath } from '../utils'
+import S3Storage from './S3Storage'
 import WebDav from './WebDav'
 import { windowService } from './WindowService'
 
@@ -25,6 +27,16 @@ class BackupManager {
     this.restoreFromWebdav = this.restoreFromWebdav.bind(this)
     this.listWebdavFiles = this.listWebdavFiles.bind(this)
     this.deleteWebdavFile = this.deleteWebdavFile.bind(this)
+    this.listLocalBackupFiles = this.listLocalBackupFiles.bind(this)
+    this.deleteLocalBackupFile = this.deleteLocalBackupFile.bind(this)
+    this.backupToLocalDir = this.backupToLocalDir.bind(this)
+    this.restoreFromLocalBackup = this.restoreFromLocalBackup.bind(this)
+    this.setLocalBackupDir = this.setLocalBackupDir.bind(this)
+    this.backupToS3 = this.backupToS3.bind(this)
+    this.restoreFromS3 = this.restoreFromS3.bind(this)
+    this.listS3Files = this.listS3Files.bind(this)
+    this.deleteS3File = this.deleteS3File.bind(this)
+    this.checkS3Connection = this.checkS3Connection.bind(this)
   }
 
   private async setWritableRecursive(dirPath: string): Promise<void> {
@@ -85,7 +97,11 @@ class BackupManager {
 
     const onProgress = (processData: { stage: string; progress: number; total: number }) => {
       mainWindow?.webContents.send(IpcChannel.BackupProgress, processData)
-      Logger.log('[BackupManager] backup progress', processData)
+      // 只在关键阶段记录日志：开始、结束和主要阶段转换点
+      const logStages = ['preparing', 'writing_data', 'preparing_compression', 'completed']
+      if (logStages.includes(processData.stage) || processData.progress === 100) {
+        Logger.log('[BackupManager] backup progress', processData)
+      }
     }
 
     try {
@@ -147,18 +163,23 @@ class BackupManager {
       let totalBytes = 0
       let processedBytes = 0
 
-      // 首先计算总文件数和总大小
+      // 首先计算总文件数和总大小，但不记录详细日志
       const calculateTotals = async (dirPath: string) => {
-        const items = await fs.readdir(dirPath, { withFileTypes: true })
-        for (const item of items) {
-          const fullPath = path.join(dirPath, item.name)
-          if (item.isDirectory()) {
-            await calculateTotals(fullPath)
-          } else {
-            totalEntries++
-            const stats = await fs.stat(fullPath)
-            totalBytes += stats.size
+        try {
+          const items = await fs.readdir(dirPath, { withFileTypes: true })
+          for (const item of items) {
+            const fullPath = path.join(dirPath, item.name)
+            if (item.isDirectory()) {
+              await calculateTotals(fullPath)
+            } else {
+              totalEntries++
+              const stats = await fs.stat(fullPath)
+              totalBytes += stats.size
+            }
           }
+        } catch (error) {
+          // 仅在出错时记录日志
+          Logger.error('[BackupManager] Error calculating totals:', error)
         }
       }
 
@@ -230,7 +251,11 @@ class BackupManager {
 
     const onProgress = (processData: { stage: string; progress: number; total: number }) => {
       mainWindow?.webContents.send(IpcChannel.RestoreProgress, processData)
-      Logger.log('[BackupManager] restore progress', processData)
+      // 只在关键阶段记录日志
+      const logStages = ['preparing', 'extracting', 'extracted', 'reading_data', 'completed']
+      if (logStages.includes(processData.stage) || processData.progress === 100) {
+        Logger.log('[BackupManager] restore progress', processData)
+      }
     }
 
     try {
@@ -296,14 +321,22 @@ class BackupManager {
   async backupToWebdav(_: Electron.IpcMainInvokeEvent, data: string, webdavConfig: WebDavConfig) {
     const filename = webdavConfig.fileName || 'cherry-studio.backup.zip'
     const backupedFilePath = await this.backup(_, filename, data, undefined, webdavConfig.skipBackupFile)
-    const contentLength = (await fs.stat(backupedFilePath)).size
     const webdavClient = new WebDav(webdavConfig)
     try {
-      const result = await webdavClient.putFileContents(filename, fs.createReadStream(backupedFilePath), {
-        overwrite: true,
-        contentLength
-      })
-      // 上传成功后删除本地备份文件
+      let result
+      if (webdavConfig.disableStream) {
+        const fileContent = await fs.readFile(backupedFilePath)
+        result = await webdavClient.putFileContents(filename, fileContent, {
+          overwrite: true
+        })
+      } else {
+        const contentLength = (await fs.stat(backupedFilePath)).size
+        result = await webdavClient.putFileContents(filename, fs.createReadStream(backupedFilePath), {
+          overwrite: true,
+          contentLength
+        })
+      }
+
       await fs.remove(backupedFilePath)
       return result
     } catch (error) {
@@ -382,21 +415,54 @@ class BackupManager {
     destination: string,
     onProgress: (size: number) => void
   ): Promise<void> {
-    const items = await fs.readdir(source, { withFileTypes: true })
+    // 先统计总文件数
+    let totalFiles = 0
+    let processedFiles = 0
+    let lastProgressReported = 0
 
-    for (const item of items) {
-      const sourcePath = path.join(source, item.name)
-      const destPath = path.join(destination, item.name)
+    // 计算总文件数
+    const countFiles = async (dir: string): Promise<number> => {
+      let count = 0
+      const items = await fs.readdir(dir, { withFileTypes: true })
+      for (const item of items) {
+        if (item.isDirectory()) {
+          count += await countFiles(path.join(dir, item.name))
+        } else {
+          count++
+        }
+      }
+      return count
+    }
 
-      if (item.isDirectory()) {
-        await fs.ensureDir(destPath)
-        await this.copyDirWithProgress(sourcePath, destPath, onProgress)
-      } else {
-        const stats = await fs.stat(sourcePath)
-        await fs.copy(sourcePath, destPath)
-        onProgress(stats.size)
+    totalFiles = await countFiles(source)
+
+    // 复制文件并更新进度
+    const copyDir = async (src: string, dest: string): Promise<void> => {
+      const items = await fs.readdir(src, { withFileTypes: true })
+
+      for (const item of items) {
+        const sourcePath = path.join(src, item.name)
+        const destPath = path.join(dest, item.name)
+
+        if (item.isDirectory()) {
+          await fs.ensureDir(destPath)
+          await copyDir(sourcePath, destPath)
+        } else {
+          const stats = await fs.stat(sourcePath)
+          await fs.copy(sourcePath, destPath)
+          processedFiles++
+
+          // 只在进度变化超过5%时报告进度
+          const currentProgress = Math.floor((processedFiles / totalFiles) * 100)
+          if (currentProgress - lastProgressReported >= 5 || processedFiles === totalFiles) {
+            lastProgressReported = currentProgress
+            onProgress(stats.size)
+          }
+        }
       }
     }
+
+    await copyDir(source, destination)
   }
 
   async checkConnection(_: Electron.IpcMainInvokeEvent, webdavConfig: WebDavConfig) {
@@ -423,6 +489,191 @@ class BackupManager {
       throw new Error(error.message || 'Failed to delete backup file')
     }
   }
+
+  async backupToLocalDir(
+    _: Electron.IpcMainInvokeEvent,
+    data: string,
+    fileName: string,
+    localConfig: {
+      localBackupDir: string
+      skipBackupFile: boolean
+    }
+  ) {
+    try {
+      const backupDir = localConfig.localBackupDir
+      // Create backup directory if it doesn't exist
+      await fs.ensureDir(backupDir)
+
+      const backupedFilePath = await this.backup(_, fileName, data, backupDir, localConfig.skipBackupFile)
+      return backupedFilePath
+    } catch (error) {
+      Logger.error('[BackupManager] Local backup failed:', error)
+      throw error
+    }
+  }
+
+  async backupToS3(_: Electron.IpcMainInvokeEvent, data: string, s3Config: S3Config) {
+    const os = require('os')
+    const deviceName = os.hostname ? os.hostname() : 'device'
+    const timestamp = new Date()
+      .toISOString()
+      .replace(/[-:T.Z]/g, '')
+      .slice(0, 14)
+    const filename = s3Config.fileName || `cherry-studio.backup.${deviceName}.${timestamp}.zip`
+
+    Logger.log(`[BackupManager] Starting S3 backup to ${filename}`)
+
+    const backupedFilePath = await this.backup(_, filename, data, undefined, s3Config.skipBackupFile)
+    const s3Client = new S3Storage(s3Config)
+    try {
+      const fileBuffer = await fs.promises.readFile(backupedFilePath)
+      const result = await s3Client.putFileContents(filename, fileBuffer)
+      await fs.remove(backupedFilePath)
+
+      Logger.log(`[BackupManager] S3 backup completed successfully: ${filename}`)
+      return result
+    } catch (error) {
+      Logger.error(`[BackupManager] S3 backup failed:`, error)
+      await fs.remove(backupedFilePath)
+      throw error
+    }
+  }
+
+  async restoreFromLocalBackup(_: Electron.IpcMainInvokeEvent, fileName: string, localBackupDir: string) {
+    try {
+      const backupDir = localBackupDir
+      const backupPath = path.join(backupDir, fileName)
+
+      if (!fs.existsSync(backupPath)) {
+        throw new Error(`Backup file not found: ${backupPath}`)
+      }
+
+      return await this.restore(_, backupPath)
+    } catch (error) {
+      Logger.error('[BackupManager] Local restore failed:', error)
+      throw error
+    }
+  }
+
+  async listLocalBackupFiles(_: Electron.IpcMainInvokeEvent, localBackupDir: string) {
+    try {
+      const files = await fs.readdir(localBackupDir)
+      const result: Array<{ fileName: string; modifiedTime: string; size: number }> = []
+
+      for (const file of files) {
+        const filePath = path.join(localBackupDir, file)
+        const stat = await fs.stat(filePath)
+
+        if (stat.isFile() && file.endsWith('.zip')) {
+          result.push({
+            fileName: file,
+            modifiedTime: stat.mtime.toISOString(),
+            size: stat.size
+          })
+        }
+      }
+
+      // Sort by modified time, newest first
+      return result.sort((a, b) => new Date(b.modifiedTime).getTime() - new Date(a.modifiedTime).getTime())
+    } catch (error) {
+      Logger.error('[BackupManager] List local backup files failed:', error)
+      throw error
+    }
+  }
+
+  async deleteLocalBackupFile(_: Electron.IpcMainInvokeEvent, fileName: string, localBackupDir: string) {
+    try {
+      const filePath = path.join(localBackupDir, fileName)
+
+      if (!fs.existsSync(filePath)) {
+        throw new Error(`Backup file not found: ${filePath}`)
+      }
+
+      await fs.remove(filePath)
+      return true
+    } catch (error) {
+      Logger.error('[BackupManager] Delete local backup file failed:', error)
+      throw error
+    }
+  }
+
+  async setLocalBackupDir(_: Electron.IpcMainInvokeEvent, dirPath: string) {
+    try {
+      // Check if directory exists
+      await fs.ensureDir(dirPath)
+      return true
+    } catch (error) {
+      Logger.error('[BackupManager] Set local backup directory failed:', error)
+      throw error
+    }
+  }
+
+  async restoreFromS3(_: Electron.IpcMainInvokeEvent, s3Config: S3Config) {
+    const filename = s3Config.fileName || 'cherry-studio.backup.zip'
+
+    Logger.log(`[BackupManager] Starting restore from S3: ${filename}`)
+
+    const s3Client = new S3Storage(s3Config)
+    try {
+      const retrievedFile = await s3Client.getFileContents(filename)
+      const backupedFilePath = path.join(this.backupDir, filename)
+      if (!fs.existsSync(this.backupDir)) {
+        fs.mkdirSync(this.backupDir, { recursive: true })
+      }
+      await new Promise<void>((resolve, reject) => {
+        const writeStream = fs.createWriteStream(backupedFilePath)
+        writeStream.write(retrievedFile as Buffer)
+        writeStream.end()
+        writeStream.on('finish', () => resolve())
+        writeStream.on('error', (error) => reject(error))
+      })
+
+      Logger.log(`[BackupManager] S3 restore file downloaded successfully: ${filename}`)
+      return await this.restore(_, backupedFilePath)
+    } catch (error: any) {
+      Logger.error('[BackupManager] Failed to restore from S3:', error)
+      throw new Error(error.message || 'Failed to restore backup file')
+    }
+  }
+
+  listS3Files = async (_: Electron.IpcMainInvokeEvent, s3Config: S3Config) => {
+    try {
+      const s3Client = new S3Storage(s3Config)
+
+      const objects = await s3Client.listFiles()
+      const files = objects
+        .filter((obj) => obj.key.endsWith('.zip'))
+        .map((obj) => {
+          const segments = obj.key.split('/')
+          const fileName = segments[segments.length - 1]
+          return {
+            fileName,
+            modifiedTime: obj.lastModified || '',
+            size: obj.size
+          }
+        })
+
+      return files.sort((a, b) => new Date(b.modifiedTime).getTime() - new Date(a.modifiedTime).getTime())
+    } catch (error: any) {
+      Logger.error('Failed to list S3 files:', error)
+      throw new Error(error.message || 'Failed to list backup files')
+    }
+  }
+
+  async deleteS3File(_: Electron.IpcMainInvokeEvent, fileName: string, s3Config: S3Config) {
+    try {
+      const s3Client = new S3Storage(s3Config)
+      return await s3Client.deleteFile(fileName)
+    } catch (error: any) {
+      Logger.error('Failed to delete S3 file:', error)
+      throw new Error(error.message || 'Failed to delete backup file')
+    }
+  }
+
+  async checkS3Connection(_: Electron.IpcMainInvokeEvent, s3Config: S3Config) {
+    const s3Client = new S3Storage(s3Config)
+    return await s3Client.checkConnection()
+  }
 }
 
 export default BackupManager

src/main/services/ConfigManager.ts

@@ -24,7 +24,9 @@ export enum ConfigKeys {
   SelectionAssistantFollowToolbar = 'selectionAssistantFollowToolbar',
   SelectionAssistantRemeberWinSize = 'selectionAssistantRemeberWinSize',
   SelectionAssistantFilterMode = 'selectionAssistantFilterMode',
-  SelectionAssistantFilterList = 'selectionAssistantFilterList'
+  SelectionAssistantFilterList = 'selectionAssistantFilterList',
+  DisableHardwareAcceleration = 'disableHardwareAcceleration',
+  Proxy = 'proxy'
 }
 
 export class ConfigManager {
@@ -218,6 +220,14 @@ export class ConfigManager {
     this.setAndNotify(ConfigKeys.SelectionAssistantFilterList, value)
   }
 
+  getDisableHardwareAcceleration(): boolean {
+    return this.get<boolean>(ConfigKeys.DisableHardwareAcceleration, false)
+  }
+
+  setDisableHardwareAcceleration(value: boolean) {
+    this.set(ConfigKeys.DisableHardwareAcceleration, value)
+  }
+
   setAndNotify(key: string, value: unknown) {
     this.set(key, value, true)
   }

src/main/services/CopilotService.ts

@@ -1,11 +1,10 @@
 import { AxiosRequestConfig } from 'axios'
+import axios from 'axios'
 import { app, safeStorage } from 'electron'
 import Logger from 'electron-log'
 import fs from 'fs/promises'
 import path from 'path'
 
-import aoxisProxy from './AxiosProxy'
-
 // 配置常量，集中管理
 const CONFIG = {
   GITHUB_CLIENT_ID: 'Iv1.b507a08c87ecfe98',
@@ -96,7 +95,7 @@ class CopilotService {
         }
       }
 
-      const response = await aoxisProxy.axios.get(CONFIG.API_URLS.GITHUB_USER, config)
+      const response = await axios.get(CONFIG.API_URLS.GITHUB_USER, config)
       return {
         login: response.data.login,
         avatar: response.data.avatar_url
@@ -117,7 +116,7 @@ class CopilotService {
     try {
       this.updateHeaders(headers)
 
-      const response = await aoxisProxy.axios.post<AuthResponse>(
+      const response = await axios.post<AuthResponse>(
         CONFIG.API_URLS.GITHUB_DEVICE_CODE,
         {
           client_id: CONFIG.GITHUB_CLIENT_ID,
@@ -149,7 +148,7 @@ class CopilotService {
       await this.delay(currentDelay)
 
       try {
-        const response = await aoxisProxy.axios.post<TokenResponse>(
+        const response = await axios.post<TokenResponse>(
           CONFIG.API_URLS.GITHUB_ACCESS_TOKEN,
           {
             client_id: CONFIG.GITHUB_CLIENT_ID,
@@ -211,7 +210,7 @@ class CopilotService {
         }
       }
 
-      const response = await aoxisProxy.axios.get<CopilotTokenResponse>(CONFIG.API_URLS.COPILOT_TOKEN, config)
+      const response = await axios.get<CopilotTokenResponse>(CONFIG.API_URLS.COPILOT_TOKEN, config)
 
       return response.data
     } catch (error) {

src/main/services/DxtService.ts

@@ -0,0 +1,396 @@
+import { getMcpDir, getTempDir } from '@main/utils/file'
+import logger from 'electron-log'
+import * as fs from 'fs'
+import StreamZip from 'node-stream-zip'
+import * as os from 'os'
+import * as path from 'path'
+import { v4 as uuidv4 } from 'uuid'
+
+// Type definitions
+export interface DxtManifest {
+  dxt_version: string
+  name: string
+  display_name?: string
+  version: string
+  description?: string
+  long_description?: string
+  author?: {
+    name?: string
+    email?: string
+    url?: string
+  }
+  repository?: {
+    type?: string
+    url?: string
+  }
+  homepage?: string
+  documentation?: string
+  support?: string
+  icon?: string
+  server: {
+    type: string
+    entry_point: string
+    mcp_config: {
+      command: string
+      args: string[]
+      env?: Record<string, string>
+      platform_overrides?: {
+        [platform: string]: {
+          command?: string
+          args?: string[]
+          env?: Record<string, string>
+        }
+      }
+    }
+  }
+  tools?: Array<{
+    name: string
+    description: string
+  }>
+  keywords?: string[]
+  license?: string
+  user_config?: Record<string, any>
+  compatibility?: {
+    claude_desktop?: string
+    platforms?: string[]
+    runtimes?: Record<string, string>
+  }
+}
+
+export interface DxtUploadResult {
+  success: boolean
+  data?: {
+    manifest: DxtManifest
+    extractDir: string
+  }
+  error?: string
+}
+
+export function performVariableSubstitution(
+  value: string,
+  extractDir: string,
+  userConfig?: Record<string, any>
+): string {
+  let result = value
+
+  // Replace ${__dirname} with the extraction directory
+  result = result.replace(/\$\{__dirname\}/g, extractDir)
+
+  // Replace ${HOME} with user's home directory
+  result = result.replace(/\$\{HOME\}/g, os.homedir())
+
+  // Replace ${DESKTOP} with user's desktop directory
+  const desktopDir = path.join(os.homedir(), 'Desktop')
+  result = result.replace(/\$\{DESKTOP\}/g, desktopDir)
+
+  // Replace ${DOCUMENTS} with user's documents directory
+  const documentsDir = path.join(os.homedir(), 'Documents')
+  result = result.replace(/\$\{DOCUMENTS\}/g, documentsDir)
+
+  // Replace ${DOWNLOADS} with user's downloads directory
+  const downloadsDir = path.join(os.homedir(), 'Downloads')
+  result = result.replace(/\$\{DOWNLOADS\}/g, downloadsDir)
+
+  // Replace ${pathSeparator} or ${/} with the platform-specific path separator
+  result = result.replace(/\$\{pathSeparator\}/g, path.sep)
+  result = result.replace(/\$\{\/\}/g, path.sep)
+
+  // Replace ${user_config.KEY} with user-configured values
+  if (userConfig) {
+    result = result.replace(/\$\{user_config\.([^}]+)\}/g, (match, key) => {
+      return userConfig[key] || match // Keep original if not found
+    })
+  }
+
+  return result
+}
+
+export function applyPlatformOverrides(mcpConfig: any, extractDir: string, userConfig?: Record<string, any>): any {
+  const platform = process.platform
+  const resolvedConfig = { ...mcpConfig }
+
+  // Apply platform-specific overrides
+  if (mcpConfig.platform_overrides && mcpConfig.platform_overrides[platform]) {
+    const override = mcpConfig.platform_overrides[platform]
+
+    // Override command if specified
+    if (override.command) {
+      resolvedConfig.command = override.command
+    }
+
+    // Override args if specified
+    if (override.args) {
+      resolvedConfig.args = override.args
+    }
+
+    // Merge environment variables
+    if (override.env) {
+      resolvedConfig.env = { ...resolvedConfig.env, ...override.env }
+    }
+  }
+
+  // Apply variable substitution to all string values
+  if (resolvedConfig.command) {
+    resolvedConfig.command = performVariableSubstitution(resolvedConfig.command, extractDir, userConfig)
+  }
+
+  if (resolvedConfig.args) {
+    resolvedConfig.args = resolvedConfig.args.map((arg: string) =>
+      performVariableSubstitution(arg, extractDir, userConfig)
+    )
+  }
+
+  if (resolvedConfig.env) {
+    for (const [key, value] of Object.entries(resolvedConfig.env)) {
+      resolvedConfig.env[key] = performVariableSubstitution(value as string, extractDir, userConfig)
+    }
+  }
+
+  return resolvedConfig
+}
+
+export interface ResolvedMcpConfig {
+  command: string
+  args: string[]
+  env?: Record<string, string>
+}
+
+class DxtService {
+  private tempDir = path.join(getTempDir(), 'dxt_uploads')
+  private mcpDir = getMcpDir()
+
+  constructor() {
+    this.ensureDirectories()
+  }
+
+  private ensureDirectories() {
+    try {
+      // Create temp directory
+      if (!fs.existsSync(this.tempDir)) {
+        fs.mkdirSync(this.tempDir, { recursive: true })
+      }
+      // Create MCP directory
+      if (!fs.existsSync(this.mcpDir)) {
+        fs.mkdirSync(this.mcpDir, { recursive: true })
+      }
+    } catch (error) {
+      logger.error('[DxtService] Failed to create directories:', error)
+    }
+  }
+
+  private async moveDirectory(source: string, destination: string): Promise<void> {
+    try {
+      // Try rename first (works if on same filesystem)
+      fs.renameSync(source, destination)
+    } catch (error) {
+      // If rename fails (cross-filesystem), use copy + remove
+      logger.info('[DxtService] Cross-filesystem move detected, using copy + remove')
+
+      // Ensure parent directory exists
+      const parentDir = path.dirname(destination)
+      if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true })
+      }
+
+      // Recursively copy directory
+      await this.copyDirectory(source, destination)
+
+      // Remove source directory
+      fs.rmSync(source, { recursive: true, force: true })
+    }
+  }
+
+  private async copyDirectory(source: string, destination: string): Promise<void> {
+    // Create destination directory
+    fs.mkdirSync(destination, { recursive: true })
+
+    // Read source directory
+    const entries = fs.readdirSync(source, { withFileTypes: true })
+
+    // Copy each entry
+    for (const entry of entries) {
+      const sourcePath = path.join(source, entry.name)
+      const destPath = path.join(destination, entry.name)
+
+      if (entry.isDirectory()) {
+        await this.copyDirectory(sourcePath, destPath)
+      } else {
+        fs.copyFileSync(sourcePath, destPath)
+      }
+    }
+  }
+
+  public async uploadDxt(_: Electron.IpcMainInvokeEvent, filePath: string): Promise<DxtUploadResult> {
+    const tempExtractDir = path.join(this.tempDir, `dxt_${uuidv4()}`)
+
+    try {
+      // Validate file exists
+      if (!fs.existsSync(filePath)) {
+        throw new Error('DXT file not found')
+      }
+
+      // Extract the DXT file (which is a ZIP archive) to a temporary directory
+      logger.info('[DxtService] Extracting DXT file:', filePath)
+
+      const zip = new StreamZip.async({ file: filePath })
+      await zip.extract(null, tempExtractDir)
+      await zip.close()
+
+      // Read and validate the manifest.json
+      const manifestPath = path.join(tempExtractDir, 'manifest.json')
+      if (!fs.existsSync(manifestPath)) {
+        throw new Error('manifest.json not found in DXT file')
+      }
+
+      const manifestContent = fs.readFileSync(manifestPath, 'utf-8')
+      const manifest: DxtManifest = JSON.parse(manifestContent)
+
+      // Validate required fields in manifest
+      if (!manifest.dxt_version) {
+        throw new Error('Invalid manifest: missing dxt_version')
+      }
+      if (!manifest.name) {
+        throw new Error('Invalid manifest: missing name')
+      }
+      if (!manifest.version) {
+        throw new Error('Invalid manifest: missing version')
+      }
+      if (!manifest.server) {
+        throw new Error('Invalid manifest: missing server configuration')
+      }
+      if (!manifest.server.mcp_config) {
+        throw new Error('Invalid manifest: missing server.mcp_config')
+      }
+      if (!manifest.server.mcp_config.command) {
+        throw new Error('Invalid manifest: missing server.mcp_config.command')
+      }
+      if (!Array.isArray(manifest.server.mcp_config.args)) {
+        throw new Error('Invalid manifest: server.mcp_config.args must be an array')
+      }
+
+      // Use server name as the final extract directory for automatic version management
+      // Sanitize the name to prevent creating subdirectories
+      const sanitizedName = manifest.name.replace(/\//g, '-')
+      const serverDirName = `server-${sanitizedName}`
+      const finalExtractDir = path.join(this.mcpDir, serverDirName)
+
+      // Clean up any existing version of this server
+      if (fs.existsSync(finalExtractDir)) {
+        logger.info('[DxtService] Removing existing server directory:', finalExtractDir)
+        fs.rmSync(finalExtractDir, { recursive: true, force: true })
+      }
+
+      // Move the temporary directory to the final location
+      // Use recursive copy + remove instead of rename to handle cross-filesystem moves
+      await this.moveDirectory(tempExtractDir, finalExtractDir)
+      logger.info('[DxtService] DXT server extracted to:', finalExtractDir)
+
+      // Clean up the uploaded DXT file if it's in temp directory
+      if (filePath.startsWith(this.tempDir)) {
+        fs.unlinkSync(filePath)
+      }
+
+      // Return success with manifest and extraction path
+      return {
+        success: true,
+        data: {
+          manifest,
+          extractDir: finalExtractDir
+        }
+      }
+    } catch (error) {
+      // Clean up on error
+      if (fs.existsSync(tempExtractDir)) {
+        fs.rmSync(tempExtractDir, { recursive: true, force: true })
+      }
+
+      const errorMessage = error instanceof Error ? error.message : 'Failed to process DXT file'
+      logger.error('[DxtService] DXT upload error:', error)
+
+      return {
+        success: false,
+        error: errorMessage
+      }
+    }
+  }
+
+  /**
+   * Get resolved MCP configuration for a DXT server with platform overrides and variable substitution
+   */
+  public getResolvedMcpConfig(dxtPath: string, userConfig?: Record<string, any>): ResolvedMcpConfig | null {
+    try {
+      // Read the manifest from the DXT server directory
+      const manifestPath = path.join(dxtPath, 'manifest.json')
+      if (!fs.existsSync(manifestPath)) {
+        logger.error('[DxtService] Manifest not found:', manifestPath)
+        return null
+      }
+
+      const manifestContent = fs.readFileSync(manifestPath, 'utf-8')
+      const manifest: DxtManifest = JSON.parse(manifestContent)
+
+      if (!manifest.server?.mcp_config) {
+        logger.error('[DxtService] No mcp_config found in manifest')
+        return null
+      }
+
+      // Apply platform overrides and variable substitution
+      const resolvedConfig = applyPlatformOverrides(manifest.server.mcp_config, dxtPath, userConfig)
+
+      logger.info('[DxtService] Resolved MCP config:', {
+        command: resolvedConfig.command,
+        args: resolvedConfig.args,
+        env: resolvedConfig.env ? Object.keys(resolvedConfig.env) : undefined
+      })
+
+      return resolvedConfig
+    } catch (error) {
+      logger.error('[DxtService] Failed to resolve MCP config:', error)
+      return null
+    }
+  }
+
+  public cleanupDxtServer(serverName: string): boolean {
+    try {
+      // Handle server names that might contain slashes (e.g., "anthropic/sequential-thinking")
+      // by replacing slashes with the same separator used during installation
+      const sanitizedName = serverName.replace(/\//g, '-')
+      const serverDirName = `server-${sanitizedName}`
+      const serverDir = path.join(this.mcpDir, serverDirName)
+
+      // First try the sanitized path
+      if (fs.existsSync(serverDir)) {
+        logger.info('[DxtService] Removing DXT server directory:', serverDir)
+        fs.rmSync(serverDir, { recursive: true, force: true })
+        return true
+      }
+
+      // Fallback: try with original name in case it was stored differently
+      const originalServerDir = path.join(this.mcpDir, `server-${serverName}`)
+      if (fs.existsSync(originalServerDir)) {
+        logger.info('[DxtService] Removing DXT server directory:', originalServerDir)
+        fs.rmSync(originalServerDir, { recursive: true, force: true })
+        return true
+      }
+
+      logger.warn('[DxtService] Server directory not found:', serverDir)
+      return false
+    } catch (error) {
+      logger.error('[DxtService] Failed to cleanup DXT server:', error)
+      return false
+    }
+  }
+
+  public cleanup() {
+    try {
+      // Clean up temp directory
+      if (fs.existsSync(this.tempDir)) {
+        fs.rmSync(this.tempDir, { recursive: true, force: true })
+      }
+    } catch (error) {
+      logger.error('[DxtService] Cleanup error:', error)
+    }
+  }
+}
+
+export default DxtService

src/main/services/FileStorage.ts

@@ -1,4 +1,4 @@
-import { getFilesDir, getFileType, getTempDir } from '@main/utils/file'
+import { getFilesDir, getFileType, getTempDir, readTextFileWithAutoEncoding } from '@main/utils/file'
 import { documentExts, imageExts, MB } from '@shared/config/constant'
 import { FileMetadata } from '@types'
 import * as crypto from 'crypto'
@@ -188,6 +188,8 @@ class FileStorage {
       count: 1
     }
 
+    logger.info('[FileStorage] File uploaded:', fileMetadata)
+
     return fileMetadata
   }
 
@@ -229,7 +231,11 @@ class FileStorage {
     await fs.promises.rm(path.join(this.storageDir, id), { recursive: true })
   }
 
-  public readFile = async (_: Electron.IpcMainInvokeEvent, id: string): Promise<string> => {
+  public readFile = async (
+    _: Electron.IpcMainInvokeEvent,
+    id: string,
+    detectEncoding: boolean = false
+  ): Promise<string> => {
     const filePath = path.join(this.storageDir, id)
 
     const fileExtension = path.extname(filePath)
@@ -256,7 +262,16 @@ class FileStorage {
       }
     }
 
-    return fs.readFileSync(filePath, 'utf8')
+    try {
+      if (detectEncoding) {
+        return readTextFileWithAutoEncoding(filePath)
+      } else {
+        return fs.readFileSync(filePath, 'utf-8')
+      }
+    } catch (error) {
+      logger.error(error)
+      throw new Error(`Failed to read file: ${filePath}.`)
+    }
   }
 
   public createTempFile = async (_: Electron.IpcMainInvokeEvent, fileName: string): Promise<string> => {
@@ -409,6 +424,19 @@ class FileStorage {
     shell.openPath(path).catch((err) => logger.error('[IPC - Error] Failed to open file:', err))
   }
 
+  /**
+   * 通过相对路径打开文件，跨设备时使用
+   * @param file
+   */
+  public openFileWithRelativePath = async (_: Electron.IpcMainInvokeEvent, file: FileMetadata): Promise<void> => {
+    const filePath = path.join(this.storageDir, file.name)
+    if (fs.existsSync(filePath)) {
+      shell.openPath(filePath).catch((err) => logger.error('[IPC - Error] Failed to open file:', err))
+    } else {
+      logger.warn('[IPC - Warning] File does not exist:', filePath)
+    }
+  }
+
   public save = async (
     _: Electron.IpcMainInvokeEvent,
     fileName: string,

src/main/services/KnowledgeService.ts

@@ -21,12 +21,12 @@ import type { ExtractChunkData } from '@cherrystudio/embedjs-interfaces'
 import { LibSqlDb } from '@cherrystudio/embedjs-libsql'
 import { SitemapLoader } from '@cherrystudio/embedjs-loader-sitemap'
 import { WebLoader } from '@cherrystudio/embedjs-loader-web'
-import Embeddings from '@main/knowledage/embeddings/Embeddings'
-import { addFileLoader } from '@main/knowledage/loader'
-import { NoteLoader } from '@main/knowledage/loader/noteLoader'
-import Reranker from '@main/knowledage/reranker/Reranker'
-import OcrProvider from '@main/ocr/OcrProvider'
-import PreprocessProvider from '@main/preprocess/PreprocessProvider'
+import OcrProvider from '@main/knowledage/ocr/OcrProvider'
+import PreprocessProvider from '@main/knowledage/preprocess/PreprocessProvider'
+import Embeddings from '@main/knowledge/embeddings/Embeddings'
+import { addFileLoader } from '@main/knowledge/loader'
+import { NoteLoader } from '@main/knowledge/loader/noteLoader'
+import Reranker from '@main/knowledge/reranker/Reranker'
 import { windowService } from '@main/services/WindowService'
 import { getDataPath } from '@main/utils'
 import { getAllFiles } from '@main/utils/file'
@@ -120,27 +120,21 @@ class KnowledgeService {
 
   private getRagApplication = async ({
     id,
-    model,
-    provider,
-    apiKey,
-    apiVersion,
-    baseURL,
-    dimensions
+    embedApiClient,
+    dimensions,
+    documentCount
   }: KnowledgeBaseParams): Promise<RAGApplication> => {
     let ragApplication: RAGApplication
     const embeddings = new Embeddings({
-      model,
-      provider,
-      apiKey,
-      apiVersion,
-      baseURL,
+      embedApiClient,
       dimensions
-    } as KnowledgeBaseParams)
+    })
     try {
       ragApplication = await new RAGApplicationBuilder()
         .setModel('NO_MODEL')
         .setEmbeddingModel(embeddings)
         .setVectorDatabase(new LibSqlDb({ path: path.join(this.storageDir, id) }))
+        .setSearchResultCount(documentCount || 30)
         .build()
     } catch (e) {
       Logger.error(e)

src/main/services/MCPService.ts

@@ -14,6 +14,16 @@ import {
   type StreamableHTTPClientTransportOptions
 } from '@modelcontextprotocol/sdk/client/streamableHttp'
 import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory'
+// Import notification schemas from MCP SDK
+import {
+  CancelledNotificationSchema,
+  LoggingMessageNotificationSchema,
+  ProgressNotificationSchema,
+  PromptListChangedNotificationSchema,
+  ResourceListChangedNotificationSchema,
+  ResourceUpdatedNotificationSchema,
+  ToolListChangedNotificationSchema
+} from '@modelcontextprotocol/sdk/types.js'
 import { nanoid } from '@reduxjs/toolkit'
 import {
   GetMCPPromptResponse,
@@ -28,8 +38,10 @@ import { app } from 'electron'
 import Logger from 'electron-log'
 import { EventEmitter } from 'events'
 import { memoize } from 'lodash'
+import { v4 as uuidv4 } from 'uuid'
 
 import { CacheService } from './CacheService'
+import DxtService from './DxtService'
 import { CallBackServer } from './mcp/oauth/callback'
 import { McpOAuthClientProvider } from './mcp/oauth/provider'
 import getLoginShellEnvironment from './mcp/shell-env'
@@ -71,6 +83,8 @@ function withCache<T extends unknown[], R>(
 class McpService {
   private clients: Map<string, Client> = new Map()
   private pendingClients: Map<string, Promise<Client>> = new Map()
+  private dxtService = new DxtService()
+  private activeToolCalls: Map<string, AbortController> = new Map()
 
   constructor() {
     this.initClient = this.initClient.bind(this)
@@ -84,7 +98,10 @@ class McpService {
     this.removeServer = this.removeServer.bind(this)
     this.restartServer = this.restartServer.bind(this)
     this.stopServer = this.stopServer.bind(this)
+    this.abortTool = this.abortTool.bind(this)
     this.cleanup = this.cleanup.bind(this)
+    this.checkMcpConnectivity = this.checkMcpConnectivity.bind(this)
+    this.getServerVersion = this.getServerVersion.bind(this)
   }
 
   private getServerKey(server: MCPServer): string {
@@ -133,7 +150,7 @@ class McpService {
         // Create new client instance for each connection
         const client = new Client({ name: 'Cherry Studio', version: app.getVersion() }, { capabilities: {} })
 
-        const args = [...(server.args || [])]
+        let args = [...(server.args || [])]
 
         // let transport: StdioClientTransport | SSEClientTransport | InMemoryTransport | StreamableHTTPClientTransport
         const authProvider = new McpOAuthClientProvider({
@@ -203,6 +220,23 @@ class McpService {
           } else if (server.command) {
             let cmd = server.command
 
+            // For DXT servers, use resolved configuration with platform overrides and variable substitution
+            if (server.dxtPath) {
+              const resolvedConfig = this.dxtService.getResolvedMcpConfig(server.dxtPath)
+              if (resolvedConfig) {
+                cmd = resolvedConfig.command
+                args = resolvedConfig.args
+                // Merge resolved environment variables with existing ones
+                server.env = {
+                  ...server.env,
+                  ...resolvedConfig.env
+                }
+                Logger.info(`[MCP] Using resolved DXT config - command: ${cmd}, args: ${args?.join(' ')}`)
+              } else {
+                Logger.warn(`[MCP] Failed to resolve DXT config for ${server.name}, falling back to manifest values`)
+              }
+            }
+
             if (server.command === 'npx') {
               cmd = await getBinaryPath('bun')
               Logger.info(`[MCP] Using command: ${cmd}`)
@@ -249,7 +283,7 @@ class McpService {
               this.removeProxyEnv(loginShellEnv)
             }
 
-            const stdioTransport = new StdioClientTransport({
+            const transportOptions: any = {
               command: cmd,
               args,
               env: {
@@ -257,7 +291,15 @@ class McpService {
                 ...server.env
               },
               stderr: 'pipe'
-            })
+            }
+
+            // For DXT servers, set the working directory to the extracted path
+            if (server.dxtPath) {
+              transportOptions.cwd = server.dxtPath
+              Logger.info(`[MCP] Setting working directory for DXT server: ${server.dxtPath}`)
+            }
+
+            const stdioTransport = new StdioClientTransport(transportOptions)
             stdioTransport.stderr?.on('data', (data) =>
               Logger.info(`[MCP] Stdio stderr for server: ${server.name} `, data.toString())
             )
@@ -331,6 +373,12 @@ class McpService {
           // Store the new client in the cache
           this.clients.set(serverKey, client)
 
+          // Set up notification handlers
+          this.setupNotificationHandlers(client, server)
+
+          // Clear existing cache to ensure fresh data
+          this.clearServerCache(serverKey)
+
           Logger.info(`[MCP] Activated server: ${server.name}`)
           return client
         } catch (error: any) {
@@ -349,6 +397,79 @@ class McpService {
     return initPromise
   }
 
+  /**
+   * Set up notification handlers for MCP client
+   */
+  private setupNotificationHandlers(client: Client, server: MCPServer) {
+    const serverKey = this.getServerKey(server)
+
+    try {
+      // Set up tools list changed notification handler
+      client.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+        Logger.info(`[MCP] Tools list changed for server: ${server.name}`)
+        // Clear tools cache
+        CacheService.remove(`mcp:list_tool:${serverKey}`)
+      })
+
+      // Set up resources list changed notification handler
+      client.setNotificationHandler(ResourceListChangedNotificationSchema, async () => {
+        Logger.info(`[MCP] Resources list changed for server: ${server.name}`)
+        // Clear resources cache
+        CacheService.remove(`mcp:list_resources:${serverKey}`)
+      })
+
+      // Set up prompts list changed notification handler
+      client.setNotificationHandler(PromptListChangedNotificationSchema, async () => {
+        Logger.info(`[MCP] Prompts list changed for server: ${server.name}`)
+        // Clear prompts cache
+        CacheService.remove(`mcp:list_prompts:${serverKey}`)
+      })
+
+      // Set up resource updated notification handler
+      client.setNotificationHandler(ResourceUpdatedNotificationSchema, async () => {
+        Logger.info(`[MCP] Resource updated for server: ${server.name}`)
+        // Clear resource-specific caches
+        this.clearResourceCaches(serverKey)
+      })
+
+      // Set up progress notification handler
+      client.setNotificationHandler(ProgressNotificationSchema, async (notification) => {
+        Logger.info(`[MCP] Progress notification received for server: ${server.name}`, notification.params)
+      })
+
+      // Set up cancelled notification handler
+      client.setNotificationHandler(CancelledNotificationSchema, async (notification) => {
+        Logger.info(`[MCP] Operation cancelled for server: ${server.name}`, notification.params)
+      })
+
+      // Set up logging message notification handler
+      client.setNotificationHandler(LoggingMessageNotificationSchema, async (notification) => {
+        Logger.info(`[MCP] Message from server ${server.name}:`, notification.params)
+      })
+
+      Logger.info(`[MCP] Set up notification handlers for server: ${server.name}`)
+    } catch (error) {
+      Logger.error(`[MCP] Failed to set up notification handlers for server ${server.name}:`, error)
+    }
+  }
+
+  /**
+   * Clear resource-specific caches for a server
+   */
+  private clearResourceCaches(serverKey: string) {
+    CacheService.remove(`mcp:list_resources:${serverKey}`)
+  }
+
+  /**
+   * Clear all caches for a specific server
+   */
+  private clearServerCache(serverKey: string) {
+    CacheService.remove(`mcp:list_tool:${serverKey}`)
+    CacheService.remove(`mcp:list_prompts:${serverKey}`)
+    CacheService.remove(`mcp:list_resources:${serverKey}`)
+    Logger.info(`[MCP] Cleared all caches for server: ${serverKey}`)
+  }
+
   async closeClient(serverKey: string) {
     const client = this.clients.get(serverKey)
     if (client) {
@@ -356,8 +477,8 @@ class McpService {
       await client.close()
       Logger.info(`[MCP] Closed server: ${serverKey}`)
       this.clients.delete(serverKey)
-      CacheService.remove(`mcp:list_tool:${serverKey}`)
-      Logger.info(`[MCP] Cleared cache for server: ${serverKey}`)
+      // Clear all caches for this server
+      this.clearServerCache(serverKey)
     } else {
       Logger.warn(`[MCP] No client found for server: ${serverKey}`)
     }
@@ -375,12 +496,26 @@ class McpService {
     if (existingClient) {
       await this.closeClient(serverKey)
     }
+
+    // If this is a DXT server, cleanup its directory
+    if (server.dxtPath) {
+      try {
+        const cleaned = this.dxtService.cleanupDxtServer(server.name)
+        if (cleaned) {
+          Logger.info(`[MCP] Cleaned up DXT server directory for: ${server.name}`)
+        }
+      } catch (error) {
+        Logger.error(`[MCP] Failed to cleanup DXT server: ${server.name}`, error)
+      }
+    }
   }
 
   async restartServer(_: Electron.IpcMainInvokeEvent, server: MCPServer) {
     Logger.info(`[MCP] Restarting server: ${server.name}`)
     const serverKey = this.getServerKey(server)
     await this.closeClient(serverKey)
+    // Clear cache before restarting to ensure fresh data
+    this.clearServerCache(serverKey)
     await this.initClient(server)
   }
 
@@ -400,6 +535,12 @@ class McpService {
   public async checkMcpConnectivity(_: Electron.IpcMainInvokeEvent, server: MCPServer): Promise<boolean> {
     Logger.info(`[MCP] Checking connectivity for server: ${server.name}`)
     try {
+      Logger.info(`[MCP] About to call initClient for server: ${server.name}`, { hasInitClient: !!this.initClient })
+
+      if (!this.initClient) {
+        throw new Error('initClient method is not available')
+      }
+
       const client = await this.initClient(server)
       // Attempt to list tools as a way to check connectivity
       await client.listTools()
@@ -455,10 +596,14 @@ class McpService {
    */
   public async callTool(
     _: Electron.IpcMainInvokeEvent,
-    { server, name, args }: { server: MCPServer; name: string; args: any }
+    { server, name, args, callId }: { server: MCPServer; name: string; args: any; callId?: string }
   ): Promise<MCPCallToolResponse> {
+    const toolCallId = callId || uuidv4()
+    const abortController = new AbortController()
+    this.activeToolCalls.set(toolCallId, abortController)
+
     try {
-      Logger.info('[MCP] Calling:', server.name, name, args)
+      Logger.info('[MCP] Calling:', server.name, name, args, 'callId:', toolCallId)
       if (typeof args === 'string') {
         try {
           args = JSON.parse(args)
@@ -468,12 +613,19 @@ class McpService {
       }
       const client = await this.initClient(server)
       const result = await client.callTool({ name, arguments: args }, undefined, {
-        timeout: server.timeout ? server.timeout * 1000 : 60000 // Default timeout of 1 minute
+        onprogress: (process) => {
+          console.log('[MCP] Progress:', process.progress / (process.total || 1))
+          window.api.mcp.setProgress(process.progress / (process.total || 1))
+        },
+        timeout: server.timeout ? server.timeout * 1000 : 60000, // Default timeout of 1 minute
+        signal: this.activeToolCalls.get(toolCallId)?.signal
       })
       return result as MCPCallToolResponse
     } catch (error) {
       Logger.error(`[MCP] Error calling tool ${name} on ${server.name}:`, error)
       throw error
+    } finally {
+      this.activeToolCalls.delete(toolCallId)
     }
   }
 
@@ -664,6 +816,45 @@ class McpService {
     delete env.http_proxy
     delete env.https_proxy
   }
+
+  // 实现 abortTool 方法
+  public async abortTool(_: Electron.IpcMainInvokeEvent, callId: string) {
+    const activeToolCall = this.activeToolCalls.get(callId)
+    if (activeToolCall) {
+      activeToolCall.abort()
+      this.activeToolCalls.delete(callId)
+      Logger.info(`[MCP] Aborted tool call: ${callId}`)
+      return true
+    } else {
+      Logger.warn(`[MCP] No active tool call found for callId: ${callId}`)
+      return false
+    }
+  }
+
+  /**
+   * Get the server version information
+   */
+  public async getServerVersion(_: Electron.IpcMainInvokeEvent, server: MCPServer): Promise<string | null> {
+    try {
+      Logger.info(`[MCP] Getting server version for: ${server.name}`)
+      const client = await this.initClient(server)
+
+      // Try to get server information which may include version
+      const serverInfo = client.getServerVersion()
+      Logger.info(`[MCP] Server info for ${server.name}:`, serverInfo)
+
+      if (serverInfo && serverInfo.version) {
+        Logger.info(`[MCP] Server version for ${server.name}: ${serverInfo.version}`)
+        return serverInfo.version
+      }
+
+      Logger.warn(`[MCP] No version information available for server: ${server.name}`)
+      return null
+    } catch (error: any) {
+      Logger.error(`[MCP] Failed to get server version for ${server.name}:`, error?.message)
+      return null
+    }
+  }
 }
 
 export default new McpService()

src/main/services/NotificationService.ts

@@ -1,8 +1,6 @@
 import { BrowserWindow, Notification as ElectronNotification } from 'electron'
 import { Notification } from 'src/renderer/src/types/notification'
 
-import icon from '../../../build/icon.png?asset'
-
 class NotificationService {
   private window: BrowserWindow
 
@@ -15,8 +13,7 @@ class NotificationService {
     // 使用 Electron Notification API
     const electronNotification = new ElectronNotification({
       title: notification.title,
-      body: notification.message,
-      icon: icon
+      body: notification.message
     })
 
     electronNotification.on('click', () => {

src/main/services/ProxyManager.ts

@@ -1,38 +1,54 @@
-import { ProxyConfig as _ProxyConfig, session } from 'electron'
+import axios from 'axios'
+import { app, ProxyConfig, session } from 'electron'
+import Logger from 'electron-log'
+import { socksDispatcher } from 'fetch-socks'
+import http from 'http'
+import https from 'https'
 import { getSystemProxy } from 'os-proxy-config'
-import { ProxyAgent as GeneralProxyAgent } from 'proxy-agent'
-// import { ProxyAgent, setGlobalDispatcher } from 'undici'
-
-type ProxyMode = 'system' | 'custom' | 'none'
-
-export interface ProxyConfig {
-  mode: ProxyMode
-  url?: string
-}
+import { ProxyAgent } from 'proxy-agent'
+import { Dispatcher, EnvHttpProxyAgent, getGlobalDispatcher, setGlobalDispatcher } from 'undici'
 
 export class ProxyManager {
-  private config: ProxyConfig
-  private proxyAgent: GeneralProxyAgent | null = null
+  private config: ProxyConfig = { mode: 'direct' }
   private systemProxyInterval: NodeJS.Timeout | null = null
+  private isSettingProxy = false
+
+  private originalGlobalDispatcher: Dispatcher
+  private originalSocksDispatcher: Dispatcher
+  // for http and https
+  private originalHttpGet: typeof http.get
+  private originalHttpRequest: typeof http.request
+  private originalHttpsGet: typeof https.get
+  private originalHttpsRequest: typeof https.request
 
   constructor() {
-    this.config = {
-      mode: 'none'
-    }
-  }
-
-  private async setSessionsProxy(config: _ProxyConfig): Promise<void> {
-    const sessions = [session.defaultSession, session.fromPartition('persist:webview')]
-    await Promise.all(sessions.map((session) => session.setProxy(config)))
+    this.originalGlobalDispatcher = getGlobalDispatcher()
+    this.originalSocksDispatcher = global[Symbol.for('undici.globalDispatcher.1')]
+    this.originalHttpGet = http.get
+    this.originalHttpRequest = http.request
+    this.originalHttpsGet = https.get
+    this.originalHttpsRequest = https.request
   }
 
   private async monitorSystemProxy(): Promise<void> {
     // Clear any existing interval first
     this.clearSystemProxyMonitor()
     // Set new interval
-    this.systemProxyInterval = setInterval(async () => {
-      await this.setSystemProxy()
-    }, 10000)
+    this.systemProxyInterval = setInterval(
+      async () => {
+        const currentProxy = await getSystemProxy()
+        if (currentProxy && currentProxy.proxyUrl.toLowerCase() === this.config.proxyRules) {
+          return
+        }
+
+        await this.configureProxy({
+          mode: 'system',
+          proxyRules: currentProxy?.proxyUrl.toLowerCase()
+        })
+      },
+      // 1 minutes
+      1000 * 60
+    )
   }
 
   private clearSystemProxyMonitor(): void {
@@ -43,99 +59,182 @@ export class ProxyManager {
   }
 
   async configureProxy(config: ProxyConfig): Promise<void> {
+    Logger.info('configureProxy', config.mode, config.proxyRules)
+    if (this.isSettingProxy) {
+      return
+    }
+
+    this.isSettingProxy = true
+
     try {
+      if (config?.mode === this.config?.mode && config?.proxyRules === this.config?.proxyRules) {
+        Logger.info('proxy config is the same, skip configure')
+        return
+      }
+
       this.config = config
       this.clearSystemProxyMonitor()
-      if (this.config.mode === 'system') {
-        await this.setSystemProxy()
-        this.monitorSystemProxy()
-      } else if (this.config.mode === 'custom') {
-        await this.setCustomProxy()
-      } else {
-        await this.clearProxy()
+      if (config.mode === 'system') {
+        const currentProxy = await getSystemProxy()
+        if (currentProxy) {
+          Logger.info('current system proxy', currentProxy.proxyUrl)
+          this.config.proxyRules = currentProxy.proxyUrl.toLowerCase()
+          this.monitorSystemProxy()
+        } else {
+          // no system proxy, use direct mode
+          this.config.mode = 'direct'
+        }
       }
+
+      this.setGlobalProxy()
     } catch (error) {
-      console.error('Failed to config proxy:', error)
+      Logger.error('Failed to config proxy:', error)
       throw error
+    } finally {
+      this.isSettingProxy = false
     }
   }
 
   private setEnvironment(url: string): void {
+    if (url === '') {
+      delete process.env.HTTP_PROXY
+      delete process.env.HTTPS_PROXY
+      delete process.env.grpc_proxy
+      delete process.env.http_proxy
+      delete process.env.https_proxy
+
+      delete process.env.SOCKS_PROXY
+      delete process.env.ALL_PROXY
+      return
+    }
+
     process.env.grpc_proxy = url
     process.env.HTTP_PROXY = url
     process.env.HTTPS_PROXY = url
     process.env.http_proxy = url
     process.env.https_proxy = url
-  }
 
-  private async setSystemProxy(): Promise<void> {
-    try {
-      const currentProxy = await getSystemProxy()
-      if (!currentProxy || currentProxy.proxyUrl === this.config.url) {
-        return
-      }
-      await this.setSessionsProxy({ mode: 'system' })
-      this.config.url = currentProxy.proxyUrl.toLowerCase()
-      this.setEnvironment(this.config.url)
-      this.proxyAgent = new GeneralProxyAgent()
-    } catch (error) {
-      console.error('Failed to set system proxy:', error)
-      throw error
+    if (url.startsWith('socks')) {
+      process.env.SOCKS_PROXY = url
+      process.env.ALL_PROXY = url
     }
   }
 
-  private async setCustomProxy(): Promise<void> {
-    try {
-      if (this.config.url) {
-        this.setEnvironment(this.config.url)
-        this.proxyAgent = new GeneralProxyAgent()
-        await this.setSessionsProxy({ proxyRules: this.config.url })
+  private setGlobalProxy() {
+    this.setEnvironment(this.config.proxyRules || '')
+    this.setGlobalFetchProxy(this.config)
+    this.setSessionsProxy(this.config)
+
+    this.setGlobalHttpProxy(this.config)
+  }
+
+  private setGlobalHttpProxy(config: ProxyConfig) {
+    const proxyUrl = config.proxyRules
+    if (config.mode === 'direct' || !proxyUrl) {
+      http.get = this.originalHttpGet
+      http.request = this.originalHttpRequest
+      https.get = this.originalHttpsGet
+      https.request = this.originalHttpsRequest
+
+      axios.defaults.proxy = undefined
+      axios.defaults.httpAgent = undefined
+      axios.defaults.httpsAgent = undefined
+      return
+    }
+
+    // ProxyAgent 从环境变量读取代理配置
+    const agent = new ProxyAgent()
+
+    // axios 使用代理
+    axios.defaults.proxy = false
+    axios.defaults.httpAgent = agent
+    axios.defaults.httpsAgent = agent
+
+    http.get = this.bindHttpMethod(this.originalHttpGet, agent)
+    http.request = this.bindHttpMethod(this.originalHttpRequest, agent)
+
+    https.get = this.bindHttpMethod(this.originalHttpsGet, agent)
+    https.request = this.bindHttpMethod(this.originalHttpsRequest, agent)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  private bindHttpMethod(originalMethod: Function, agent: http.Agent | https.Agent) {
+    return (...args: any[]) => {
+      let url: string | URL | undefined
+      let options: http.RequestOptions | https.RequestOptions
+      let callback: (res: http.IncomingMessage) => void
+
+      if (typeof args[0] === 'string' || args[0] instanceof URL) {
+        url = args[0]
+        if (typeof args[1] === 'function') {
+          options = {}
+          callback = args[1]
+        } else {
+          options = {
+            ...args[1]
+          }
+          callback = args[2]
+        }
+      } else {
+        options = {
+          ...args[0]
+        }
+        callback = args[1]
       }
-    } catch (error) {
-      console.error('Failed to set custom proxy:', error)
-      throw error
+
+      // for webdav https self-signed certificate
+      if (options.agent instanceof https.Agent) {
+        ;(agent as https.Agent).options.rejectUnauthorized = options.agent.options.rejectUnauthorized
+      }
+
+      // 确保只设置 agent，不修改其他网络选项
+      if (!options.agent) {
+        options.agent = agent
+      }
+
+      if (url) {
+        return originalMethod(url, options, callback)
+      }
+      return originalMethod(options, callback)
     }
   }
 
-  private clearEnvironment(): void {
-    delete process.env.HTTP_PROXY
-    delete process.env.HTTPS_PROXY
-    delete process.env.grpc_proxy
-    delete process.env.http_proxy
-    delete process.env.https_proxy
+  private setGlobalFetchProxy(config: ProxyConfig) {
+    const proxyUrl = config.proxyRules
+    if (config.mode === 'direct' || !proxyUrl) {
+      setGlobalDispatcher(this.originalGlobalDispatcher)
+      global[Symbol.for('undici.globalDispatcher.1')] = this.originalSocksDispatcher
+      return
+    }
+
+    const url = new URL(proxyUrl)
+    if (url.protocol === 'http:' || url.protocol === 'https:') {
+      setGlobalDispatcher(new EnvHttpProxyAgent())
+      return
+    }
+
+    global[Symbol.for('undici.globalDispatcher.1')] = socksDispatcher({
+      port: parseInt(url.port),
+      type: url.protocol === 'socks4:' ? 4 : 5,
+      host: url.hostname,
+      userId: url.username || undefined,
+      password: url.password || undefined
+    })
   }
 
-  private async clearProxy(): Promise<void> {
-    this.clearEnvironment()
-    await this.setSessionsProxy({ mode: 'direct' })
-    this.config = { mode: 'none' }
-    this.proxyAgent = null
-  }
+  private async setSessionsProxy(config: ProxyConfig): Promise<void> {
+    let c = config
 
-  getProxyAgent(): GeneralProxyAgent | null {
-    return this.proxyAgent
-  }
+    if (config.mode === 'direct' || !config.proxyRules) {
+      c = { mode: 'direct' }
+    }
 
-  getProxyUrl(): string {
-    return this.config.url || ''
-  }
+    const sessions = [session.defaultSession, session.fromPartition('persist:webview')]
+    await Promise.all(sessions.map((session) => session.setProxy(c)))
 
-  // setGlobalProxy() {
-  //   const proxyUrl = this.config.url
-  //   if (proxyUrl) {
-  //     const [protocol, address] = proxyUrl.split('://')
-  //     const [host, port] = address.split(':')
-  //     if (!protocol.includes('socks')) {
-  //       setGlobalDispatcher(new ProxyAgent(proxyUrl))
-  //     } else {
-  //       global[Symbol.for('undici.globalDispatcher.1')] = socksDispatcher({
-  //         port: parseInt(port),
-  //         type: protocol === 'socks5' ? 5 : 4,
-  //         host: host
-  //       })
-  //     }
-  //   }
-  // }
+    // set proxy for electron
+    app.setProxy(c)
+  }
 }
 
 export const proxyManager = new ProxyManager()

src/main/services/RemoteStorage.ts

@@ -1,57 +0,0 @@
-// import Logger from 'electron-log'
-// import { Operator } from 'opendal'
-
-// export default class RemoteStorage {
-//   public instance: Operator | undefined
-
-//   /**
-//    *
-//    * @param scheme is the scheme for opendal services. Available value includes "azblob", "azdls", "cos", "gcs", "obs", "oss", "s3", "webdav", "webhdfs", "aliyun-drive", "alluxio", "azfile", "dropbox", "gdrive", "onedrive", "postgresql", "mysql", "redis", "swift", "mongodb", "alluxio", "b2", "seafile", "upyun", "koofr", "yandex-disk"
-//    * @param options is the options for given opendal services. Valid options depend on the scheme. Checkout https://docs.rs/opendal/latest/opendal/services/index.html for all valid options.
-//    *
-//    * For example, use minio as remote storage:
-//    *
-//    * ```typescript
-//    * const storage = new RemoteStorage('s3', {
-//    *   endpoint: 'http://localhost:9000',
-//    *   region: 'us-east-1',
-//    *   bucket: 'testbucket',
-//    *   access_key_id: 'user',
-//    *   secret_access_key: 'password',
-//    *   root: '/path/to/basepath',
-//    * })
-//    * ```
-//    */
-//   constructor(scheme: string, options?: Record<string, string> | undefined | null) {
-//     this.instance = new Operator(scheme, options)
-
-//     this.putFileContents = this.putFileContents.bind(this)
-//     this.getFileContents = this.getFileContents.bind(this)
-//   }
-
-//   public putFileContents = async (filename: string, data: string | Buffer) => {
-//     if (!this.instance) {
-//       return new Error('RemoteStorage client not initialized')
-//     }
-
-//     try {
-//       return await this.instance.write(filename, data)
-//     } catch (error) {
-//       Logger.error('[RemoteStorage] Error putting file contents:', error)
-//       throw error
-//     }
-//   }
-
-//   public getFileContents = async (filename: string) => {
-//     if (!this.instance) {
-//       throw new Error('RemoteStorage client not initialized')
-//     }
-
-//     try {
-//       return await this.instance.read(filename)
-//     } catch (error) {
-//       Logger.error('[RemoteStorage] Error getting file contents:', error)
-//       throw error
-//     }
-//   }
-// }

src/main/services/S3Storage.ts

@@ -0,0 +1,183 @@
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  HeadBucketCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3Client
+} from '@aws-sdk/client-s3'
+import type { S3Config } from '@types'
+import Logger from 'electron-log'
+import * as net from 'net'
+import { Readable } from 'stream'
+
+/**
+ * 将可读流转换为 Buffer
+ */
+function streamToBuffer(stream: Readable): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    stream.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))
+    stream.on('error', reject)
+    stream.on('end', () => resolve(Buffer.concat(chunks)))
+  })
+}
+
+// 需要使用 Virtual Host-Style 的服务商域名后缀白名单
+const VIRTUAL_HOST_SUFFIXES = ['aliyuncs.com', 'myqcloud.com']
+
+/**
+ * 使用 AWS SDK v3 的简单 S3 封装，兼容之前 RemoteStorage 的最常用接口。
+ */
+export default class S3Storage {
+  private client: S3Client
+  private bucket: string
+  private root: string
+
+  constructor(config: S3Config) {
+    const { endpoint, region, accessKeyId, secretAccessKey, bucket, root } = config
+
+    const usePathStyle = (() => {
+      if (!endpoint) return false
+
+      try {
+        const { hostname } = new URL(endpoint)
+
+        if (hostname === 'localhost' || net.isIP(hostname) !== 0) {
+          return true
+        }
+
+        const isInWhiteList = VIRTUAL_HOST_SUFFIXES.some((suffix) => hostname.endsWith(suffix))
+        return !isInWhiteList
+      } catch (e) {
+        Logger.warn('[S3Storage] Failed to parse endpoint, fallback to Path-Style:', endpoint, e)
+        return true
+      }
+    })()
+
+    this.client = new S3Client({
+      region,
+      endpoint: endpoint || undefined,
+      credentials: {
+        accessKeyId: accessKeyId,
+        secretAccessKey: secretAccessKey
+      },
+      forcePathStyle: usePathStyle
+    })
+
+    this.bucket = bucket
+    this.root = root?.replace(/^\/+/g, '').replace(/\/+$/g, '') || ''
+
+    this.putFileContents = this.putFileContents.bind(this)
+    this.getFileContents = this.getFileContents.bind(this)
+    this.deleteFile = this.deleteFile.bind(this)
+    this.listFiles = this.listFiles.bind(this)
+    this.checkConnection = this.checkConnection.bind(this)
+  }
+
+  /**
+   * 内部辅助方法，用来拼接带 root 的对象 key
+   */
+  private buildKey(key: string): string {
+    if (!this.root) return key
+    return key.startsWith(`${this.root}/`) ? key : `${this.root}/${key}`
+  }
+
+  async putFileContents(key: string, data: Buffer | string) {
+    try {
+      const contentType = key.endsWith('.zip') ? 'application/zip' : 'application/octet-stream'
+
+      return await this.client.send(
+        new PutObjectCommand({
+          Bucket: this.bucket,
+          Key: this.buildKey(key),
+          Body: data,
+          ContentType: contentType
+        })
+      )
+    } catch (error) {
+      Logger.error('[S3Storage] Error putting object:', error)
+      throw error
+    }
+  }
+
+  async getFileContents(key: string): Promise<Buffer> {
+    try {
+      const res = await this.client.send(new GetObjectCommand({ Bucket: this.bucket, Key: this.buildKey(key) }))
+      if (!res.Body || !(res.Body instanceof Readable)) {
+        throw new Error('Empty body received from S3')
+      }
+      return await streamToBuffer(res.Body as Readable)
+    } catch (error) {
+      Logger.error('[S3Storage] Error getting object:', error)
+      throw error
+    }
+  }
+
+  async deleteFile(key: string) {
+    try {
+      const keyWithRoot = this.buildKey(key)
+      const variations = new Set([keyWithRoot, key.replace(/^\//, '')])
+      for (const k of variations) {
+        try {
+          await this.client.send(new DeleteObjectCommand({ Bucket: this.bucket, Key: k }))
+        } catch {
+          // 忽略删除失败
+        }
+      }
+    } catch (error) {
+      Logger.error('[S3Storage] Error deleting object:', error)
+      throw error
+    }
+  }
+
+  /**
+   * 列举指定前缀下的对象，默认列举全部。
+   */
+  async listFiles(prefix = ''): Promise<Array<{ key: string; lastModified?: string; size: number }>> {
+    const files: Array<{ key: string; lastModified?: string; size: number }> = []
+    let continuationToken: string | undefined
+    const fullPrefix = this.buildKey(prefix)
+
+    try {
+      do {
+        const res = await this.client.send(
+          new ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: fullPrefix === '' ? undefined : fullPrefix,
+            ContinuationToken: continuationToken
+          })
+        )
+
+        res.Contents?.forEach((obj) => {
+          if (!obj.Key) return
+          files.push({
+            key: obj.Key,
+            lastModified: obj.LastModified?.toISOString(),
+            size: obj.Size ?? 0
+          })
+        })
+
+        continuationToken = res.IsTruncated ? res.NextContinuationToken : undefined
+      } while (continuationToken)
+
+      return files
+    } catch (error) {
+      Logger.error('[S3Storage] Error listing objects:', error)
+      throw error
+    }
+  }
+
+  /**
+   * 尝试调用 HeadBucket 判断凭证/网络是否可用
+   */
+  async checkConnection() {
+    try {
+      await this.client.send(new HeadBucketCommand({ Bucket: this.bucket }))
+      return true
+    } catch (error) {
+      Logger.error('[S3Storage] Error checking connection:', error)
+      throw error
+    }
+  }
+}

src/main/services/SelectionService.ts

@@ -1,7 +1,7 @@
 import { SELECTION_FINETUNED_LIST, SELECTION_PREDEFINED_BLACKLIST } from '@main/configs/SelectionConfig'
 import { isDev, isMac, isWin } from '@main/constant'
 import { IpcChannel } from '@shared/IpcChannel'
-import { BrowserWindow, ipcMain, screen, systemPreferences } from 'electron'
+import { app, BrowserWindow, ipcMain, screen, systemPreferences } from 'electron'
 import Logger from 'electron-log'
 import { join } from 'path'
 import type {
@@ -141,7 +141,7 @@ export class SelectionService {
    * Initialize zoom factor from config and subscribe to changes
    * Ensures UI elements scale properly with system DPI settings
    */
-  private initZoomFactor() {
+  private initZoomFactor(): void {
     const zoomFactor = configManager.getZoomFactor()
     if (zoomFactor) {
       this.setZoomFactor(zoomFactor)
@@ -154,7 +154,7 @@ export class SelectionService {
     this.zoomFactor = zoomFactor
   }
 
-  private initConfig() {
+  private initConfig(): void {
     this.triggerMode = configManager.getSelectionAssistantTriggerMode() as TriggerMode
     this.isFollowToolbar = configManager.getSelectionAssistantFollowToolbar()
     this.isRemeberWinSize = configManager.getSelectionAssistantRemeberWinSize()
@@ -207,7 +207,7 @@ export class SelectionService {
    * @param mode - The mode to set, either 'default', 'whitelist', or 'blacklist'
    * @param list - An array of strings representing the list of items to include or exclude
    */
-  private setHookGlobalFilterMode(mode: string, list: string[]) {
+  private setHookGlobalFilterMode(mode: string, list: string[]): void {
     if (!this.selectionHook) return
 
     const modeMap = {
@@ -245,7 +245,7 @@ export class SelectionService {
     }
   }
 
-  private setHookFineTunedList() {
+  private setHookFineTunedList(): void {
     if (!this.selectionHook) return
 
     const excludeClipboardCursorDetectList = isWin
@@ -271,6 +271,11 @@ export class SelectionService {
    * @returns {boolean} Success status of service start
    */
   public start(): boolean {
+    if (!isSupportedOS) {
+      this.logError(new Error('SelectionService start(): not supported on this OS'))
+      return false
+    }
+
     if (!this.selectionHook) {
       this.logError(new Error('SelectionService start(): instance is null'))
       return false
@@ -373,7 +378,7 @@ export class SelectionService {
    * Toggle the enabled state of the selection service
    * Will sync the new enabled store to all renderer windows
    */
-  public toggleEnabled(enabled: boolean | undefined = undefined) {
+  public toggleEnabled(enabled: boolean | undefined = undefined): void {
     if (!this.selectionHook) return
 
     const newEnabled = enabled === undefined ? !configManager.getSelectionAssistantEnabled() : enabled
@@ -389,7 +394,7 @@ export class SelectionService {
    * Sets up window properties, event handlers, and loads the toolbar UI
    * @param readyCallback Optional callback when window is ready to show
    */
-  private createToolbarWindow(readyCallback?: () => void) {
+  private createToolbarWindow(readyCallback?: () => void): void {
     if (this.isToolbarAlive()) return
 
     const { toolbarWidth, toolbarHeight } = this.getToolbarRealSize()
@@ -414,9 +419,11 @@ export class SelectionService {
       backgroundMaterial: 'none',
 
       // Platform specific settings
-      //   [macOS] DO NOT set type to 'panel', it will not work because it conflicts with other settings
       //   [macOS] DO NOT set focusable to false, it will make other windows bring to front together
-      ...(isWin ? { type: 'toolbar', focusable: false } : {}),
+      //   [macOS] `panel` conflicts with other settings ,
+      //           and log will show `NSWindow does not support nonactivating panel styleMask 0x80`
+      //           but it seems still work on fullscreen apps, so we set this anyway
+      ...(isWin ? { type: 'toolbar', focusable: false } : { type: 'panel' }),
       hiddenInMissionControl: true, // [macOS only]
       acceptFirstMouse: true, // [macOS only]
 
@@ -447,13 +454,6 @@ export class SelectionService {
     // Add show/hide event listeners
     this.toolbarWindow.on('show', () => {
       this.toolbarWindow?.webContents.send(IpcChannel.Selection_ToolbarVisibilityChange, true)
-
-      // [macOS] force the toolbar window to be visible on current desktop
-      // but it will make docker icon flash. And we found that it's not necessary now.
-      // will remove after testing
-      // if (isMac) {
-      //   this.toolbarWindow!.setVisibleOnAllWorkspaces(false)
-      // }
     })
 
     this.toolbarWindow.on('hide', () => {
@@ -485,10 +485,10 @@ export class SelectionService {
    * @param point Reference point for positioning, logical coordinates
    * @param orientation Preferred position relative to reference point
    */
-  private showToolbarAtPosition(point: Point, orientation: RelativeOrientation) {
+  private showToolbarAtPosition(point: Point, orientation: RelativeOrientation, programName: string): void {
     if (!this.isToolbarAlive()) {
       this.createToolbarWindow(() => {
-        this.showToolbarAtPosition(point, orientation)
+        this.showToolbarAtPosition(point, orientation, programName)
       })
       return
     }
@@ -509,25 +509,55 @@ export class SelectionService {
     //should set every time the window is shown
     this.toolbarWindow!.setAlwaysOnTop(true, 'screen-saver')
 
-    // [macOS] force the toolbar window to be visible on current desktop
-    // but it will make docker icon flash. And we found that it's not necessary now.
-    // will remove after testing
-    // if (isMac) {
-    //   this.toolbarWindow!.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true })
-    // }
+    if (!isMac) {
+      this.toolbarWindow!.show()
+      /**
+       * [Windows]
+       *   In Windows 10, setOpacity(1) will make the window completely transparent
+       *   It's a strange behavior, so we don't use it for compatibility
+       */
+      // this.toolbarWindow!.setOpacity(1)
+      this.startHideByMouseKeyListener()
+      return
+    }
+
+    /************************************************
+     * [macOS] the following code is only for macOS
+     *
+     * WARNING:
+     *   DO NOT MODIFY THESE CODES, UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!!!!
+     *************************************************/
+
+    // [macOS] a hacky way
+    // when set `skipTransformProcessType: true`, if the selection is in self app, it will make the selection canceled after toolbar showing
+    // so we just don't set `skipTransformProcessType: true` when in self app
+    const isSelf = ['com.github.Electron', 'com.kangfenmao.CherryStudio'].includes(programName)
+
+    if (!isSelf) {
+      // [macOS] an ugly hacky way
+      // `focusable: true` will make mainWindow disappeared when `setVisibleOnAllWorkspaces`
+      // so we set `focusable: true` before showing, and then set false after showing
+      this.toolbarWindow!.setFocusable(false)
+
+      // [macOS]
+      // force `setVisibleOnAllWorkspaces: true` to let toolbar show in all workspaces. And we MUST not set it to false again
+      // set `skipTransformProcessType: true` to avoid dock icon spinning when `setVisibleOnAllWorkspaces`
+      this.toolbarWindow!.setVisibleOnAllWorkspaces(true, {
+        visibleOnFullScreen: true,
+        skipTransformProcessType: true
+      })
+    }
 
     // [macOS] MUST use `showInactive()` to prevent other windows bring to front together
     // [Windows] is OK for both `show()` and `showInactive()` because of `focusable: false`
     this.toolbarWindow!.showInactive()
 
-    /**
-     * [Windows]
-     *   In Windows 10, setOpacity(1) will make the window completely transparent
-     *   It's a strange behavior, so we don't use it for compatibility
-     */
-    // this.toolbarWindow!.setOpacity(1)
+    // [macOS] restore the focusable status
+    this.toolbarWindow!.setFocusable(true)
 
     this.startHideByMouseKeyListener()
+
+    return
   }
 
   /**
@@ -588,8 +618,8 @@ export class SelectionService {
    * Check if toolbar window exists and is not destroyed
    * @returns {boolean} Toolbar window status
    */
-  private isToolbarAlive() {
-    return this.toolbarWindow && !this.toolbarWindow.isDestroyed()
+  private isToolbarAlive(): boolean {
+    return !!(this.toolbarWindow && !this.toolbarWindow.isDestroyed())
   }
 
   /**
@@ -598,7 +628,7 @@ export class SelectionService {
    * @param width New toolbar width
    * @param height New toolbar height
    */
-  public determineToolbarSize(width: number, height: number) {
+  public determineToolbarSize(width: number, height: number): void {
     const toolbarWidth = Math.ceil(width)
 
     // only update toolbar width if it's changed
@@ -611,7 +641,7 @@ export class SelectionService {
    * Get actual toolbar dimensions accounting for zoom factor
    * @returns Object containing toolbar width and height
    */
-  private getToolbarRealSize() {
+  private getToolbarRealSize(): { toolbarWidth: number; toolbarHeight: number } {
     return {
       toolbarWidth: this.TOOLBAR_WIDTH * this.zoomFactor,
       toolbarHeight: this.TOOLBAR_HEIGHT * this.zoomFactor
@@ -882,8 +912,9 @@ export class SelectionService {
       refPoint = { x: Math.round(refPoint.x), y: Math.round(refPoint.y) }
     }
 
-    this.showToolbarAtPosition(refPoint, refOrientation)
-    this.toolbarWindow?.webContents.send(IpcChannel.Selection_TextSelected, selectionData)
+    // [macOS] isFullscreen is only available on macOS
+    this.showToolbarAtPosition(refPoint, refOrientation, selectionData.programName)
+    this.toolbarWindow!.webContents.send(IpcChannel.Selection_TextSelected, selectionData)
   }
 
   /**
@@ -891,7 +922,7 @@ export class SelectionService {
    */
 
   // Start monitoring global mouse clicks
-  private startHideByMouseKeyListener() {
+  private startHideByMouseKeyListener(): void {
     try {
       // Register event handlers
       this.selectionHook!.on('mouse-down', this.handleMouseDownHide)
@@ -904,7 +935,7 @@ export class SelectionService {
   }
 
   // Stop monitoring global mouse clicks
-  private stopHideByMouseKeyListener() {
+  private stopHideByMouseKeyListener(): void {
     if (!this.isHideByMouseKeyListenerActive) return
 
     try {
@@ -1098,7 +1129,7 @@ export class SelectionService {
    * Initialize preloaded action windows
    * Creates a pool of windows at startup for faster response
    */
-  private async initPreloadedActionWindows() {
+  private async initPreloadedActionWindows(): Promise<void> {
     try {
       // Create initial pool of preloaded windows
       for (let i = 0; i < this.PRELOAD_ACTION_WINDOW_COUNT; i++) {
@@ -1112,7 +1143,7 @@ export class SelectionService {
   /**
    * Close all preloaded action windows
    */
-  private closePreloadedActionWindows() {
+  private closePreloadedActionWindows(): void {
     for (const actionWindow of this.preloadedActionWindows) {
       if (!actionWindow.isDestroyed()) {
         actionWindow.destroy()
@@ -1124,7 +1155,7 @@ export class SelectionService {
    * Preload a new action window asynchronously
    * This method is called after popping a window to ensure we always have windows ready
    */
-  private async pushNewActionWindow() {
+  private async pushNewActionWindow(): Promise<void> {
     try {
       const actionWindow = this.createPreloadedActionWindow()
       this.preloadedActionWindows.push(actionWindow)
@@ -1138,7 +1169,7 @@ export class SelectionService {
    * Immediately returns a window and asynchronously creates a new one
    * @returns {BrowserWindow} The action window
    */
-  private popActionWindow() {
+  private popActionWindow(): BrowserWindow {
     // Get a window from the preloaded queue or create a new one if empty
     const actionWindow = this.preloadedActionWindows.pop() || this.createPreloadedActionWindow()
 
@@ -1189,20 +1220,26 @@ export class SelectionService {
     return actionWindow
   }
 
-  public processAction(actionItem: ActionItem): void {
+  /**
+   * Process action item
+   * @param actionItem Action item to process
+   * @param isFullScreen [macOS] only macOS has the available isFullscreen mode
+   */
+  public processAction(actionItem: ActionItem, isFullScreen: boolean = false): void {
     const actionWindow = this.popActionWindow()
 
     actionWindow.webContents.send(IpcChannel.Selection_UpdateActionData, actionItem)
 
-    this.showActionWindow(actionWindow)
+    this.showActionWindow(actionWindow, isFullScreen)
   }
 
   /**
    * Show action window with proper positioning relative to toolbar
    * Ensures window stays within screen boundaries
    * @param actionWindow Window to position and show
+   * @param isFullScreen [macOS] only macOS has the available isFullscreen mode
    */
-  private showActionWindow(actionWindow: BrowserWindow) {
+  private showActionWindow(actionWindow: BrowserWindow, isFullScreen: boolean = false): void {
     let actionWindowWidth = this.ACTION_WINDOW_WIDTH
     let actionWindowHeight = this.ACTION_WINDOW_HEIGHT
 
@@ -1212,67 +1249,125 @@ export class SelectionService {
       actionWindowHeight = this.lastActionWindowSize.height
     }
 
-    //center way
+    /********************************************
+     * Setting the position of the action window
+     ********************************************/
+    const display = screen.getDisplayNearestPoint(screen.getCursorScreenPoint())
+    const workArea = display.workArea
+
+    // Center of the screen
     if (!this.isFollowToolbar || !this.toolbarWindow) {
-      const display = screen.getDisplayNearestPoint(screen.getCursorScreenPoint())
-      const workArea = display.workArea
-
-      const centerX = workArea.x + (workArea.width - actionWindowWidth) / 2
-      const centerY = workArea.y + (workArea.height - actionWindowHeight) / 2
+      const centerX = Math.round(workArea.x + (workArea.width - actionWindowWidth) / 2)
+      const centerY = Math.round(workArea.y + (workArea.height - actionWindowHeight) / 2)
 
+      actionWindow.setPosition(centerX, centerY, false)
       actionWindow.setBounds({
         width: actionWindowWidth,
         height: actionWindowHeight,
-        x: Math.round(centerX),
-        y: Math.round(centerY)
+        x: centerX,
+        y: centerY
       })
+    } else {
+      // Follow toolbar position
+      const toolbarBounds = this.toolbarWindow!.getBounds()
+      const GAP = 6 // 6px gap from screen edges
 
+      //make sure action window is inside screen
+      if (actionWindowWidth > workArea.width - 2 * GAP) {
+        actionWindowWidth = workArea.width - 2 * GAP
+      }
+
+      if (actionWindowHeight > workArea.height - 2 * GAP) {
+        actionWindowHeight = workArea.height - 2 * GAP
+      }
+
+      // Calculate initial position to center action window horizontally below toolbar
+      let posX = Math.round(toolbarBounds.x + (toolbarBounds.width - actionWindowWidth) / 2)
+      let posY = Math.round(toolbarBounds.y)
+
+      // Ensure action window stays within screen boundaries with a small gap
+      if (posX + actionWindowWidth > workArea.x + workArea.width) {
+        posX = workArea.x + workArea.width - actionWindowWidth - GAP
+      } else if (posX < workArea.x) {
+        posX = workArea.x + GAP
+      }
+      if (posY + actionWindowHeight > workArea.y + workArea.height) {
+        // If window would go below screen, try to position it above toolbar
+        posY = workArea.y + workArea.height - actionWindowHeight - GAP
+      } else if (posY < workArea.y) {
+        posY = workArea.y + GAP
+      }
+
+      actionWindow.setPosition(posX, posY, false)
+      //KEY to make window not resize
+      actionWindow.setBounds({
+        width: actionWindowWidth,
+        height: actionWindowHeight,
+        x: posX,
+        y: posY
+      })
+    }
+
+    if (!isMac) {
       actionWindow.show()
       return
     }
 
-    //follow toolbar
-    const toolbarBounds = this.toolbarWindow!.getBounds()
-    const display = screen.getDisplayNearestPoint(screen.getCursorScreenPoint())
-    const workArea = display.workArea
-    const GAP = 6 // 6px gap from screen edges
+    /************************************************
+     * [macOS] the following code is only for macOS
+     *
+     * WARNING:
+     *   DO NOT MODIFY THESE CODES, UNLESS YOU REALLY KNOW WHAT YOU ARE DOING!!!!
+     *************************************************/
 
-    //make sure action window is inside screen
-    if (actionWindowWidth > workArea.width - 2 * GAP) {
-      actionWindowWidth = workArea.width - 2 * GAP
+    // act normally when the app is not in fullscreen mode
+    if (!isFullScreen) {
+      actionWindow.show()
+      return
     }
 
-    if (actionWindowHeight > workArea.height - 2 * GAP) {
-      actionWindowHeight = workArea.height - 2 * GAP
-    }
+    // [macOS] an UGLY HACKY way for fullscreen override settings
 
-    // Calculate initial position to center action window horizontally below toolbar
-    let posX = Math.round(toolbarBounds.x + (toolbarBounds.width - actionWindowWidth) / 2)
-    let posY = Math.round(toolbarBounds.y)
+    // FIXME sometimes the dock will be shown when the action window is shown
+    // FIXME if actionWindow show on the fullscreen app, switch to other space will cause the mainWindow to be shown
+    // FIXME When setVisibleOnAllWorkspaces is true, docker icon disappeared when the first action window is shown on the fullscreen app
+    //       use app.dock.show() to show the dock again will cause the action window to be closed when auto hide on blur is enabled
 
-    // Ensure action window stays within screen boundaries with a small gap
-    if (posX + actionWindowWidth > workArea.x + workArea.width) {
-      posX = workArea.x + workArea.width - actionWindowWidth - GAP
-    } else if (posX < workArea.x) {
-      posX = workArea.x + GAP
-    }
-    if (posY + actionWindowHeight > workArea.y + workArea.height) {
-      // If window would go below screen, try to position it above toolbar
-      posY = workArea.y + workArea.height - actionWindowHeight - GAP
-    } else if (posY < workArea.y) {
-      posY = workArea.y + GAP
-    }
+    // setFocusable(false) to prevent the action window hide when blur (if auto hide on blur is enabled)
+    actionWindow.setFocusable(false)
+    actionWindow.setAlwaysOnTop(true, 'floating')
 
-    actionWindow.setPosition(posX, posY, false)
-    //KEY to make window not resize
-    actionWindow.setBounds({
-      width: actionWindowWidth,
-      height: actionWindowHeight,
-      x: posX,
-      y: posY
+    // `setVisibleOnAllWorkspaces(true)` will cause the dock icon disappeared
+    // just store the dock icon status, and show it again
+    const isDockShown = app.dock?.isVisible()
+
+    // DO NOT set `skipTransformProcessType: true`,
+    // it will cause the action window to be shown on other space
+    actionWindow.setVisibleOnAllWorkspaces(true, {
+      visibleOnFullScreen: true
     })
 
-    actionWindow.show()
+    actionWindow.showInactive()
+
+    // show the dock again if last time it was shown
+    // do not put it after `actionWindow.focus()`, will cause the action window to be closed when auto hide on blur is enabled
+    if (!app.dock?.isVisible() && isDockShown) {
+      app.dock?.show()
+    }
+
+    // unset everything
+    setTimeout(() => {
+      actionWindow.setVisibleOnAllWorkspaces(false, {
+        visibleOnFullScreen: true,
+        skipTransformProcessType: true
+      })
+      actionWindow.setAlwaysOnTop(false)
+
+      actionWindow.setFocusable(true)
+
+      // regain the focus when all the works done
+      actionWindow.focus()
+    }, 50)
   }
 
   public closeActionWindow(actionWindow: BrowserWindow): void {
@@ -1292,38 +1387,40 @@ export class SelectionService {
    * Switches between selection-based and alt-key based triggering
    * Manages appropriate event listeners for each mode
    */
-  private processTriggerMode() {
+  private processTriggerMode(): void {
+    if (!this.selectionHook) return
+
     switch (this.triggerMode) {
       case TriggerMode.Selected:
         if (this.isCtrlkeyListenerActive) {
-          this.selectionHook!.off('key-down', this.handleKeyDownCtrlkeyMode)
-          this.selectionHook!.off('key-up', this.handleKeyUpCtrlkeyMode)
+          this.selectionHook.off('key-down', this.handleKeyDownCtrlkeyMode)
+          this.selectionHook.off('key-up', this.handleKeyUpCtrlkeyMode)
 
           this.isCtrlkeyListenerActive = false
         }
 
-        this.selectionHook!.setSelectionPassiveMode(false)
+        this.selectionHook.setSelectionPassiveMode(false)
         break
       case TriggerMode.Ctrlkey:
         if (!this.isCtrlkeyListenerActive) {
-          this.selectionHook!.on('key-down', this.handleKeyDownCtrlkeyMode)
-          this.selectionHook!.on('key-up', this.handleKeyUpCtrlkeyMode)
+          this.selectionHook.on('key-down', this.handleKeyDownCtrlkeyMode)
+          this.selectionHook.on('key-up', this.handleKeyUpCtrlkeyMode)
 
           this.isCtrlkeyListenerActive = true
         }
 
-        this.selectionHook!.setSelectionPassiveMode(true)
+        this.selectionHook.setSelectionPassiveMode(true)
         break
       case TriggerMode.Shortcut:
         //remove the ctrlkey listener, don't need any key listener for shortcut mode
         if (this.isCtrlkeyListenerActive) {
-          this.selectionHook!.off('key-down', this.handleKeyDownCtrlkeyMode)
-          this.selectionHook!.off('key-up', this.handleKeyUpCtrlkeyMode)
+          this.selectionHook.off('key-down', this.handleKeyDownCtrlkeyMode)
+          this.selectionHook.off('key-up', this.handleKeyUpCtrlkeyMode)
 
           this.isCtrlkeyListenerActive = false
         }
 
-        this.selectionHook!.setSelectionPassiveMode(true)
+        this.selectionHook.setSelectionPassiveMode(true)
         break
     }
   }
@@ -1376,8 +1473,9 @@ export class SelectionService {
       configManager.setSelectionAssistantFilterList(filterList)
     })
 
-    ipcMain.handle(IpcChannel.Selection_ProcessAction, (_, actionItem: ActionItem) => {
-      selectionService?.processAction(actionItem)
+    // [macOS] only macOS has the available isFullscreen mode
+    ipcMain.handle(IpcChannel.Selection_ProcessAction, (_, actionItem: ActionItem, isFullScreen: boolean = false) => {
+      selectionService?.processAction(actionItem, isFullScreen)
     })
 
     ipcMain.handle(IpcChannel.Selection_ActionWindowClose, (event) => {
@@ -1404,13 +1502,13 @@ export class SelectionService {
     this.isIpcHandlerRegistered = true
   }
 
-  private logInfo(message: string, forceShow: boolean = false) {
+  private logInfo(message: string, forceShow: boolean = false): void {
     if (isDev || forceShow) {
       Logger.info('[SelectionService] Info: ', message)
     }
   }
 
-  private logError(...args: [...string[], Error]) {
+  private logError(...args: [...string[], Error]): void {
     Logger.error('[SelectionService] Error: ', ...args)
   }
 }
@@ -1423,7 +1521,7 @@ export class SelectionService {
 export function initSelectionService(): boolean {
   if (!isSupportedOS) return false
 
-  configManager.subscribe(ConfigKeys.SelectionAssistantEnabled, (enabled: boolean) => {
+  configManager.subscribe(ConfigKeys.SelectionAssistantEnabled, (enabled: boolean): void => {
     //avoid closure
     const ss = SelectionService.getInstance()
     if (!ss) {

src/main/services/ShortcutService.ts

@@ -55,7 +55,8 @@ function formatShortcutKey(shortcut: string[]): string {
   return shortcut.join('+')
 }
 
-// convert the shortcut recorded by keyboard event key value to electron global shortcut format
+// convert the shortcut recorded by JS keyboard event key value to electron global shortcut format
+// see: https://www.electronjs.org/zh/docs/latest/api/accelerator
 const convertShortcutFormat = (shortcut: string | string[]): string => {
   const accelerator = (() => {
     if (Array.isArray(shortcut)) {
@@ -68,12 +69,34 @@ const convertShortcutFormat = (shortcut: string | string[]): string => {
   return accelerator
     .map((key) => {
       switch (key) {
+        // OLD WAY FOR MODIFIER KEYS, KEEP THEM HERE FOR REFERENCE
+        // case 'Command':
+        //   return 'CommandOrControl'
+        // case 'Control':
+        //   return 'Control'
+        // case 'Ctrl':
+        //   return 'Control'
+
+        // NEW WAY FOR MODIFIER KEYS
+        // you can see all the modifier keys in the same
+        case 'CommandOrControl':
+          return 'CommandOrControl'
+        case 'Ctrl':
+          return 'Ctrl'
+        case 'Alt':
+          return 'Alt' // Use `Alt` instead of `Option`. The `Option` key only exists on macOS, whereas the `Alt` key is available on all platforms.
+        case 'Meta':
+          return 'Meta' // `Meta` key is mapped to the Windows key on Windows and Linux, `Cmd` on macOS.
+        case 'Shift':
+          return 'Shift'
+
+        // For backward compatibility with old data
         case 'Command':
+        case 'Cmd':
           return 'CommandOrControl'
         case 'Control':
-          return 'Control'
-        case 'Ctrl':
-          return 'Control'
+          return 'Ctrl'
+
         case 'ArrowUp':
           return 'Up'
         case 'ArrowDown':
@@ -83,7 +106,7 @@ const convertShortcutFormat = (shortcut: string | string[]): string => {
         case 'ArrowRight':
           return 'Right'
         case 'AltGraph':
-          return 'Alt'
+          return 'AltGr'
         case 'Slash':
           return '/'
         case 'Semicolon':

src/main/services/ThemeService.ts

@@ -1,48 +1,48 @@
-import { IpcChannel } from '@shared/IpcChannel'
-import { ThemeMode } from '@types'
-import { BrowserWindow, nativeTheme } from 'electron'
-
-import { titleBarOverlayDark, titleBarOverlayLight } from '../config'
-import { configManager } from './ConfigManager'
-
-class ThemeService {
-  private theme: ThemeMode = ThemeMode.system
-  constructor() {
-    this.theme = configManager.getTheme()
-
-    if (this.theme === ThemeMode.dark || this.theme === ThemeMode.light || this.theme === ThemeMode.system) {
-      nativeTheme.themeSource = this.theme
-    } else {
-      // 兼容旧版本
-      configManager.setTheme(ThemeMode.system)
-      nativeTheme.themeSource = ThemeMode.system
-    }
-    nativeTheme.on('updated', this.themeUpdatadHandler.bind(this))
-  }
-
-  themeUpdatadHandler() {
-    BrowserWindow.getAllWindows().forEach((win) => {
-      if (win && !win.isDestroyed() && win.setTitleBarOverlay) {
-        try {
-          win.setTitleBarOverlay(nativeTheme.shouldUseDarkColors ? titleBarOverlayDark : titleBarOverlayLight)
-        } catch (error) {
-          // don't throw error if setTitleBarOverlay failed
-          // Because it may be called with some windows have some title bar
-        }
-      }
-      win.webContents.send(IpcChannel.ThemeUpdated, nativeTheme.shouldUseDarkColors ? ThemeMode.dark : ThemeMode.light)
-    })
-  }
-
-  setTheme(theme: ThemeMode) {
-    if (theme === this.theme) {
-      return
-    }
-
-    this.theme = theme
-    nativeTheme.themeSource = theme
-    configManager.setTheme(theme)
-  }
-}
-
-export const themeService = new ThemeService()
+import { IpcChannel } from '@shared/IpcChannel'
+import { ThemeMode } from '@types'
+import { BrowserWindow, nativeTheme } from 'electron'
+
+import { titleBarOverlayDark, titleBarOverlayLight } from '../config'
+import { configManager } from './ConfigManager'
+
+class ThemeService {
+  private theme: ThemeMode = ThemeMode.system
+  constructor() {
+    this.theme = configManager.getTheme()
+
+    if (this.theme === ThemeMode.dark || this.theme === ThemeMode.light || this.theme === ThemeMode.system) {
+      nativeTheme.themeSource = this.theme
+    } else {
+      // 兼容旧版本
+      configManager.setTheme(ThemeMode.system)
+      nativeTheme.themeSource = ThemeMode.system
+    }
+    nativeTheme.on('updated', this.themeUpdatadHandler.bind(this))
+  }
+
+  themeUpdatadHandler() {
+    BrowserWindow.getAllWindows().forEach((win) => {
+      if (win && !win.isDestroyed() && win.setTitleBarOverlay) {
+        try {
+          win.setTitleBarOverlay(nativeTheme.shouldUseDarkColors ? titleBarOverlayDark : titleBarOverlayLight)
+        } catch (error) {
+          // don't throw error if setTitleBarOverlay failed
+          // Because it may be called with some windows have some title bar
+        }
+      }
+      win.webContents.send(IpcChannel.ThemeUpdated, nativeTheme.shouldUseDarkColors ? ThemeMode.dark : ThemeMode.light)
+    })
+  }
+
+  setTheme(theme: ThemeMode) {
+    if (theme === this.theme) {
+      return
+    }
+
+    this.theme = theme
+    nativeTheme.themeSource = theme
+    configManager.setTheme(theme)
+  }
+}
+
+export const themeService = new ThemeService()

src/main/services/WebDav.ts

@@ -23,7 +23,9 @@ export default class WebDav {
       password: params.webdavPass,
       maxBodyLength: Infinity,
       maxContentLength: Infinity,
-      httpsAgent: new https.Agent({ rejectUnauthorized: false })
+      httpsAgent: new https.Agent({
+        rejectUnauthorized: false
+      })
     })
 
     this.putFileContents = this.putFileContents.bind(this)

src/main/services/WindowService.ts

@@ -5,7 +5,7 @@ import { is } from '@electron-toolkit/utils'
 import { isDev, isLinux, isMac, isWin } from '@main/constant'
 import { getFilesDir } from '@main/utils/file'
 import { IpcChannel } from '@shared/IpcChannel'
-import { app, BrowserWindow, nativeTheme, shell } from 'electron'
+import { app, BrowserWindow, nativeTheme, screen, shell } from 'electron'
 import Logger from 'electron-log'
 import windowStateKeeper from 'electron-window-state'
 import { join } from 'path'
@@ -16,6 +16,9 @@ import { configManager } from './ConfigManager'
 import { contextMenu } from './ContextMenu'
 import { initSessionUserAgent } from './WebviewService'
 
+const DEFAULT_MINIWINDOW_WIDTH = 550
+const DEFAULT_MINIWINDOW_HEIGHT = 400
+
 export class WindowService {
   private static instance: WindowService | null = null
   private mainWindow: BrowserWindow | null = null
@@ -26,6 +29,11 @@ export class WindowService {
   private wasMainWindowFocused: boolean = false
   private lastRendererProcessCrashTime: number = 0
 
+  private miniWindowSize: { width: number; height: number } = {
+    width: DEFAULT_MINIWINDOW_WIDTH,
+    height: DEFAULT_MINIWINDOW_HEIGHT
+  }
+
   public static getInstance(): WindowService {
     if (!WindowService.instance) {
       WindowService.instance = new WindowService()
@@ -41,8 +49,8 @@ export class WindowService {
     }
 
     const mainWindowState = windowStateKeeper({
-      defaultWidth: 1080,
-      defaultHeight: 670,
+      defaultWidth: 960,
+      defaultHeight: 600,
       fullScreen: false,
       maximize: false
     })
@@ -52,7 +60,7 @@ export class WindowService {
       y: mainWindowState.y,
       width: mainWindowState.width,
       height: mainWindowState.height,
-      minWidth: 1080,
+      minWidth: 960,
       minHeight: 600,
       show: false,
       autoHideMenuBar: true,
@@ -426,8 +434,8 @@ export class WindowService {
 
   public createMiniWindow(isPreload: boolean = false): BrowserWindow {
     this.miniWindow = new BrowserWindow({
-      width: 550,
-      height: 400,
+      width: this.miniWindowSize.width,
+      height: this.miniWindowSize.height,
       minWidth: 350,
       minHeight: 380,
       maxWidth: 1024,
@@ -437,13 +445,12 @@ export class WindowService {
       transparent: isMac,
       vibrancy: 'under-window',
       visualEffectState: 'followWindow',
-      center: true,
       frame: false,
       alwaysOnTop: true,
-      resizable: true,
       useContentSize: true,
       ...(isMac ? { type: 'panel' } : {}),
       skipTaskbar: true,
+      resizable: true,
       minimizable: false,
       maximizable: false,
       fullscreenable: false,
@@ -485,6 +492,13 @@ export class WindowService {
       this.miniWindow?.webContents.send(IpcChannel.HideMiniWindow)
     })
 
+    this.miniWindow.on('resized', () => {
+      this.miniWindowSize = this.miniWindow?.getBounds() || {
+        width: DEFAULT_MINIWINDOW_WIDTH,
+        height: DEFAULT_MINIWINDOW_HEIGHT
+      }
+    })
+
     this.miniWindow.on('show', () => {
       this.miniWindow?.webContents.send(IpcChannel.ShowMiniWindow)
     })
@@ -508,10 +522,48 @@ export class WindowService {
     if (this.miniWindow && !this.miniWindow.isDestroyed()) {
       this.wasMainWindowFocused = this.mainWindow?.isFocused() || false
 
-      if (this.miniWindow.isMinimized()) {
-        this.miniWindow.restore()
+      // [Windows] hacky fix
+      // the window is minimized only when in Windows platform
+      // because it's a workround for Windows, see `hideMiniWindow()`
+      if (this.miniWindow?.isMinimized()) {
+        // don't let the window being seen before we finish adusting the position across screens
+        this.miniWindow?.setOpacity(0)
+        // DO NOT use `restore()` here, Electron has the bug with screens of different scale factor
+        // We have to use `show()` here, then set the position and bounds
+        this.miniWindow?.show()
       }
-      this.miniWindow.show()
+
+      const miniWindowBounds = this.miniWindow.getBounds()
+
+      // Check if miniWindow is on the same screen as mouse cursor
+      const cursorDisplay = screen.getDisplayNearestPoint(screen.getCursorScreenPoint())
+      const miniWindowDisplay = screen.getDisplayNearestPoint(miniWindowBounds)
+
+      // Show the miniWindow on the cursor's screen center
+      // If miniWindow is not on the same screen as cursor, move it to cursor's screen center
+      if (cursorDisplay.id !== miniWindowDisplay.id) {
+        const workArea = cursorDisplay.bounds
+
+        // use remembered size to avoid the bug of Electron with screens of different scale factor
+        const miniWindowWidth = this.miniWindowSize.width
+        const miniWindowHeight = this.miniWindowSize.height
+
+        // move to the center of the cursor's screen
+        const miniWindowX = Math.round(workArea.x + (workArea.width - miniWindowWidth) / 2)
+        const miniWindowY = Math.round(workArea.y + (workArea.height - miniWindowHeight) / 2)
+
+        this.miniWindow.setPosition(miniWindowX, miniWindowY, false)
+        this.miniWindow.setBounds({
+          x: miniWindowX,
+          y: miniWindowY,
+          width: miniWindowWidth,
+          height: miniWindowHeight
+        })
+      }
+
+      this.miniWindow?.setOpacity(1)
+      this.miniWindow?.show()
+
       return
     }
 
@@ -519,20 +571,26 @@ export class WindowService {
   }
 
   public hideMiniWindow() {
-    //hacky-fix:[mac/win] previous window(not self-app) should be focused again after miniWindow hide
+    if (!this.miniWindow || this.miniWindow.isDestroyed()) {
+      return
+    }
+
+    //[macOs/Windows] hacky fix
+    // previous window(not self-app) should be focused again after miniWindow hide
+    // this workaround is to make previous window focused again after miniWindow hide
     if (isWin) {
-      this.miniWindow?.minimize()
-      this.miniWindow?.hide()
+      this.miniWindow.setOpacity(0) // don't show the minimizing animation
+      this.miniWindow.minimize()
       return
     } else if (isMac) {
-      this.miniWindow?.hide()
+      this.miniWindow.hide()
       if (!this.wasMainWindowFocused) {
         app.hide()
       }
       return
     }
 
-    this.miniWindow?.hide()
+    this.miniWindow.hide()
   }
 
   public closeMiniWindow() {

src/main/services/memory/MemoryService.ts

@@ -0,0 +1,829 @@
+import { Client, createClient } from '@libsql/client'
+import Embeddings from '@main/knowledge/embeddings/Embeddings'
+import type {
+  AddMemoryOptions,
+  AssistantMessage,
+  MemoryConfig,
+  MemoryHistoryItem,
+  MemoryItem,
+  MemoryListOptions,
+  MemorySearchOptions
+} from '@types'
+import crypto from 'crypto'
+import { app } from 'electron'
+import Logger from 'electron-log'
+import path from 'path'
+
+import { MemoryQueries } from './queries'
+
+export interface EmbeddingOptions {
+  model: string
+  provider: string
+  apiKey: string
+  apiVersion?: string
+  baseURL: string
+  dimensions?: number
+  batchSize?: number
+}
+
+export interface VectorSearchOptions {
+  limit?: number
+  threshold?: number
+  userId?: string
+  agentId?: string
+  filters?: Record<string, any>
+}
+
+export interface SearchResult {
+  memories: MemoryItem[]
+  count: number
+  error?: string
+}
+
+export class MemoryService {
+  private static instance: MemoryService | null = null
+  private db: Client | null = null
+  private isInitialized = false
+  private embeddings: Embeddings | null = null
+  private config: MemoryConfig | null = null
+  private static readonly UNIFIED_DIMENSION = 1536
+  private static readonly SIMILARITY_THRESHOLD = 0.85
+
+  private constructor() {
+    // Private constructor to enforce singleton pattern
+  }
+
+  public static getInstance(): MemoryService {
+    if (!MemoryService.instance) {
+      MemoryService.instance = new MemoryService()
+    }
+    return MemoryService.instance
+  }
+
+  public static reload(): MemoryService {
+    if (MemoryService.instance) {
+      MemoryService.instance.close()
+    }
+    MemoryService.instance = new MemoryService()
+    return MemoryService.instance
+  }
+
+  /**
+   * Initialize the database connection and create tables
+   */
+  private async init(): Promise<void> {
+    if (this.isInitialized && this.db) {
+      return
+    }
+
+    try {
+      const userDataPath = app.getPath('userData')
+      const dbPath = path.join(userDataPath, 'memories.db')
+
+      this.db = createClient({
+        url: `file:${dbPath}`,
+        intMode: 'number'
+      })
+
+      // Create tables
+      await this.createTables()
+      this.isInitialized = true
+      Logger.info('Memory database initialized successfully')
+    } catch (error) {
+      Logger.error('Failed to initialize memory database:', error)
+      throw new Error(
+        `Memory database initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+      )
+    }
+  }
+
+  private async createTables(): Promise<void> {
+    if (!this.db) throw new Error('Database not initialized')
+
+    // Create memories table with native vector support
+    await this.db.execute(MemoryQueries.createTables.memories)
+
+    // Create memory history table
+    await this.db.execute(MemoryQueries.createTables.memoryHistory)
+
+    // Create indexes
+    await this.db.execute(MemoryQueries.createIndexes.userId)
+    await this.db.execute(MemoryQueries.createIndexes.agentId)
+    await this.db.execute(MemoryQueries.createIndexes.createdAt)
+    await this.db.execute(MemoryQueries.createIndexes.hash)
+    await this.db.execute(MemoryQueries.createIndexes.memoryHistory)
+
+    // Create vector index for similarity search
+    try {
+      await this.db.execute(MemoryQueries.createIndexes.vector)
+    } catch (error) {
+      // Vector index might not be supported in all versions
+      Logger.warn('Failed to create vector index, falling back to non-indexed search:', error)
+    }
+  }
+
+  /**
+   * Add new memories from messages
+   */
+  public async add(messages: string | AssistantMessage[], options: AddMemoryOptions): Promise<SearchResult> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    const { userId, agentId, runId, metadata } = options
+
+    try {
+      // Convert messages to memory strings
+      const memoryStrings = Array.isArray(messages)
+        ? messages.map((m) => (typeof m === 'string' ? m : m.content))
+        : [messages]
+      const addedMemories: MemoryItem[] = []
+
+      for (const memory of memoryStrings) {
+        const trimmedMemory = memory.trim()
+        if (!trimmedMemory) continue
+
+        // Generate hash for deduplication
+        const hash = crypto.createHash('sha256').update(trimmedMemory).digest('hex')
+
+        // Check if memory already exists
+        const existing = await this.db.execute({
+          sql: MemoryQueries.memory.checkExistsIncludeDeleted,
+          args: [hash]
+        })
+
+        if (existing.rows.length > 0) {
+          const existingRecord = existing.rows[0] as any
+          const isDeleted = existingRecord.is_deleted === 1
+
+          if (!isDeleted) {
+            // Active record exists, skip insertion
+            Logger.info(`Memory already exists with hash: ${hash}`)
+            continue
+          } else {
+            // Deleted record exists, restore it instead of inserting new one
+            Logger.info(`Restoring deleted memory with hash: ${hash}`)
+
+            // Generate embedding if model is configured
+            let embedding: number[] | null = null
+            const embedderApiClient = this.config?.embedderApiClient
+            if (embedderApiClient) {
+              try {
+                embedding = await this.generateEmbedding(trimmedMemory)
+                Logger.info(
+                  `Generated embedding for restored memory with dimension: ${embedding.length} (target: ${this.config?.embedderDimensions || MemoryService.UNIFIED_DIMENSION})`
+                )
+              } catch (error) {
+                Logger.error('Failed to generate embedding for restored memory:', error)
+              }
+            }
+
+            const now = new Date().toISOString()
+
+            // Restore the deleted record
+            await this.db.execute({
+              sql: MemoryQueries.memory.restoreDeleted,
+              args: [
+                trimmedMemory,
+                embedding ? this.embeddingToVector(embedding) : null,
+                metadata ? JSON.stringify(metadata) : null,
+                now,
+                existingRecord.id
+              ]
+            })
+
+            // Add to history
+            await this.addHistory(existingRecord.id, null, trimmedMemory, 'ADD')
+
+            addedMemories.push({
+              id: existingRecord.id,
+              memory: trimmedMemory,
+              hash,
+              createdAt: now,
+              updatedAt: now,
+              metadata
+            })
+            continue
+          }
+        }
+
+        // Generate embedding if model is configured
+        let embedding: number[] | null = null
+        if (this.config?.embedderApiClient) {
+          try {
+            embedding = await this.generateEmbedding(trimmedMemory)
+            Logger.info(
+              `Generated embedding with dimension: ${embedding.length} (target: ${this.config?.embedderDimensions || MemoryService.UNIFIED_DIMENSION})`
+            )
+
+            // Check for similar memories using vector similarity
+            const similarMemories = await this.hybridSearch(trimmedMemory, embedding, {
+              limit: 5,
+              threshold: 0.1, // Lower threshold to get more candidates
+              userId,
+              agentId
+            })
+
+            // Check if any similar memory exceeds the similarity threshold
+            if (similarMemories.memories.length > 0) {
+              const highestSimilarity = Math.max(...similarMemories.memories.map((m) => m.score || 0))
+              if (highestSimilarity >= MemoryService.SIMILARITY_THRESHOLD) {
+                Logger.info(
+                  `Skipping memory addition due to high similarity: ${highestSimilarity.toFixed(3)} >= ${MemoryService.SIMILARITY_THRESHOLD}`
+                )
+                Logger.info(`Similar memory found: "${similarMemories.memories[0].memory}"`)
+                continue
+              }
+            }
+          } catch (error) {
+            Logger.error('Failed to generate embedding:', error)
+          }
+        }
+
+        // Insert new memory
+        const id = crypto.randomUUID()
+        const now = new Date().toISOString()
+
+        await this.db.execute({
+          sql: MemoryQueries.memory.insert,
+          args: [
+            id,
+            trimmedMemory,
+            hash,
+            embedding ? this.embeddingToVector(embedding) : null,
+            metadata ? JSON.stringify(metadata) : null,
+            userId || null,
+            agentId || null,
+            runId || null,
+            now,
+            now
+          ]
+        })
+
+        // Add to history
+        await this.addHistory(id, null, trimmedMemory, 'ADD')
+
+        addedMemories.push({
+          id,
+          memory: trimmedMemory,
+          hash,
+          createdAt: now,
+          updatedAt: now,
+          metadata
+        })
+      }
+
+      return {
+        memories: addedMemories,
+        count: addedMemories.length
+      }
+    } catch (error) {
+      Logger.error('Failed to add memories:', error)
+      return {
+        memories: [],
+        count: 0,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      }
+    }
+  }
+
+  /**
+   * Search memories using text or vector similarity
+   */
+  public async search(query: string, options: MemorySearchOptions = {}): Promise<SearchResult> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    const { limit = 10, userId, agentId, filters = {} } = options
+
+    try {
+      // If we have an embedder model configured, use vector search
+      if (this.config?.embedderApiClient) {
+        try {
+          const queryEmbedding = await this.generateEmbedding(query)
+          return await this.hybridSearch(query, queryEmbedding, { limit, userId, agentId, filters })
+        } catch (error) {
+          Logger.error('Vector search failed, falling back to text search:', error)
+        }
+      }
+
+      // Fallback to text search
+      const conditions: string[] = ['m.is_deleted = 0']
+      const params: any[] = []
+
+      // Add search conditions
+      conditions.push('(m.memory LIKE ? OR m.memory LIKE ?)')
+      params.push(`%${query}%`, `%${query.split(' ').join('%')}%`)
+
+      if (userId) {
+        conditions.push('m.user_id = ?')
+        params.push(userId)
+      }
+
+      if (agentId) {
+        conditions.push('m.agent_id = ?')
+        params.push(agentId)
+      }
+
+      // Add custom filters
+      for (const [key, value] of Object.entries(filters)) {
+        if (value !== undefined && value !== null) {
+          conditions.push(`json_extract(m.metadata, '$.${key}') = ?`)
+          params.push(value)
+        }
+      }
+
+      const whereClause = conditions.join(' AND ')
+      params.push(limit)
+
+      const result = await this.db.execute({
+        sql: `${MemoryQueries.memory.list} ${whereClause}
+          ORDER BY m.created_at DESC
+          LIMIT ?
+        `,
+        args: params
+      })
+
+      const memories: MemoryItem[] = result.rows.map((row: any) => ({
+        id: row.id as string,
+        memory: row.memory as string,
+        hash: (row.hash as string) || undefined,
+        metadata: row.metadata ? JSON.parse(row.metadata as string) : undefined,
+        createdAt: row.created_at as string,
+        updatedAt: row.updated_at as string
+      }))
+
+      return {
+        memories,
+        count: memories.length
+      }
+    } catch (error) {
+      Logger.error('Search failed:', error)
+      return {
+        memories: [],
+        count: 0,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      }
+    }
+  }
+
+  /**
+   * List all memories with optional filters
+   */
+  public async list(options: MemoryListOptions = {}): Promise<SearchResult> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    const { userId, agentId, limit = 100, offset = 0 } = options
+
+    try {
+      const conditions: string[] = ['m.is_deleted = 0']
+      const params: any[] = []
+
+      if (userId) {
+        conditions.push('m.user_id = ?')
+        params.push(userId)
+      }
+
+      if (agentId) {
+        conditions.push('m.agent_id = ?')
+        params.push(agentId)
+      }
+
+      const whereClause = conditions.join(' AND ')
+
+      // Get total count
+      const countResult = await this.db.execute({
+        sql: `${MemoryQueries.memory.count} ${whereClause}`,
+        args: params
+      })
+      const totalCount = (countResult.rows[0] as any).total as number
+
+      // Get paginated results
+      params.push(limit, offset)
+      const result = await this.db.execute({
+        sql: `${MemoryQueries.memory.list} ${whereClause}
+          ORDER BY m.created_at DESC
+          LIMIT ? OFFSET ?
+        `,
+        args: params
+      })
+
+      const memories: MemoryItem[] = result.rows.map((row: any) => ({
+        id: row.id as string,
+        memory: row.memory as string,
+        hash: (row.hash as string) || undefined,
+        metadata: row.metadata ? JSON.parse(row.metadata as string) : undefined,
+        createdAt: row.created_at as string,
+        updatedAt: row.updated_at as string
+      }))
+
+      return {
+        memories,
+        count: totalCount
+      }
+    } catch (error) {
+      Logger.error('List failed:', error)
+      return {
+        memories: [],
+        count: 0,
+        error: error instanceof Error ? error.message : 'Unknown error'
+      }
+    }
+  }
+
+  /**
+   * Delete a memory (soft delete)
+   */
+  public async delete(id: string): Promise<void> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    try {
+      // Get current memory value for history
+      const current = await this.db.execute({
+        sql: MemoryQueries.memory.getForDelete,
+        args: [id]
+      })
+
+      if (current.rows.length === 0) {
+        throw new Error('Memory not found')
+      }
+
+      const currentMemory = (current.rows[0] as any).memory as string
+
+      // Soft delete
+      await this.db.execute({
+        sql: MemoryQueries.memory.softDelete,
+        args: [new Date().toISOString(), id]
+      })
+
+      // Add to history
+      await this.addHistory(id, currentMemory, null, 'DELETE')
+
+      Logger.info(`Memory deleted: ${id}`)
+    } catch (error) {
+      Logger.error('Delete failed:', error)
+      throw new Error(`Failed to delete memory: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  /**
+   * Update a memory
+   */
+  public async update(id: string, memory: string, metadata?: Record<string, any>): Promise<void> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    try {
+      // Get current memory
+      const current = await this.db.execute({
+        sql: MemoryQueries.memory.getForUpdate,
+        args: [id]
+      })
+
+      if (current.rows.length === 0) {
+        throw new Error('Memory not found')
+      }
+
+      const row = current.rows[0] as any
+      const previousMemory = row.memory as string
+      const previousMetadata = row.metadata ? JSON.parse(row.metadata as string) : {}
+
+      // Generate new hash
+      const hash = crypto.createHash('sha256').update(memory.trim()).digest('hex')
+
+      // Generate new embedding if model is configured
+      let embedding: number[] | null = null
+      if (this.config?.embedderApiClient) {
+        try {
+          embedding = await this.generateEmbedding(memory)
+          Logger.info(
+            `Updated embedding with dimension: ${embedding.length} (target: ${this.config?.embedderDimensions || MemoryService.UNIFIED_DIMENSION})`
+          )
+        } catch (error) {
+          Logger.error('Failed to generate embedding for update:', error)
+        }
+      }
+
+      // Merge metadata
+      const mergedMetadata = { ...previousMetadata, ...metadata }
+
+      // Update memory
+      await this.db.execute({
+        sql: MemoryQueries.memory.update,
+        args: [
+          memory.trim(),
+          hash,
+          embedding ? this.embeddingToVector(embedding) : null,
+          JSON.stringify(mergedMetadata),
+          new Date().toISOString(),
+          id
+        ]
+      })
+
+      // Add to history
+      await this.addHistory(id, previousMemory, memory, 'UPDATE')
+
+      Logger.info(`Memory updated: ${id}`)
+    } catch (error) {
+      Logger.error('Update failed:', error)
+      throw new Error(`Failed to update memory: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  /**
+   * Get memory history
+   */
+  public async get(memoryId: string): Promise<MemoryHistoryItem[]> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    try {
+      const result = await this.db.execute({
+        sql: MemoryQueries.history.getByMemoryId,
+        args: [memoryId]
+      })
+
+      return result.rows.map((row: any) => ({
+        id: row.id as number,
+        memoryId: row.memory_id as string,
+        previousValue: row.previous_value as string | undefined,
+        newValue: row.new_value as string,
+        action: row.action as 'ADD' | 'UPDATE' | 'DELETE',
+        createdAt: row.created_at as string,
+        updatedAt: row.updated_at as string,
+        isDeleted: row.is_deleted === 1
+      }))
+    } catch (error) {
+      Logger.error('Get history failed:', error)
+      throw new Error(`Failed to get memory history: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  /**
+   * Delete all memories for a user without deleting the user (hard delete)
+   */
+  public async deleteAllMemoriesForUser(userId: string): Promise<void> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    if (!userId) {
+      throw new Error('User ID is required')
+    }
+
+    try {
+      // Get count of memories to be deleted
+      const countResult = await this.db.execute({
+        sql: MemoryQueries.users.countMemoriesForUser,
+        args: [userId]
+      })
+      const totalCount = (countResult.rows[0] as any).total as number
+
+      // Delete history entries for this user's memories
+      await this.db.execute({
+        sql: MemoryQueries.users.deleteHistoryForUser,
+        args: [userId]
+      })
+
+      // Hard delete all memories for this user
+      await this.db.execute({
+        sql: MemoryQueries.users.deleteAllMemoriesForUser,
+        args: [userId]
+      })
+
+      Logger.info(`Reset all memories for user ${userId} (${totalCount} memories deleted)`)
+    } catch (error) {
+      Logger.error('Reset user memories failed:', error)
+      throw new Error(`Failed to reset user memories: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  /**
+   * Delete a user and all their memories (hard delete)
+   */
+  public async deleteUser(userId: string): Promise<void> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    if (!userId) {
+      throw new Error('User ID is required')
+    }
+
+    if (userId === 'default-user') {
+      throw new Error('Cannot delete the default user')
+    }
+
+    try {
+      // Get count of memories to be deleted
+      const countResult = await this.db.execute({
+        sql: `SELECT COUNT(*) as total FROM memories WHERE user_id = ?`,
+        args: [userId]
+      })
+      const totalCount = (countResult.rows[0] as any).total as number
+
+      // Delete history entries for this user's memories
+      await this.db.execute({
+        sql: `DELETE FROM memory_history WHERE memory_id IN (SELECT id FROM memories WHERE user_id = ?)`,
+        args: [userId]
+      })
+
+      // Delete all memories for this user (hard delete)
+      await this.db.execute({
+        sql: `DELETE FROM memories WHERE user_id = ?`,
+        args: [userId]
+      })
+
+      Logger.info(`Deleted user ${userId} and ${totalCount} memories`)
+    } catch (error) {
+      Logger.error('Delete user failed:', error)
+      throw new Error(`Failed to delete user: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  /**
+   * Get list of unique user IDs with their memory counts
+   */
+  public async getUsersList(): Promise<{ userId: string; memoryCount: number; lastMemoryDate: string }[]> {
+    await this.init()
+    if (!this.db) throw new Error('Database not initialized')
+
+    try {
+      const result = await this.db.execute({
+        sql: MemoryQueries.users.getUniqueUsers,
+        args: []
+      })
+
+      return result.rows.map((row: any) => ({
+        userId: row.user_id as string,
+        memoryCount: row.memory_count as number,
+        lastMemoryDate: row.last_memory_date as string
+      }))
+    } catch (error) {
+      Logger.error('Get users list failed:', error)
+      throw new Error(`Failed to get users list: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  /**
+   * Update configuration
+   */
+  public setConfig(config: MemoryConfig): void {
+    this.config = config
+    // Reset embeddings instance when config changes
+    this.embeddings = null
+  }
+
+  /**
+   * Close database connection
+   */
+  public async close(): Promise<void> {
+    if (this.db) {
+      await this.db.close()
+      this.db = null
+      this.isInitialized = false
+    }
+  }
+
+  // ========== EMBEDDING OPERATIONS (Previously EmbeddingService) ==========
+
+  /**
+   * Normalize embedding dimensions to unified size
+   */
+  private normalizeEmbedding(embedding: number[]): number[] {
+    if (embedding.length === MemoryService.UNIFIED_DIMENSION) {
+      return embedding
+    }
+
+    if (embedding.length < MemoryService.UNIFIED_DIMENSION) {
+      // Pad with zeros
+      return [...embedding, ...new Array(MemoryService.UNIFIED_DIMENSION - embedding.length).fill(0)]
+    } else {
+      // Truncate
+      return embedding.slice(0, MemoryService.UNIFIED_DIMENSION)
+    }
+  }
+
+  /**
+   * Generate embedding for text
+   */
+  private async generateEmbedding(text: string): Promise<number[]> {
+    if (!this.config?.embedderApiClient) {
+      throw new Error('Embedder model not configured')
+    }
+
+    try {
+      // Initialize embeddings instance if needed
+      if (!this.embeddings) {
+        if (!this.config.embedderApiClient) {
+          throw new Error('Embedder provider not configured')
+        }
+
+        this.embeddings = new Embeddings({
+          embedApiClient: this.config.embedderApiClient,
+          dimensions: this.config.embedderDimensions
+        })
+        await this.embeddings.init()
+      }
+
+      const embedding = await this.embeddings.embedQuery(text)
+
+      // Normalize to unified dimension
+      return this.normalizeEmbedding(embedding)
+    } catch (error) {
+      Logger.error('Embedding generation failed:', error)
+      throw new Error(`Failed to generate embedding: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  // ========== VECTOR SEARCH OPERATIONS (Previously VectorSearch) ==========
+
+  /**
+   * Convert embedding array to libsql vector format
+   */
+  private embeddingToVector(embedding: number[]): string {
+    return `[${embedding.join(',')}]`
+  }
+
+  /**
+   * Hybrid search combining text and vector similarity (currently vector-only)
+   */
+  private async hybridSearch(
+    _: string,
+    queryEmbedding: number[],
+    options: VectorSearchOptions = {}
+  ): Promise<SearchResult> {
+    if (!this.db) throw new Error('Database not initialized')
+
+    const { limit = 10, threshold = 0.5, userId } = options
+
+    try {
+      const queryVector = this.embeddingToVector(queryEmbedding)
+
+      const conditions: string[] = ['m.is_deleted = 0']
+      const params: any[] = []
+
+      // Vector search only - three vector parameters for distance, vector_similarity, and combined_score
+      params.push(queryVector, queryVector, queryVector)
+
+      if (userId) {
+        conditions.push('m.user_id = ?')
+        params.push(userId)
+      }
+
+      const whereClause = conditions.join(' AND ')
+
+      const hybridQuery = `${MemoryQueries.search.hybridSearch} ${whereClause}
+      ) AS results
+      WHERE vector_similarity >= ?
+      ORDER BY vector_similarity DESC
+      LIMIT ?`
+
+      params.push(threshold, limit)
+
+      const result = await this.db.execute({
+        sql: hybridQuery,
+        args: params
+      })
+
+      const memories: MemoryItem[] = result.rows.map((row: any) => ({
+        id: row.id as string,
+        memory: row.memory as string,
+        hash: (row.hash as string) || undefined,
+        metadata: row.metadata ? JSON.parse(row.metadata as string) : undefined,
+        createdAt: row.created_at as string,
+        updatedAt: row.updated_at as string,
+        score: row.vector_similarity as number
+      }))
+
+      return {
+        memories,
+        count: memories.length
+      }
+    } catch (error) {
+      Logger.error('Hybrid search failed:', error)
+      throw new Error(`Hybrid search failed: ${error instanceof Error ? error.message : 'Unknown error'}`)
+    }
+  }
+
+  // ========== HELPER METHODS ==========
+
+  /**
+   * Add entry to memory history
+   */
+  private async addHistory(
+    memoryId: string,
+    previousValue: string | null,
+    newValue: string | null,
+    action: 'ADD' | 'UPDATE' | 'DELETE'
+  ): Promise<void> {
+    if (!this.db) throw new Error('Database not initialized')
+
+    const now = new Date().toISOString()
+    await this.db.execute({
+      sql: MemoryQueries.history.insert,
+      args: [memoryId, previousValue, newValue, action, now, now]
+    })
+  }
+}
+
+export default MemoryService

src/main/services/memory/queries.ts

@@ -0,0 +1,164 @@
+/**
+ * SQL queries for MemoryService
+ * All SQL queries are centralized here for better maintainability
+ */
+
+export const MemoryQueries = {
+  // Table creation queries
+  createTables: {
+    memories: `
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        memory TEXT NOT NULL,
+        hash TEXT UNIQUE,
+        embedding F32_BLOB(1536), -- Native vector column (1536 dimensions for OpenAI embeddings)
+        metadata TEXT, -- JSON string
+        user_id TEXT,
+        agent_id TEXT,
+        run_id TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        is_deleted INTEGER DEFAULT 0
+      )
+    `,
+
+    memoryHistory: `
+      CREATE TABLE IF NOT EXISTS memory_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        memory_id TEXT NOT NULL,
+        previous_value TEXT,
+        new_value TEXT,
+        action TEXT NOT NULL, -- ADD, UPDATE, DELETE
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        is_deleted INTEGER DEFAULT 0,
+        FOREIGN KEY (memory_id) REFERENCES memories (id)
+      )
+    `
+  },
+
+  // Index creation queries
+  createIndexes: {
+    userId: 'CREATE INDEX IF NOT EXISTS idx_memories_user_id ON memories(user_id)',
+    agentId: 'CREATE INDEX IF NOT EXISTS idx_memories_agent_id ON memories(agent_id)',
+    createdAt: 'CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at)',
+    hash: 'CREATE INDEX IF NOT EXISTS idx_memories_hash ON memories(hash)',
+    memoryHistory: 'CREATE INDEX IF NOT EXISTS idx_memory_history_memory_id ON memory_history(memory_id)',
+    vector: 'CREATE INDEX IF NOT EXISTS idx_memories_vector ON memories (libsql_vector_idx(embedding))'
+  },
+
+  // Memory operations
+  memory: {
+    checkExists: 'SELECT id FROM memories WHERE hash = ? AND is_deleted = 0',
+
+    checkExistsIncludeDeleted: 'SELECT id, is_deleted FROM memories WHERE hash = ?',
+
+    restoreDeleted: `
+      UPDATE memories 
+      SET is_deleted = 0, memory = ?, embedding = ?, metadata = ?, updated_at = ?
+      WHERE id = ?
+    `,
+
+    insert: `
+      INSERT INTO memories (id, memory, hash, embedding, metadata, user_id, agent_id, run_id, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+
+    getForDelete: 'SELECT memory FROM memories WHERE id = ? AND is_deleted = 0',
+
+    softDelete: 'UPDATE memories SET is_deleted = 1, updated_at = ? WHERE id = ?',
+
+    getForUpdate: 'SELECT memory, metadata FROM memories WHERE id = ? AND is_deleted = 0',
+
+    update: `
+      UPDATE memories 
+      SET memory = ?, hash = ?, embedding = ?, metadata = ?, updated_at = ?
+      WHERE id = ?
+    `,
+
+    count: 'SELECT COUNT(*) as total FROM memories m WHERE',
+
+    list: `
+      SELECT 
+        m.id,
+        m.memory,
+        m.hash,
+        m.metadata,
+        m.user_id,
+        m.agent_id,
+        m.run_id,
+        m.created_at,
+        m.updated_at
+      FROM memories m
+      WHERE
+    `
+  },
+
+  // History operations
+  history: {
+    insert: `
+      INSERT INTO memory_history (memory_id, previous_value, new_value, action, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `,
+
+    getByMemoryId: `
+      SELECT * FROM memory_history 
+      WHERE memory_id = ? AND is_deleted = 0
+      ORDER BY created_at DESC
+    `
+  },
+
+  // Search operations
+  search: {
+    hybridSearch: `
+      SELECT * FROM (
+        SELECT 
+          m.id,
+          m.memory,
+          m.hash,
+          m.metadata,
+          m.user_id,
+          m.agent_id,
+          m.run_id,
+          m.created_at,
+          m.updated_at,
+          CASE 
+            WHEN m.embedding IS NULL THEN 2.0
+            ELSE vector_distance_cos(m.embedding, vector32(?))
+          END as distance,
+          CASE 
+            WHEN m.embedding IS NULL THEN 0.0
+            ELSE (1 - vector_distance_cos(m.embedding, vector32(?)))
+          END as vector_similarity,
+          0.0 as text_similarity,
+          (
+            CASE 
+              WHEN m.embedding IS NULL THEN 0.0
+              ELSE (1 - vector_distance_cos(m.embedding, vector32(?)))
+            END
+          ) as combined_score
+        FROM memories m
+        WHERE
+    `
+  },
+
+  // User operations
+  users: {
+    getUniqueUsers: `
+      SELECT DISTINCT 
+        user_id,
+        COUNT(*) as memory_count,
+        MAX(created_at) as last_memory_date
+      FROM memories 
+      WHERE user_id IS NOT NULL AND is_deleted = 0
+      GROUP BY user_id
+      ORDER BY last_memory_date DESC
+    `,
+
+    countMemoriesForUser: 'SELECT COUNT(*) as total FROM memories WHERE user_id = ?',
+
+    deleteAllMemoriesForUser: 'DELETE FROM memories WHERE user_id = ?',
+
+    deleteHistoryForUser: 'DELETE FROM memory_history WHERE memory_id IN (SELECT id FROM memories WHERE user_id = ?)'
+  }
+} as const

src/main/services/urlschema/handle-providers.ts

@@ -1,7 +1,19 @@
+import { isMac } from '@main/constant'
 import Logger from 'electron-log'
 
 import { windowService } from '../WindowService'
 
+function ParseData(data: string) {
+  try {
+    const result = JSON.parse(Buffer.from(data, 'base64').toString('utf-8'))
+
+    return JSON.stringify(result)
+  } catch (error) {
+    Logger.error('ParseData error:', { error })
+    return null
+  }
+}
+
 export async function handleProvidersProtocolUrl(url: URL) {
   switch (url.pathname) {
     case '/api-keys': {
@@ -18,7 +30,13 @@ export async function handleProvidersProtocolUrl(url: URL) {
       // replace + and / to _ and - because + and / are processed by URLSearchParams
       const processedSearch = url.search.replaceAll('+', '_').replaceAll('/', '-')
       const params = new URLSearchParams(processedSearch)
-      const data = params.get('data')
+      const data = ParseData(params.get('data')?.replaceAll('_', '+').replaceAll('-', '/') || '')
+
+      if (!data) {
+        Logger.error('handleProvidersProtocolUrl data is null or invalid')
+        return
+      }
+
       const mainWindow = windowService.getMainWindow()
       const version = params.get('v')
       if (version == '1') {
@@ -32,9 +50,16 @@ export async function handleProvidersProtocolUrl(url: URL) {
         !mainWindow.isDestroyed() &&
         (await mainWindow.webContents.executeJavaScript(`typeof window.navigate === 'function'`))
       ) {
-        mainWindow.webContents.executeJavaScript(`window.navigate('/settings/provider?addProviderData=${data}')`)
+        mainWindow.webContents.executeJavaScript(
+          `window.navigate('/settings/provider?addProviderData=${encodeURIComponent(data)}')`
+        )
+
+        if (isMac) {
+          windowService.showMainWindow()
+        }
       } else {
         setTimeout(() => {
+          Logger.info('handleProvidersProtocolUrl timeout', { data, version })
           handleProvidersProtocolUrl(url)
         }, 1000)
       }

src/main/services/urlschema/mcp-install.ts

@@ -44,7 +44,9 @@ export function handleMcpProtocolUrl(url: URL) {
       //   }
       // }
       // cherrystudio://mcp/install?servers={base64Encode(JSON.stringify(jsonConfig))}
+
       const data = params.get('servers')
+
       if (data) {
         const stringify = Buffer.from(data, 'base64').toString('utf8')
         Logger.info('install MCP servers from urlschema: ', stringify)
@@ -63,10 +65,8 @@ export function handleMcpProtocolUrl(url: URL) {
         }
       }
 
-      const mainWindow = windowService.getMainWindow()
-      if (mainWindow && !mainWindow.isDestroyed()) {
-        mainWindow.webContents.executeJavaScript("window.navigate('/settings/mcp')")
-      }
+      windowService.getMainWindow()?.show()
+
       break
     }
     default:

src/main/utils/__tests__/file.test.ts

@@ -1,14 +1,19 @@
 import * as fs from 'node:fs'
+import * as fsPromises from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
 import { FileTypes } from '@types'
+import iconv from 'iconv-lite'
+import { detectAll as detectEncodingAll } from 'jschardet'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
+import { readTextFileWithAutoEncoding } from '../file'
 import { getAllFiles, getAppConfigDir, getConfigDir, getFilesDir, getFileType, getTempDir } from '../file'
 
 // Mock dependencies
 vi.mock('node:fs')
+vi.mock('node:fs/promises')
 vi.mock('node:os')
 vi.mock('node:path')
 vi.mock('uuid', () => ({
@@ -241,4 +246,54 @@ describe('file', () => {
       expect(appConfigDir).toBe('/mock/home/.cherrystudio/config/')
     })
   })
+
+  describe('readTextFileWithAutoEncoding', () => {
+    const mockFilePath = '/path/to/mock/file.txt'
+
+    it('should read file with auto encoding', async () => {
+      const content = '这是一段GB2312编码的测试内容'
+      const buffer = iconv.encode(content, 'GB2312')
+
+      // 创建模拟的 FileHandle 对象
+      const mockFileHandle = {
+        read: vi.fn().mockResolvedValue({
+          bytesRead: buffer.byteLength,
+          buffer: buffer
+        }),
+        close: vi.fn().mockResolvedValue(undefined)
+      }
+
+      // 模拟 open 方法
+      vi.spyOn(fsPromises, 'open').mockResolvedValue(mockFileHandle as any)
+      vi.spyOn(fsPromises, 'readFile').mockResolvedValue(buffer)
+
+      const result = await readTextFileWithAutoEncoding(mockFilePath)
+      expect(result).toBe(content)
+    })
+
+    it('should try to fix bad detected encoding', async () => {
+      const content = '这是一段GB2312编码的测试内容'
+      const buffer = iconv.encode(content, 'GB2312')
+
+      // 创建模拟的 FileHandle 对象
+      const mockFileHandle = {
+        read: vi.fn().mockResolvedValue({
+          bytesRead: buffer.byteLength,
+          buffer: buffer
+        }),
+        close: vi.fn().mockResolvedValue(undefined)
+      }
+
+      // 模拟 fs.open 方法
+      vi.spyOn(fsPromises, 'open').mockResolvedValue(mockFileHandle as any)
+      vi.spyOn(fsPromises, 'readFile').mockResolvedValue(buffer)
+      vi.mocked(vi.fn(detectEncodingAll)).mockReturnValue([
+        { encoding: 'UTF-8', confidence: 0.9 },
+        { encoding: 'GB2312', confidence: 0.8 }
+      ])
+
+      const result = await readTextFileWithAutoEncoding(mockFilePath)
+      expect(result).toBe(content)
+    })
+  })
 })

src/main/utils/file.ts

@@ -1,11 +1,15 @@
 import * as fs from 'node:fs'
+import { open, readFile } from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
 
 import { isLinux, isPortable } from '@main/constant'
-import { audioExts, documentExts, imageExts, textExts, videoExts } from '@shared/config/constant'
+import { audioExts, documentExts, imageExts, MB, textExts, videoExts } from '@shared/config/constant'
 import { FileMetadata, FileTypes } from '@types'
 import { app } from 'electron'
+import Logger from 'electron-log'
+import iconv from 'iconv-lite'
+import * as jschardet from 'jschardet'
 import { v4 as uuidv4 } from 'uuid'
 
 export function initAppDataDir() {
@@ -202,3 +206,53 @@ export function getCacheDir() {
 export function getAppConfigDir(name: string) {
   return path.join(getConfigDir(), name)
 }
+
+export function getMcpDir() {
+  return path.join(os.homedir(), '.cherrystudio', 'mcp')
+}
+
+/**
+ * 读取文件内容并自动检测编码格式进行解码
+ * @param filePath - 文件路径
+ * @returns 解码后的文件内容
+ */
+export async function readTextFileWithAutoEncoding(filePath: string): Promise<string> {
+  // 读取前1MB以检测编码
+  const buffer = Buffer.alloc(1 * MB)
+  const fh = await open(filePath, 'r')
+  const { buffer: bufferRead } = await fh.read(buffer, 0, 1 * MB, 0)
+  await fh.close()
+
+  // 获取文件编码格式，最多取前两个可能的编码
+  const encodings = jschardet
+    .detectAll(bufferRead)
+    .map((item) => ({
+      ...item,
+      encoding: item.encoding === 'ascii' ? 'UTF-8' : item.encoding
+    }))
+    .filter((item, index, array) => array.findIndex((prevItem) => prevItem.encoding === item.encoding) === index)
+    .slice(0, 2)
+
+  if (encodings.length === 0) {
+    Logger.error('Failed to detect encoding. Use utf-8 to decode.')
+    const data = await readFile(filePath)
+    return iconv.decode(data, 'UTF-8')
+  }
+
+  const data = await readFile(filePath)
+
+  for (const item of encodings) {
+    const encoding = item.encoding
+    const content = iconv.decode(data, encoding)
+    if (content.includes('\uFFFD')) {
+      Logger.error(
+        `File ${filePath} was auto-detected as ${encoding} encoding, but contains invalid characters. Trying other encodings`
+      )
+    } else {
+      return content
+    }
+  }
+
+  Logger.error(`File ${filePath} failed to decode with all possible encodings, trying UTF-8 encoding`)
+  return iconv.decode(data, 'UTF-8')
+}

src/main/utils/zoom.ts

@@ -1,26 +1,26 @@
-import { BrowserWindow } from 'electron'
-
-import { configManager } from '../services/ConfigManager'
-
-export function handleZoomFactor(wins: BrowserWindow[], delta: number, reset: boolean = false) {
-  if (reset) {
-    wins.forEach((win) => {
-      win.webContents.setZoomFactor(1)
-    })
-    configManager.setZoomFactor(1)
-    return
-  }
-
-  if (delta === 0) {
-    return
-  }
-
-  const currentZoom = configManager.getZoomFactor()
-  const newZoom = Number((currentZoom + delta).toFixed(1))
-  if (newZoom >= 0.5 && newZoom <= 2.0) {
-    wins.forEach((win) => {
-      win.webContents.setZoomFactor(newZoom)
-    })
-    configManager.setZoomFactor(newZoom)
-  }
-}
+import { BrowserWindow } from 'electron'
+
+import { configManager } from '../services/ConfigManager'
+
+export function handleZoomFactor(wins: BrowserWindow[], delta: number, reset: boolean = false) {
+  if (reset) {
+    wins.forEach((win) => {
+      win.webContents.setZoomFactor(1)
+    })
+    configManager.setZoomFactor(1)
+    return
+  }
+
+  if (delta === 0) {
+    return
+  }
+
+  const currentZoom = configManager.getZoomFactor()
+  const newZoom = Number((currentZoom + delta).toFixed(1))
+  if (newZoom >= 0.5 && newZoom <= 2.0) {
+    wins.forEach((win) => {
+      win.webContents.setZoomFactor(newZoom)
+    })
+    configManager.setZoomFactor(newZoom)
+  }
+}

src/preload/index.ts

@@ -3,13 +3,19 @@ import { electronAPI } from '@electron-toolkit/preload'
 import { UpgradeChannel } from '@shared/config/constant'
 import { IpcChannel } from '@shared/IpcChannel'
 import {
+  AddMemoryOptions,
+  AssistantMessage,
   FileListResponse,
   FileMetadata,
   FileUploadResponse,
   KnowledgeBaseParams,
   KnowledgeItem,
   MCPServer,
+  MemoryConfig,
+  MemoryListOptions,
+  MemorySearchOptions,
   Provider,
+  S3Config,
   Shortcut,
   ThemeMode,
   WebDavConfig
@@ -72,9 +78,9 @@ const api = {
     decompress: (text: Buffer) => ipcRenderer.invoke(IpcChannel.Zip_Decompress, text)
   },
   backup: {
-    backup: (fileName: string, data: string, destinationPath?: string, skipBackupFile?: boolean) =>
-      ipcRenderer.invoke(IpcChannel.Backup_Backup, fileName, data, destinationPath, skipBackupFile),
-    restore: (backupPath: string) => ipcRenderer.invoke(IpcChannel.Backup_Restore, backupPath),
+    backup: (filename: string, content: string, path: string, skipBackupFile: boolean) =>
+      ipcRenderer.invoke(IpcChannel.Backup_Backup, filename, content, path, skipBackupFile),
+    restore: (path: string) => ipcRenderer.invoke(IpcChannel.Backup_Restore, path),
     backupToWebdav: (data: string, webdavConfig: WebDavConfig) =>
       ipcRenderer.invoke(IpcChannel.Backup_BackupToWebdav, data, webdavConfig),
     restoreFromWebdav: (webdavConfig: WebDavConfig) =>
@@ -86,14 +92,36 @@ const api = {
     createDirectory: (webdavConfig: WebDavConfig, path: string, options?: CreateDirectoryOptions) =>
       ipcRenderer.invoke(IpcChannel.Backup_CreateDirectory, webdavConfig, path, options),
     deleteWebdavFile: (fileName: string, webdavConfig: WebDavConfig) =>
-      ipcRenderer.invoke(IpcChannel.Backup_DeleteWebdavFile, fileName, webdavConfig)
+      ipcRenderer.invoke(IpcChannel.Backup_DeleteWebdavFile, fileName, webdavConfig),
+    backupToLocalDir: (
+      data: string,
+      fileName: string,
+      localConfig: { localBackupDir?: string; skipBackupFile?: boolean }
+    ) => ipcRenderer.invoke(IpcChannel.Backup_BackupToLocalDir, data, fileName, localConfig),
+    restoreFromLocalBackup: (fileName: string, localBackupDir?: string) =>
+      ipcRenderer.invoke(IpcChannel.Backup_RestoreFromLocalBackup, fileName, localBackupDir),
+    listLocalBackupFiles: (localBackupDir?: string) =>
+      ipcRenderer.invoke(IpcChannel.Backup_ListLocalBackupFiles, localBackupDir),
+    deleteLocalBackupFile: (fileName: string, localBackupDir?: string) =>
+      ipcRenderer.invoke(IpcChannel.Backup_DeleteLocalBackupFile, fileName, localBackupDir),
+    setLocalBackupDir: (dirPath: string) => ipcRenderer.invoke(IpcChannel.Backup_SetLocalBackupDir, dirPath),
+    checkWebdavConnection: (webdavConfig: WebDavConfig) =>
+      ipcRenderer.invoke(IpcChannel.Backup_CheckConnection, webdavConfig),
+
+    backupToS3: (data: string, s3Config: S3Config) => ipcRenderer.invoke(IpcChannel.Backup_BackupToS3, data, s3Config),
+    restoreFromS3: (s3Config: S3Config) => ipcRenderer.invoke(IpcChannel.Backup_RestoreFromS3, s3Config),
+    listS3Files: (s3Config: S3Config) => ipcRenderer.invoke(IpcChannel.Backup_ListS3Files, s3Config),
+    deleteS3File: (fileName: string, s3Config: S3Config) =>
+      ipcRenderer.invoke(IpcChannel.Backup_DeleteS3File, fileName, s3Config),
+    checkS3Connection: (s3Config: S3Config) => ipcRenderer.invoke(IpcChannel.Backup_CheckS3Connection, s3Config)
   },
   file: {
     select: (options?: OpenDialogOptions) => ipcRenderer.invoke(IpcChannel.File_Select, options),
     upload: (file: FileMetadata) => ipcRenderer.invoke(IpcChannel.File_Upload, file),
     delete: (fileId: string) => ipcRenderer.invoke(IpcChannel.File_Delete, fileId),
     deleteDir: (dirPath: string) => ipcRenderer.invoke(IpcChannel.File_DeleteDir, dirPath),
-    read: (fileId: string) => ipcRenderer.invoke(IpcChannel.File_Read, fileId),
+    read: (fileId: string, detectEncoding?: boolean) =>
+      ipcRenderer.invoke(IpcChannel.File_Read, fileId, detectEncoding),
     clear: () => ipcRenderer.invoke(IpcChannel.File_Clear),
     get: (filePath: string) => ipcRenderer.invoke(IpcChannel.File_Get, filePath),
     /**
@@ -124,7 +152,8 @@ const api = {
     copy: (fileId: string, destPath: string) => ipcRenderer.invoke(IpcChannel.File_Copy, fileId, destPath),
     base64File: (fileId: string) => ipcRenderer.invoke(IpcChannel.File_Base64File, fileId),
     pdfInfo: (fileId: string) => ipcRenderer.invoke(IpcChannel.File_GetPdfInfo, fileId),
-    getPathForFile: (file: File) => webUtils.getPathForFile(file)
+    getPathForFile: (file: File) => webUtils.getPathForFile(file),
+    openFileWithRelativePath: (file: FileMetadata) => ipcRenderer.invoke(IpcChannel.File_OpenWithRelativePath, file)
   },
   fs: {
     read: (pathOrUrl: string, encoding?: BufferEncoding) => ipcRenderer.invoke(IpcChannel.Fs_Read, pathOrUrl, encoding)
@@ -160,6 +189,22 @@ const api = {
     checkQuota: ({ base, userId }: { base: KnowledgeBaseParams; userId: string }) =>
       ipcRenderer.invoke(IpcChannel.KnowledgeBase_Check_Quota, base, userId)
   },
+  memory: {
+    add: (messages: string | AssistantMessage[], options?: AddMemoryOptions) =>
+      ipcRenderer.invoke(IpcChannel.Memory_Add, messages, options),
+    search: (query: string, options: MemorySearchOptions) =>
+      ipcRenderer.invoke(IpcChannel.Memory_Search, query, options),
+    list: (options?: MemoryListOptions) => ipcRenderer.invoke(IpcChannel.Memory_List, options),
+    delete: (id: string) => ipcRenderer.invoke(IpcChannel.Memory_Delete, id),
+    update: (id: string, memory: string, metadata?: Record<string, any>) =>
+      ipcRenderer.invoke(IpcChannel.Memory_Update, id, memory, metadata),
+    get: (id: string) => ipcRenderer.invoke(IpcChannel.Memory_Get, id),
+    setConfig: (config: MemoryConfig) => ipcRenderer.invoke(IpcChannel.Memory_SetConfig, config),
+    deleteUser: (userId: string) => ipcRenderer.invoke(IpcChannel.Memory_DeleteUser, userId),
+    deleteAllMemoriesForUser: (userId: string) =>
+      ipcRenderer.invoke(IpcChannel.Memory_DeleteAllMemoriesForUser, userId),
+    getUsersList: () => ipcRenderer.invoke(IpcChannel.Memory_GetUsersList)
+  },
   window: {
     setMinimumSize: (width: number, height: number) =>
       ipcRenderer.invoke(IpcChannel.Windows_SetMinimumSize, width, height),
@@ -206,8 +251,8 @@ const api = {
     restartServer: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_RestartServer, server),
     stopServer: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_StopServer, server),
     listTools: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_ListTools, server),
-    callTool: ({ server, name, args }: { server: MCPServer; name: string; args: any }) =>
-      ipcRenderer.invoke(IpcChannel.Mcp_CallTool, { server, name, args }),
+    callTool: ({ server, name, args, callId }: { server: MCPServer; name: string; args: any; callId?: string }) =>
+      ipcRenderer.invoke(IpcChannel.Mcp_CallTool, { server, name, args, callId }),
     listPrompts: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_ListPrompts, server),
     getPrompt: ({ server, name, args }: { server: MCPServer; name: string; args?: Record<string, any> }) =>
       ipcRenderer.invoke(IpcChannel.Mcp_GetPrompt, { server, name, args }),
@@ -215,7 +260,14 @@ const api = {
     getResource: ({ server, uri }: { server: MCPServer; uri: string }) =>
       ipcRenderer.invoke(IpcChannel.Mcp_GetResource, { server, uri }),
     getInstallInfo: () => ipcRenderer.invoke(IpcChannel.Mcp_GetInstallInfo),
-    checkMcpConnectivity: (server: any) => ipcRenderer.invoke(IpcChannel.Mcp_CheckConnectivity, server)
+    checkMcpConnectivity: (server: any) => ipcRenderer.invoke(IpcChannel.Mcp_CheckConnectivity, server),
+    uploadDxt: async (file: File) => {
+      const buffer = await file.arrayBuffer()
+      return ipcRenderer.invoke(IpcChannel.Mcp_UploadDxt, buffer, file.name)
+    },
+    abortTool: (callId: string) => ipcRenderer.invoke(IpcChannel.Mcp_AbortTool, callId),
+    setProgress: (progress: number) => ipcRenderer.invoke(IpcChannel.Mcp_SetProgress, progress),
+    getServerVersion: (server: MCPServer) => ipcRenderer.invoke(IpcChannel.Mcp_GetServerVersion, server)
   },
   python: {
     execute: (script: string, context?: Record<string, any>, timeout?: number) =>
@@ -285,12 +337,15 @@ const api = {
       ipcRenderer.invoke(IpcChannel.Selection_SetRemeberWinSize, isRemeberWinSize),
     setFilterMode: (filterMode: string) => ipcRenderer.invoke(IpcChannel.Selection_SetFilterMode, filterMode),
     setFilterList: (filterList: string[]) => ipcRenderer.invoke(IpcChannel.Selection_SetFilterList, filterList),
-    processAction: (actionItem: ActionItem) => ipcRenderer.invoke(IpcChannel.Selection_ProcessAction, actionItem),
+    processAction: (actionItem: ActionItem, isFullScreen: boolean = false) =>
+      ipcRenderer.invoke(IpcChannel.Selection_ProcessAction, actionItem, isFullScreen),
     closeActionWindow: () => ipcRenderer.invoke(IpcChannel.Selection_ActionWindowClose),
     minimizeActionWindow: () => ipcRenderer.invoke(IpcChannel.Selection_ActionWindowMinimize),
     pinActionWindow: (isPinned: boolean) => ipcRenderer.invoke(IpcChannel.Selection_ActionWindowPin, isPinned)
   },
-  quoteToMainWindow: (text: string) => ipcRenderer.invoke(IpcChannel.App_QuoteToMain, text)
+  quoteToMainWindow: (text: string) => ipcRenderer.invoke(IpcChannel.App_QuoteToMain, text),
+  setDisableHardwareAcceleration: (isDisable: boolean) =>
+    ipcRenderer.invoke(IpcChannel.App_SetDisableHardwareAcceleration, isDisable)
 }
 
 // Use `contextBridge` APIs to expose Electron APIs to

src/renderer/index.html

@@ -1,46 +1,45 @@
 <!doctype html>
 <html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="initial-scale=1, width=device-width" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; connect-src blob: *; script-src 'self' 'unsafe-eval' 'unsafe-inline' *; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' *; font-src 'self' data: *; img-src 'self' data: file: * blob:; frame-src * file:" />
+    <title>Cherry Studio</title>
 
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="initial-scale=1, width=device-width" />
-  <meta http-equiv="Content-Security-Policy"
-    content="default-src 'self'; connect-src blob: *; script-src 'self' 'unsafe-eval' 'unsafe-inline' *; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' *; font-src 'self' data: *; img-src 'self' data: file: * blob:; frame-src * file:" />
-  <title>Cherry Studio</title>
+    <style>
+      html,
+      body {
+        margin: 0;
+      }
 
-  <style>
-    html,
-    body {
-      margin: 0;
-    }
+      #spinner {
+        position: fixed;
+        width: 100vw;
+        height: 100vh;
+        flex-direction: row;
+        justify-content: center;
+        align-items: center;
+        display: flex;
+      }
 
-    #spinner {
-      position: fixed;
-      width: 100vw;
-      height: 100vh;
-      flex-direction: row;
-      justify-content: center;
-      align-items: center;
-      display: flex;
-    }
+      #spinner img {
+        width: 100px;
+        border-radius: 50px;
+      }
+    </style>
+  </head>
 
-    #spinner img {
-      width: 100px;
-      border-radius: 50px;
-    }
-  </style>
-</head>
-
-<body>
-  <div id="root"></div>
-  <div id="spinner">
-    <img src="/src/assets/images/logo.png" />
-  </div>
-  <script>
-    console.time('init')
-  </script>
-  <script type="module" src="/src/init.ts"></script>
-  <script type="module" src="/src/entryPoint.tsx"></script>
-</body>
-
-</html>
+  <body>
+    <div id="root"></div>
+    <div id="spinner">
+      <img src="/src/assets/images/logo.png" />
+    </div>
+    <script>
+      console.time('init')
+    </script>
+    <script type="module" src="/src/init.ts"></script>
+    <script type="module" src="/src/entryPoint.tsx"></script>
+  </body>
+</html>

src/renderer/miniWindow.html

@@ -1,24 +1,23 @@
 <!doctype html>
 <html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="initial-scale=1, width=device-width" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; connect-src blob: *; script-src 'self' 'unsafe-eval' *; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' *; font-src 'self' data: *; img-src 'self' data: file: * blob:; frame-src * file:" />
+    <title>Cherry Studio</title>
 
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="initial-scale=1, width=device-width" />
-  <meta http-equiv="Content-Security-Policy"
-    content="default-src 'self'; connect-src blob: *; script-src 'self' 'unsafe-eval' *; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' *; font-src 'self' data: *; img-src 'self' data: file: * blob:; frame-src * file:" />
-  <title>Cherry Studio</title>
+    <style>
+      html,
+      body {
+        margin: 0;
+      }
+    </style>
+  </head>
 
-  <style>
-    html,
-    body {
-      margin: 0;
-    }
-  </style>
-</head>
-
-<body>
-  <div id="root"></div>
-  <script type="module" src="/src/windows/mini/entryPoint.tsx"></script>
-</body>
-
-</html>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/windows/mini/entryPoint.tsx"></script>
+  </body>
+</html>

src/renderer/selectionAction.html

@@ -1,41 +1,39 @@
 <!doctype html>
 <html lang="zh-CN">
-
-<head>
+  <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="initial-scale=1, width=device-width" />
-    <meta http-equiv="Content-Security-Policy"
-        content="default-src 'self'; connect-src blob: *; script-src 'self' 'unsafe-eval' *; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' *; font-src 'self' data: *; img-src 'self' data: file: * blob:; frame-src * file:" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; connect-src blob: *; script-src 'self' 'unsafe-eval' *; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' *; font-src 'self' data: *; img-src 'self' data: file: * blob:; frame-src * file:" />
     <title>Cherry Studio Selection Assistant</title>
+  </head>
 
-</head>
-
-<body>
+  <body>
     <div id="root"></div>
     <script type="module" src="/src/windows/selection/action/entryPoint.tsx"></script>
     <style>
-        html {
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
+      html {
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
 
-        body {
-            width: 100vw;
-            height: 100vh;
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
+      body {
+        width: 100vw;
+        height: 100vh;
+        margin: 0;
+        padding: 0;
+        box-sizing: border-box;
+      }
 
-        #root {
-            margin: 0;
-            padding: 0;
-            width: 100%;
-            height: 100%;
-            box-sizing: border-box;
-        }
+      #root {
+        margin: 0;
+        padding: 0;
+        width: 100%;
+        height: 100%;
+        box-sizing: border-box;
+      }
     </style>
-</body>
-
-</html>
+  </body>
+</html>

src/renderer/selectionToolbar.html

@@ -1,46 +1,43 @@
 <!doctype html>
 <html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="initial-scale=1, width=device-width" />
+    <meta
+      http-equiv="Content-Security-Policy"
+      content="default-src 'self'; connect-src blob: *; script-src 'self' 'unsafe-eval' *; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' *; font-src 'self' data: *; img-src 'self' data: file: * blob:; frame-src * file:" />
+    <title>Cherry Studio Selection Toolbar</title>
+  </head>
 
-<head>
-  <meta charset="UTF-8" />
-  <meta name="viewport" content="initial-scale=1, width=device-width" />
-  <meta http-equiv="Content-Security-Policy"
-    content="default-src 'self'; connect-src blob: *; script-src 'self' 'unsafe-eval' *; worker-src 'self' blob:; style-src 'self' 'unsafe-inline' *; font-src 'self' data: *; img-src 'self' data: file: * blob:; frame-src * file:" />
-  <title>Cherry Studio Selection Toolbar</title>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/windows/selection/toolbar/entryPoint.tsx"></script>
+    <style>
+      html {
+        margin: 0 !important;
+        background-color: transparent !important;
+        background-image: none !important;
+      }
 
-</head>
+      body {
+        margin: 0 !important;
+        padding: 0 !important;
+        overflow: hidden !important;
+        width: 100vw !important;
+        height: 100vh !important;
 
-<body>
-  <div id="root"></div>
-  <script type="module" src="/src/windows/selection/toolbar/entryPoint.tsx"></script>
-  <style>
-    html {
-      margin: 0 !important;
-      background-color: transparent !important;
-      background-image: none !important;
+        -webkit-user-select: none;
+        -moz-user-select: none;
+        -ms-user-select: none;
+        user-select: none;
+      }
 
-    }
-
-    body {
-      margin: 0 !important;
-      padding: 0 !important;
-      overflow: hidden !important;
-      width: 100vw !important;
-      height: 100vh !important;
-
-      -webkit-user-select: none;
-      -moz-user-select: none;
-      -ms-user-select: none;
-      user-select: none;
-    }
-
-    #root {
-      margin: 0 !important;
-      padding: 0 !important;
-      width: max-content !important;
-      height: fit-content !important;
-    }
-  </style>
-</body>
-
-</html>
+      #root {
+        margin: 0 !important;
+        padding: 0 !important;
+        width: max-content !important;
+        height: fit-content !important;
+      }
+    </style>
+  </body>
+</html>

src/renderer/src/aiCore/clients/AihubmixAPIClient.ts

@@ -103,7 +103,12 @@ export class AihubmixAPIClient extends BaseApiClient {
     }
 
     // gemini开头 且不以-nothink、-search结尾
-    if ((id.startsWith('gemini') || id.startsWith('imagen')) && !id.endsWith('-nothink') && !id.endsWith('-search')) {
+    if (
+      (id.startsWith('gemini') || id.startsWith('imagen')) &&
+      !id.endsWith('-nothink') &&
+      !id.endsWith('-search') &&
+      !id.includes('embedding')
+    ) {
       const client = this.clients.get('gemini')
       if (!client || !this.isValidClient(client)) {
         throw new Error('Gemini client not properly initialized')

src/renderer/src/aiCore/clients/ApiClientFactory.ts

@@ -47,10 +47,9 @@ export class ApiClientFactory {
     // 然后检查标准的provider type
     switch (provider.type) {
       case 'openai':
-      case 'azure-openai':
-        console.log(`[ApiClientFactory] Creating OpenAIApiClient for provider: ${provider.id}`)
         instance = new OpenAIAPIClient(provider) as BaseApiClient
         break
+      case 'azure-openai':
       case 'openai-response':
         instance = new OpenAIResponseAPIClient(provider) as BaseApiClient
         break
@@ -73,6 +72,7 @@ export class ApiClientFactory {
   }
 }
 
-export function isOpenAIProvider(provider: Provider) {
-  return !['anthropic', 'gemini'].includes(provider.type)
-}
+// 移除这个函数，它已经移动到 utils/index.ts
+// export function isOpenAIProvider(provider: Provider) {
+//   return !['anthropic', 'gemini'].includes(provider.type)
+// }

src/renderer/src/aiCore/clients/BaseApiClient.ts

@@ -1,6 +1,7 @@
 import {
   isFunctionCallingModel,
   isNotSupportTemperatureAndTopP,
+  isOpenAIDeepResearchModel,
   isOpenAIModel,
   isSupportedFlexServiceTier
 } from '@renderer/config/models'
@@ -16,6 +17,7 @@ import {
   MCPCallToolResponse,
   MCPTool,
   MCPToolResponse,
+  MemoryItem,
   Model,
   OpenAIServiceTier,
   Provider,
@@ -37,7 +39,7 @@ import {
 } from '@renderer/types/sdk'
 import { isJSON, parseJSON } from '@renderer/utils'
 import { addAbortController, removeAbortController } from '@renderer/utils/abortController'
-import { findFileBlocks, getContentWithTools, getMainTextContent } from '@renderer/utils/messageUtils/find'
+import { findFileBlocks, getMainTextContent } from '@renderer/utils/messageUtils/find'
 import { defaultTimeout } from '@shared/config/constant'
 import Logger from 'electron-log/renderer'
 import { isEmpty } from 'lodash'
@@ -205,11 +207,14 @@ export abstract class BaseApiClient<
     if (isSupportedFlexServiceTier(model)) {
       return 15 * 1000 * 60
     }
+    if (isOpenAIDeepResearchModel(model)) {
+      return 60 * 1000 * 60
+    }
     return defaultTimeout
   }
 
   public async getMessageContent(message: Message): Promise<string> {
-    const content = getContentWithTools(message)
+    const content = getMainTextContent(message)
 
     if (isEmpty(content)) {
       return ''
@@ -217,6 +222,7 @@ export abstract class BaseApiClient<
 
     const webSearchReferences = await this.getWebSearchReferencesFromCache(message)
     const knowledgeReferences = await this.getKnowledgeBaseReferencesFromCache(message)
+    const memoryReferences = this.getMemoryReferencesFromCache(message)
 
     // 添加偏移量以避免ID冲突
     const reindexedKnowledgeReferences = knowledgeReferences.map((ref) => ({
@@ -224,7 +230,7 @@ export abstract class BaseApiClient<
       id: ref.id + webSearchReferences.length // 为知识库引用的ID添加网络搜索引用的数量作为偏移量
     }))
 
-    const allReferences = [...webSearchReferences, ...reindexedKnowledgeReferences]
+    const allReferences = [...webSearchReferences, ...reindexedKnowledgeReferences, ...memoryReferences]
 
     Logger.log(`Found ${allReferences.length} references for ID: ${message.id}`, allReferences)
 
@@ -254,7 +260,7 @@ export abstract class BaseApiClient<
 
         for (const fileBlock of textFileBlocks) {
           const file = fileBlock.file
-          const fileContent = (await window.api.file.read(file.id + file.ext)).trim()
+          const fileContent = (await window.api.file.read(file.id + file.ext, true)).trim()
           const fileNameRow = 'file: ' + file.origin_name + '\n\n'
           text = text + fileNameRow + fileContent + divider
         }
@@ -266,6 +272,20 @@ export abstract class BaseApiClient<
     return ''
   }
 
+  private getMemoryReferencesFromCache(message: Message) {
+    const memories = window.keyv.get(`memory-search-${message.id}`) as MemoryItem[] | undefined
+    if (memories) {
+      const memoryReferences: KnowledgeReference[] = memories.map((mem, index) => ({
+        id: index + 1,
+        content: `${mem.memory} -- Created at: ${mem.createdAt}`,
+        sourceUrl: '',
+        type: 'memory'
+      }))
+      return memoryReferences
+    }
+    return []
+  }
+
   private async getWebSearchReferencesFromCache(message: Message) {
     const content = getMainTextContent(message)
     if (isEmpty(content)) {

src/renderer/src/aiCore/clients/NewAPIClient.ts

@@ -106,7 +106,7 @@ export class NewAPIClient extends BaseApiClient {
       return client
     }
 
-    if (model.endpoint_type === 'openai') {
+    if (model.endpoint_type === 'openai' || model.endpoint_type === 'image-generation') {
       const client = this.clients.get('openai')
       if (!client || !this.isValidClient(client)) {
         throw new Error('Failed to get openai client')

src/renderer/src/aiCore/clients/__tests__/ApiClientFactory.test.ts

@@ -0,0 +1,208 @@
+import { Provider } from '@renderer/types'
+import { isOpenAIProvider } from '@renderer/utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { AihubmixAPIClient } from '../AihubmixAPIClient'
+import { AnthropicAPIClient } from '../anthropic/AnthropicAPIClient'
+import { ApiClientFactory } from '../ApiClientFactory'
+import { GeminiAPIClient } from '../gemini/GeminiAPIClient'
+import { VertexAPIClient } from '../gemini/VertexAPIClient'
+import { NewAPIClient } from '../NewAPIClient'
+import { OpenAIAPIClient } from '../openai/OpenAIApiClient'
+import { OpenAIResponseAPIClient } from '../openai/OpenAIResponseAPIClient'
+import { PPIOAPIClient } from '../ppio/PPIOAPIClient'
+
+// 为工厂测试创建最小化 provider 的辅助函数
+// ApiClientFactory 只使用 'id' 和 'type' 字段来决定创建哪个客户端
+// 其他字段会传递给客户端构造函数，但不影响工厂逻辑
+const createTestProvider = (id: string, type: string): Provider => ({
+  id,
+  type: type as Provider['type'],
+  name: '',
+  apiKey: '',
+  apiHost: '',
+  models: []
+})
+
+// Mock 所有客户端模块
+vi.mock('../AihubmixAPIClient', () => ({
+  AihubmixAPIClient: vi.fn().mockImplementation(() => ({}))
+}))
+vi.mock('../anthropic/AnthropicAPIClient', () => ({
+  AnthropicAPIClient: vi.fn().mockImplementation(() => ({}))
+}))
+vi.mock('../gemini/GeminiAPIClient', () => ({
+  GeminiAPIClient: vi.fn().mockImplementation(() => ({}))
+}))
+vi.mock('../gemini/VertexAPIClient', () => ({
+  VertexAPIClient: vi.fn().mockImplementation(() => ({}))
+}))
+vi.mock('../NewAPIClient', () => ({
+  NewAPIClient: vi.fn().mockImplementation(() => ({}))
+}))
+vi.mock('../openai/OpenAIApiClient', () => ({
+  OpenAIAPIClient: vi.fn().mockImplementation(() => ({}))
+}))
+vi.mock('../openai/OpenAIResponseAPIClient', () => ({
+  OpenAIResponseAPIClient: vi.fn().mockImplementation(() => ({
+    getClient: vi.fn().mockReturnThis()
+  }))
+}))
+vi.mock('../ppio/PPIOAPIClient', () => ({
+  PPIOAPIClient: vi.fn().mockImplementation(() => ({}))
+}))
+
+describe('ApiClientFactory', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('create', () => {
+    // 测试特殊 ID 的客户端创建
+    it('should create AihubmixAPIClient for aihubmix provider', () => {
+      const provider = createTestProvider('aihubmix', 'openai')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(AihubmixAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    it('should create NewAPIClient for new-api provider', () => {
+      const provider = createTestProvider('new-api', 'openai')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(NewAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    it('should create PPIOAPIClient for ppio provider', () => {
+      const provider = createTestProvider('ppio', 'openai')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(PPIOAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    // 测试标准类型的客户端创建
+    it('should create OpenAIAPIClient for openai type', () => {
+      const provider = createTestProvider('custom-openai', 'openai')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(OpenAIAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    it('should create OpenAIResponseAPIClient for azure-openai type', () => {
+      const provider = createTestProvider('azure-openai', 'azure-openai')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(OpenAIResponseAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    it('should create OpenAIResponseAPIClient for openai-response type', () => {
+      const provider = createTestProvider('response', 'openai-response')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(OpenAIResponseAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    it('should create GeminiAPIClient for gemini type', () => {
+      const provider = createTestProvider('gemini', 'gemini')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(GeminiAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    it('should create VertexAPIClient for vertexai type', () => {
+      const provider = createTestProvider('vertex', 'vertexai')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(VertexAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    it('should create AnthropicAPIClient for anthropic type', () => {
+      const provider = createTestProvider('anthropic', 'anthropic')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(AnthropicAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    // 测试默认情况
+    it('should create OpenAIAPIClient as default for unknown type', () => {
+      const provider = createTestProvider('unknown', 'unknown-type')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(OpenAIAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    // 测试边界条件
+    it('should handle provider with minimal configuration', () => {
+      const provider = createTestProvider('minimal', 'openai')
+
+      const client = ApiClientFactory.create(provider)
+
+      expect(OpenAIAPIClient).toHaveBeenCalledWith(provider)
+      expect(client).toBeDefined()
+    })
+
+    // 测试特殊 ID 优先级高于类型
+    it('should prioritize special ID over type', () => {
+      const provider = createTestProvider('aihubmix', 'anthropic') // 即使类型是 anthropic
+
+      const client = ApiClientFactory.create(provider)
+
+      // 应该创建 AihubmixAPIClient 而不是 AnthropicAPIClient
+      expect(AihubmixAPIClient).toHaveBeenCalledWith(provider)
+      expect(AnthropicAPIClient).not.toHaveBeenCalled()
+      expect(client).toBeDefined()
+    })
+  })
+
+  describe('isOpenAIProvider', () => {
+    it('should return true for openai type', () => {
+      const provider = createTestProvider('openai', 'openai')
+      expect(isOpenAIProvider(provider)).toBe(true)
+    })
+
+    it('should return true for azure-openai type', () => {
+      const provider = createTestProvider('azure-openai', 'azure-openai')
+      expect(isOpenAIProvider(provider)).toBe(true)
+    })
+
+    it('should return true for unknown type (fallback to OpenAI)', () => {
+      const provider = createTestProvider('unknown', 'unknown')
+      expect(isOpenAIProvider(provider)).toBe(true)
+    })
+
+    it('should return false for vertexai type', () => {
+      const provider = createTestProvider('vertex', 'vertexai')
+      expect(isOpenAIProvider(provider)).toBe(false)
+    })
+
+    it('should return false for anthropic type', () => {
+      const provider = createTestProvider('anthropic', 'anthropic')
+      expect(isOpenAIProvider(provider)).toBe(false)
+    })
+
+    it('should return false for gemini type', () => {
+      const provider = createTestProvider('gemini', 'gemini')
+      expect(isOpenAIProvider(provider)).toBe(false)
+    })
+  })
+})

src/renderer/src/aiCore/clients/anthropic/AnthropicAPIClient.ts

@@ -49,10 +49,10 @@ import {
   LLMWebSearchCompleteChunk,
   LLMWebSearchInProgressChunk,
   MCPToolCreatedChunk,
-  TextCompleteChunk,
   TextDeltaChunk,
-  ThinkingCompleteChunk,
-  ThinkingDeltaChunk
+  TextStartChunk,
+  ThinkingDeltaChunk,
+  ThinkingStartChunk
 } from '@renderer/types/chunk'
 import { type Message } from '@renderer/types/newMessage'
 import {
@@ -231,7 +231,7 @@ export class AnthropicAPIClient extends BaseApiClient<
             }
           })
         } else {
-          const fileContent = await (await window.api.file.read(file.id + file.ext)).trim()
+          const fileContent = await (await window.api.file.read(file.id + file.ext, true)).trim()
           parts.push({
             type: 'text',
             text: file.origin_name + '\n' + fileContent
@@ -519,15 +519,23 @@ export class AnthropicAPIClient extends BaseApiClient<
     return () => {
       let accumulatedJson = ''
       const toolCalls: Record<number, ToolUseBlock> = {}
-      const ChunkIdTypeMap: Record<number, ChunkType> = {}
       return {
         async transform(rawChunk: AnthropicSdkRawChunk, controller: TransformStreamDefaultController<GenericChunk>) {
           switch (rawChunk.type) {
             case 'message': {
               let i = 0
+              let hasTextContent = false
+              let hasThinkingContent = false
+
               for (const content of rawChunk.content) {
                 switch (content.type) {
                   case 'text': {
+                    if (!hasTextContent) {
+                      controller.enqueue({
+                        type: ChunkType.TEXT_START
+                      } as TextStartChunk)
+                      hasTextContent = true
+                    }
                     controller.enqueue({
                       type: ChunkType.TEXT_DELTA,
                       text: content.text
@@ -540,6 +548,12 @@ export class AnthropicAPIClient extends BaseApiClient<
                     break
                   }
                   case 'thinking': {
+                    if (!hasThinkingContent) {
+                      controller.enqueue({
+                        type: ChunkType.THINKING_START
+                      } as ThinkingStartChunk)
+                      hasThinkingContent = true
+                    }
                     controller.enqueue({
                       type: ChunkType.THINKING_DELTA,
                       text: content.thinking
@@ -615,16 +629,16 @@ export class AnthropicAPIClient extends BaseApiClient<
                   break
                 }
                 case 'text': {
-                  if (!ChunkIdTypeMap[rawChunk.index]) {
-                    ChunkIdTypeMap[rawChunk.index] = ChunkType.TEXT_DELTA // 用textdelta代表文本块
-                  }
+                  controller.enqueue({
+                    type: ChunkType.TEXT_START
+                  } as TextStartChunk)
                   break
                 }
                 case 'thinking':
                 case 'redacted_thinking': {
-                  if (!ChunkIdTypeMap[rawChunk.index]) {
-                    ChunkIdTypeMap[rawChunk.index] = ChunkType.THINKING_DELTA // 用thinkingdelta代表思考块
-                  }
+                  controller.enqueue({
+                    type: ChunkType.THINKING_START
+                  } as ThinkingStartChunk)
                   break
                 }
               }
@@ -661,15 +675,6 @@ export class AnthropicAPIClient extends BaseApiClient<
               break
             }
             case 'content_block_stop': {
-              if (ChunkIdTypeMap[rawChunk.index] === ChunkType.TEXT_DELTA) {
-                controller.enqueue({
-                  type: ChunkType.TEXT_COMPLETE
-                } as TextCompleteChunk)
-              } else if (ChunkIdTypeMap[rawChunk.index] === ChunkType.THINKING_DELTA) {
-                controller.enqueue({
-                  type: ChunkType.THINKING_COMPLETE
-                } as ThinkingCompleteChunk)
-              }
               const toolCall = toolCalls[rawChunk.index]
               if (toolCall) {
                 try {

src/renderer/src/aiCore/clients/gemini/GeminiAPIClient.ts

@@ -41,7 +41,7 @@ import {
   ToolCallResponse,
   WebSearchSource
 } from '@renderer/types'
-import { ChunkType, LLMWebSearchCompleteChunk } from '@renderer/types/chunk'
+import { ChunkType, LLMWebSearchCompleteChunk, TextStartChunk, ThinkingStartChunk } from '@renderer/types/chunk'
 import { Message } from '@renderer/types/newMessage'
 import {
   GeminiOptions,
@@ -288,7 +288,7 @@ export class GeminiAPIClient extends BaseApiClient<
         continue
       }
       if ([FileTypes.TEXT, FileTypes.DOCUMENT].includes(file.type)) {
-        const fileContent = await (await window.api.file.read(file.id + file.ext)).trim()
+        const fileContent = await (await window.api.file.read(file.id + file.ext, true)).trim()
         parts.push({
           text: file.origin_name + '\n' + fileContent
         })
@@ -443,7 +443,7 @@ export class GeminiAPIClient extends BaseApiClient<
         messages: GeminiSdkMessageParam[]
         metadata: Record<string, any>
       }> => {
-        const { messages, mcpTools, maxTokens, enableWebSearch, enableGenerateImage } = coreRequest
+        const { messages, mcpTools, maxTokens, enableWebSearch, enableUrlContext, enableGenerateImage } = coreRequest
         // 1. 处理系统消息
         let systemInstruction = assistant.prompt
 
@@ -483,6 +483,12 @@ export class GeminiAPIClient extends BaseApiClient<
           })
         }
 
+        if (enableUrlContext) {
+          tools.push({
+            urlContext: {}
+          })
+        }
+
         if (isGemmaModel(model) && assistant.prompt) {
           const isFirstMessage = history.length === 0
           if (isFirstMessage && messageContents) {
@@ -547,20 +553,34 @@ export class GeminiAPIClient extends BaseApiClient<
   }
 
   getResponseChunkTransformer(): ResponseChunkTransformer<GeminiSdkRawChunk> {
+    const toolCalls: FunctionCall[] = []
+    let isFirstTextChunk = true
+    let isFirstThinkingChunk = true
     return () => ({
       async transform(chunk: GeminiSdkRawChunk, controller: TransformStreamDefaultController<GenericChunk>) {
-        const toolCalls: FunctionCall[] = []
         if (chunk.candidates && chunk.candidates.length > 0) {
           for (const candidate of chunk.candidates) {
             if (candidate.content) {
               candidate.content.parts?.forEach((part) => {
                 const text = part.text || ''
                 if (part.thought) {
+                  if (isFirstThinkingChunk) {
+                    controller.enqueue({
+                      type: ChunkType.THINKING_START
+                    } as ThinkingStartChunk)
+                    isFirstThinkingChunk = false
+                  }
                   controller.enqueue({
                     type: ChunkType.THINKING_DELTA,
                     text: text
                   })
                 } else if (part.text) {
+                  if (isFirstTextChunk) {
+                    controller.enqueue({
+                      type: ChunkType.TEXT_START
+                    } as TextStartChunk)
+                    isFirstTextChunk = false
+                  }
                   controller.enqueue({
                     type: ChunkType.TEXT_DELTA,
                     text: text
@@ -593,6 +613,13 @@ export class GeminiAPIClient extends BaseApiClient<
                   }
                 } as LLMWebSearchCompleteChunk)
               }
+              if (toolCalls.length > 0) {
+                controller.enqueue({
+                  type: ChunkType.MCP_TOOL_CREATED,
+                  tool_calls: [...toolCalls]
+                })
+                toolCalls.length = 0
+              }
               controller.enqueue({
                 type: ChunkType.LLM_RESPONSE_COMPLETE,
                 response: {

src/renderer/src/aiCore/clients/openai/OpenAIApiClient.ts

@@ -5,6 +5,7 @@ import {
   GEMINI_FLASH_MODEL_REGEX,
   getOpenAIWebSearchParams,
   isDoubaoThinkingAutoModel,
+  isQwenReasoningModel,
   isReasoningModel,
   isSupportedReasoningEffortGrokModel,
   isSupportedReasoningEffortModel,
@@ -31,7 +32,7 @@ import {
   ToolCallResponse,
   WebSearchSource
 } from '@renderer/types'
-import { ChunkType } from '@renderer/types/chunk'
+import { ChunkType, TextStartChunk, ThinkingStartChunk } from '@renderer/types/chunk'
 import { Message } from '@renderer/types/newMessage'
 import {
   OpenAISdkMessageParam,
@@ -114,7 +115,11 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
 
     if (!reasoningEffort) {
       if (model.provider === 'openrouter') {
-        if (isSupportedThinkingTokenGeminiModel(model) && !GEMINI_FLASH_MODEL_REGEX.test(model.id)) {
+        if (
+          isSupportedThinkingTokenGeminiModel(model) &&
+          !GEMINI_FLASH_MODEL_REGEX.test(model.id) &&
+          model.id.includes('grok-4')
+        ) {
           return {}
         }
         return { reasoning: { enabled: false, exclude: true } }
@@ -166,10 +171,17 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
 
     // Qwen models
     if (isSupportedThinkingTokenQwenModel(model)) {
-      return {
+      const thinkConfig = {
         enable_thinking: true,
         thinking_budget: budgetTokens
       }
+      if (this.provider.id === 'dashscope') {
+        return {
+          ...thinkConfig,
+          incremental_output: true
+        }
+      }
+      return thinkConfig
     }
 
     // Grok models
@@ -307,7 +319,7 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
       }
 
       if ([FileTypes.TEXT, FileTypes.DOCUMENT].includes(file.type)) {
-        const fileContent = await (await window.api.file.read(file.id + file.ext)).trim()
+        const fileContent = await (await window.api.file.read(file.id + file.ext, true)).trim()
         parts.push({
           type: 'text',
           text: file.origin_name + '\n' + fileContent
@@ -359,7 +371,12 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
     if ('toolUseId' in mcpToolResponse && mcpToolResponse.toolUseId) {
       // This case is for Anthropic/Claude like tool usage, OpenAI uses tool_call_id
       // For OpenAI, we primarily expect toolCallId. This might need adjustment if mixing provider concepts.
-      return mcpToolCallResponseToOpenAICompatibleMessage(mcpToolResponse, resp, isVisionModel(model))
+      return mcpToolCallResponseToOpenAICompatibleMessage(
+        mcpToolResponse,
+        resp,
+        isVisionModel(model),
+        this.provider.isNotSupportArrayContent ?? false
+      )
     } else if ('toolCallId' in mcpToolResponse && mcpToolResponse.toolCallId) {
       return {
         role: 'tool',
@@ -436,7 +453,14 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
         messages: OpenAISdkMessageParam[]
         metadata: Record<string, any>
       }> => {
-        const { messages, mcpTools, maxTokens, streamOutput, enableWebSearch } = coreRequest
+        const { messages, mcpTools, maxTokens, enableWebSearch } = coreRequest
+        let { streamOutput } = coreRequest
+
+        // Qwen3商业版（思考模式）、Qwen3开源版、QwQ、QVQ只支持流式输出。
+        if (isQwenReasoningModel(model)) {
+          streamOutput = true
+        }
+
         // 1. 处理系统消息
         let systemMessage = { role: 'system', content: assistant.prompt || '' }
 
@@ -659,6 +683,8 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
       isFinished = true
     }
 
+    let isFirstThinkingChunk = true
+    let isFirstTextChunk = true
     return (context: ResponseChunkTransformerContext) => ({
       async transform(chunk: OpenAISdkRawChunk, controller: TransformStreamDefaultController<GenericChunk>) {
         // 持续更新usage信息
@@ -677,15 +703,29 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
 
             // 对于流式响应，使用 delta；对于非流式响应，使用 message。
             // 然而某些 OpenAI 兼容平台在非流式请求时会错误地返回一个空对象的 delta 字段。
-            // 如果 delta 为空对象，应当忽略它并回退到 message，避免造成内容缺失。
+            // 如果 delta 为空对象或content为空，应当忽略它并回退到 message，避免造成内容缺失。
             let contentSource: OpenAISdkRawContentSource | null = null
-            if ('delta' in choice && choice.delta && Object.keys(choice.delta).length > 0) {
+            if (
+              'delta' in choice &&
+              choice.delta &&
+              Object.keys(choice.delta).length > 0 &&
+              (!('content' in choice.delta) ||
+                (typeof choice.delta.content === 'string' && choice.delta.content !== '') ||
+                (typeof (choice.delta as any).reasoning_content === 'string' &&
+                  (choice.delta as any).reasoning_content !== '') ||
+                (typeof (choice.delta as any).reasoning === 'string' && (choice.delta as any).reasoning !== ''))
+            ) {
               contentSource = choice.delta
             } else if ('message' in choice) {
               contentSource = choice.message
             }
 
-            if (!contentSource) continue
+            if (!contentSource) {
+              if ('finish_reason' in choice && choice.finish_reason) {
+                emitCompletionSignals(controller)
+              }
+              continue
+            }
 
             const webSearchData = collectWebSearchData(chunk, contentSource, context)
             if (webSearchData) {
@@ -699,6 +739,12 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
             // @ts-ignore - reasoning_content is not in standard OpenAI types but some providers use it
             const reasoningText = contentSource.reasoning_content || contentSource.reasoning
             if (reasoningText) {
+              if (isFirstThinkingChunk) {
+                controller.enqueue({
+                  type: ChunkType.THINKING_START
+                } as ThinkingStartChunk)
+                isFirstThinkingChunk = false
+              }
               controller.enqueue({
                 type: ChunkType.THINKING_DELTA,
                 text: reasoningText
@@ -707,6 +753,12 @@ export class OpenAIAPIClient extends OpenAIBaseClient<
 
             // 处理文本内容
             if (contentSource.content) {
+              if (isFirstTextChunk) {
+                controller.enqueue({
+                  type: ChunkType.TEXT_START
+                } as TextStartChunk)
+                isFirstTextChunk = false
+              }
               controller.enqueue({
                 type: ChunkType.TEXT_DELTA,
                 text: contentSource.content