更新 version.py

Interactive plugin flows edit existing messages; the flag was only applied
on send_message, so link previews stayed enabled after edits.

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

.dockerignore

@@ -1,3 +1,84 @@
-# Ignore git
+# Git
 .github
-.git
+.git
+.gitignore
+
+# Documentation
+docs/
+README.md
+LICENSE
+
+# Development files
+.pylintrc
+*.pyc
+__pycache__/
+*.pyo
+*.pyd
+.Python
+*.so
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+.hypothesis/
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp
+tmp/
+temp/
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Test files
+tests/
+test_*
+*_test.py
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+
+# Docker
+Dockerfile*
+docker-compose*
+.dockerignore
+
+# Other
+app.ico
+frozen.spec

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -9,8 +9,9 @@ body:
         请确认以下信息：
         1. 请按此模板提交issues，不按模板提交的问题将直接关闭。
         2. 如果你的问题可以直接在以往 issue 或者 Telegram频道 中找到，那么你的 issue 将会被直接关闭。
-        3. 提交问题务必描述清楚、附上日志，描述不清导致无法理解和分析的问题会被直接关闭。
+        3. **$\color{red}{提交问题务必描述清楚、附上日志}$**，描述不清导致无法理解和分析的问题会被直接关闭。
         4. 此仓库为后端仓库，如果是前端 WebUI 问题请在[前端仓库](https://github.com/jxxghp/MoviePilot-Frontend)提 issue。
+        5. **$\color{red}{不要通过issues来寻求解决你的环境问题、配置安装类问题、咨询类问题}$**，否则直接关闭并加入用户 $\color{red}{黑名单}$ !实在没有精力陪一波又一波的伸手党玩。
   - type: checkboxes
     id: ensure
     attributes:
@@ -32,6 +33,16 @@ body:
       description: 遇到问题时程序所在的版本号
     validations:
       required: true
+  - type: dropdown
+    id: environment
+    attributes:
+      label: 运行环境
+      description: 当前程序运行环境
+      options:
+        - Docker
+        - Windows
+    validations:
+      required: true
   - type: dropdown
     id: type
     attributes:
@@ -40,7 +51,6 @@ body:
       options:
         - 主程序运行问题
         - 插件问题
-        - Docker或运行环境问题
         - 其他问题
     validations:
       required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -14,6 +14,27 @@ body:
       description: 目前使用的程序版本
     validations:
       required: true
+  - type: dropdown
+    id: environment
+    attributes:
+      label: 运行环境
+      description: 当前程序运行环境
+      options:
+        - Docker
+        - Windows
+    validations:
+      required: true
+  - type: dropdown
+    id: type
+    attributes:
+      label: 功能改进类型
+      description: 你需要在下面哪个方面改进功能
+      options:
+        - 主程序
+        - 插件
+        - 其他
+    validations:
+      required: true
   - type: textarea
     id: feature-request
     attributes:

.github/ISSUE_TEMPLATE/rfc.yml

@@ -0,0 +1,45 @@
+name: 功能提案
+description: Request for Comments
+title: "[RFC]"
+labels: ["RFC"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        一份提案(RFC)定位为 **「在某功能/重构的具体开发前，用于开发者间 review 技术设计/方案的文档」**，
+        目的是让协作的开发者间清晰的知道「要做什么」和「具体会怎么做」，以及所有的开发者都能公开透明的参与讨论；
+        以便评估和讨论产生的影响 (遗漏的考虑、向后兼容性、与现有功能的冲突)，
+        因此提案侧重在对解决问题的 **方案、设计、步骤** 的描述上。
+
+        如果仅希望讨论是否添加或改进某功能本身，请使用 -> [Issue: 功能改进](https://github.com/jxxghp/MoviePilot/issues/new?assignees=&labels=feature+request&projects=&template=feature_request.yml&title=%5BFeature+Request%5D%3A+)
+  - type: textarea
+    id: background
+    attributes:
+      label: 背景 or 问题
+      description: 简单描述遇到的什么问题或需要改动什么。可以引用其他 issue、讨论、文档等。
+    validations:
+      required: true
+  - type: textarea
+    id: goal
+    attributes:
+      label: "目标 & 方案简述"
+      description: 简单描述提案此提案实现后，**预期的目标效果**，以及简单大致描述会采取的方案/步骤，可能会/不会产生什么影响。
+    validations:
+      required: true
+  - type: textarea
+    id: design
+    attributes:
+      label: "方案设计 & 实现步骤"
+      description: |
+        详细描述你设计的具体方案，可以考虑拆分列表或要点，一步步描述具体打算如何实现的步骤和相关细节。
+        这部份不需要一次性写完整，即使在创建完此提案 issue 后，依旧可以再次编辑修改。
+    validations:
+      required: false
+  - type: textarea
+    id: alternative
+    attributes:
+      label: "替代方案 & 对比"
+      description: |
+        [可选] 为来实现目标效果，还考虑过什么其他方案，有什么对比？
+    validations:
+      required: false

.github/workflows/beta.yml

@@ -0,0 +1,60 @@
+name: MoviePilot Builder Beta
+on:
+  workflow_dispatch:
+
+jobs:
+  Docker-build:
+    runs-on: ubuntu-latest
+    name: Build Docker Image
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Release version
+        id: release_version
+        run: |
+          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
+          echo "app_version=$app_version" >> $GITHUB_ENV
+
+      - name: Docker Meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+            ghcr.io/${{ github.repository }}
+          tags: |
+            type=raw,value=beta
+
+      - name: Set Up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set Up Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Login GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build Image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: |
+            linux/amd64
+            linux/arm64/v8
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha, scope=${{ github.workflow }}-docker
+          cache-to: type=gha, scope=${{ github.workflow }}-docker

.github/workflows/build.yml

@@ -1,62 +1,201 @@
-name: MoviePilot Builder
+name: MoviePilot Builder v2
 on:
   workflow_dispatch:
   push:
     branches:
-      - main
+      - v2
     paths:
-      - version.py
+      - 'version.py'
 
 jobs:
-  build:
+  Docker-build:
     runs-on: ubuntu-latest
     name: Build Docker Image
     steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v4
+      - name: Checkout
+        uses: actions/checkout@v4
         with:
-          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot
+          fetch-depth: 0
+          fetch-tags: true
 
-      -
-        name: Release version
+      - name: Release version
         id: release_version
         run: |
           app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
           echo "app_version=$app_version" >> $GITHUB_ENV
 
-      -
-        name: Set Up QEMU
-        uses: docker/setup-qemu-action@v2
+      - name: Docker Meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+            ${{ secrets.DOCKER_USERNAME }}/moviepilot
+            ghcr.io/${{ github.repository }}
+          tags: |
+            type=raw,value=${{ env.app_version }}
+            type=raw,value=latest
 
-      -
-        name: Set Up Buildx
-        uses: docker/setup-buildx-action@v2
+      - name: Set Up QEMU
+        uses: docker/setup-qemu-action@v3
 
-      -
-        name: Login DockerHub
-        uses: docker/login-action@v2
+      - name: Set Up Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login DockerHub
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
-      -
-        name: Build Image
-        uses: docker/build-push-action@v4
+      - name: Login GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build Image
+        uses: docker/build-push-action@v5
         with:
           context: .
-          file: Dockerfile
+          file: docker/Dockerfile
           platforms: |
             linux/amd64
-            linux/arm64
+            linux/arm64/v8
           push: true
-          build-args: |
-            MOVIEPILOT_VERSION=${{ env.app_version }}
-          tags: |
-            ${{ secrets.DOCKER_USERNAME }}/moviepilot:latest
-            ${{ secrets.DOCKER_USERNAME }}/moviepilot:${{ env.app_version }}
+          tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha, scope=${{ github.workflow }}-docker
+          cache-to: type=gha, scope=${{ github.workflow }}-docker
+
+      - name: Generate Changelog
+        id: changelog
+        run: |
+          # 获取上一个 tag（排除当前版本的 tag）
+          PREVIOUS_TAG=$(git tag -l 'v*' --sort=-v:refname | grep -v "^v${{ env.app_version }}$" | head -n 1)
+          echo "Previous tag: $PREVIOUS_TAG"
+
+          # 使用 || 作为分隔符，同时获取 commit 消息和作者 GitHub 用户名
+          if [ -z "$PREVIOUS_TAG" ]; then
+            COMMITS=$(git log --pretty=format:"%s||%an" HEAD)
+          else
+            COMMITS=$(git log --pretty=format:"%s||%an" ${PREVIOUS_TAG}..HEAD)
+          fi
+
+          # 分类收集 commit 消息（使用关联数组去重）
+          declare -A SEEN
+          FEATURES=""
+          FIXES=""
+          OTHERS=""
+
+          while IFS= read -r line; do
+            # 跳过空行
+            if [ -z "$line" ]; then
+              continue
+            fi
+
+            # 分离 commit 消息和作者
+            msg=$(echo "$line" | sed 's/||[^|]*$//')
+            author=$(echo "$line" | sed 's/.*||//')
+
+            # 跳过 Merge commit 和版本更新 commit
+            if echo "$msg" | grep -qE "^Merge pull request|^Merge branch|^更新 version"; then
+              continue
+            fi
+
+            # 按 Conventional Commits 前缀分类
+            if echo "$msg" | grep -qiE "^feat(\(.+\))?:"; then
+              desc=$(echo "$msg" | sed -E 's/^feat(\([^)]*\))?:\s*//')
+              category="FEATURES"
+            elif echo "$msg" | grep -qiE "^fix(\(.+\))?:"; then
+              desc=$(echo "$msg" | sed -E 's/^fix(\([^)]*\))?:\s*//')
+              category="FIXES"
+            elif echo "$msg" | grep -qiE "^(docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?:"; then
+              desc=$(echo "$msg" | sed -E 's/^(docs|style|refactor|perf|test|build|ci|chore|revert)(\([^)]*\))?:\s*//')
+              category="OTHERS"
+            else
+              desc="$msg"
+              category="OTHERS"
+            fi
+
+            # 使用 "分类+描述" 作为去重的 key，跳过重复内容
+            dedup_key="${category}::${desc}"
+            if [ -n "${SEEN[$dedup_key]+x}" ]; then
+              continue
+            fi
+            SEEN[$dedup_key]=1
+
+            # 添加 by @author 引用
+            entry="- ${desc} by @${author}"
+
+            case "$category" in
+              FEATURES) FEATURES="${FEATURES}${entry}\n" ;;
+              FIXES)    FIXES="${FIXES}${entry}\n" ;;
+              OTHERS)   OTHERS="${OTHERS}${entry}\n" ;;
+            esac
+          done <<< "$COMMITS"
+
+          # 组装 changelog
+          CHANGELOG=""
+
+          if [ -n "$FEATURES" ]; then
+            CHANGELOG="${CHANGELOG}### ✨ 新功能\n\n${FEATURES}\n"
+          fi
+
+          if [ -n "$FIXES" ]; then
+            CHANGELOG="${CHANGELOG}### 🐛 修复\n\n${FIXES}\n"
+          fi
+
+          if [ -n "$OTHERS" ]; then
+            CHANGELOG="${CHANGELOG}### 🔧 其他\n\n${OTHERS}\n"
+          fi
+
+          # 添加版本对比链接
+          if [ -n "$PREVIOUS_TAG" ]; then
+            CHANGELOG="${CHANGELOG}**完整更新记录**: https://github.com/${{ github.repository }}/compare/${PREVIOUS_TAG}...v${{ env.app_version }}"
+          fi
+
+          # 写入环境变量
+          echo "CHANGELOG<<EOF" >> $GITHUB_ENV
+          echo -e "$CHANGELOG" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
+      - name: Get existing release body
+        id: get_release_body
+        continue-on-error: true
+        run: |
+          release_body=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            "https://api.github.com/repos/${{ github.repository }}/releases/tags/v${{ env.app_version }}" | \
+            jq -r '.body // ""')
+
+          # 如果已有手动编写的 release body，则保留；否则使用自动生成的 changelog
+          if [ -n "$release_body" ] && [ "$release_body" != "null" ] && [ "$release_body" != "" ]; then
+            echo "RELEASE_BODY<<EOF" >> $GITHUB_ENV
+            echo "$release_body" >> $GITHUB_ENV
+            echo "EOF" >> $GITHUB_ENV
+          else
+            echo "RELEASE_BODY<<EOF" >> $GITHUB_ENV
+            echo "${{ env.CHANGELOG }}" >> $GITHUB_ENV
+            echo "EOF" >> $GITHUB_ENV
+          fi
+
+      - name: Delete Release
+        uses: dev-drprasad/delete-tag-and-release@v1.1
+        continue-on-error: true
+        with:
+          tag_name: v${{ env.app_version }}
+          delete_release: true
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ env.app_version }}
+          name: v${{ env.app_version }}
+          body: ${{ env.RELEASE_BODY }}
+          draft: false
+          prerelease: false
+          make_latest: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/issues.yml

@@ -0,0 +1,33 @@
+name: Close inactive issues
+on:
+ workflow_dispatch:
+
+ schedule:
+   # Github Action 只支持 UTC 时间。
+   # '0 18 * * *' 对应 UTC 时间的 18:00，也就是中国时区 (UTC+8) 的第二天凌晨 02:00。
+   - cron: "0 18 * * *"
+
+jobs:
+ close-issues:
+   runs-on: ubuntu-latest
+   permissions:
+     issues: write
+     pull-requests: write
+   steps:
+     - uses: actions/stale@v5
+       with:
+         # 标记 stale 标签时间
+         days-before-issue-stale: 30
+         # 关闭 issues 标签时间
+         days-before-issue-close: 14
+         # 自定义标签名
+         stale-issue-label: "stale"
+         stale-issue-message: "此问题已过时，因为它已打开 30 天且没有任何活动。"
+         close-issue-message: "此问题已关闭，因为它在标记为 stale 后，已处于无更新状态 14 天。"
+         # 忽略所有的 Pull Request，只处理 Issue
+         days-before-pr-stale: -1
+         days-before-pr-close: -1
+         # 排除带有RFC标签的issue
+         exempt-issue-labels: "RFC"
+         operations-per-run: 500
+         repo-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pylint.yml

@@ -0,0 +1,91 @@
+name: Pylint Code Quality Check
+
+on:
+  # 允许手动触发
+  workflow_dispatch:
+
+jobs:
+  pylint:
+    runs-on: ubuntu-latest
+    name: Pylint Code Quality Check
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+        cache: 'pip'
+
+    - name: Cache pip dependencies
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt', '**/requirements.in') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip setuptools wheel
+        pip install pylint
+        # 安装项目依赖
+        if [ -f requirements.txt ]; then
+          echo "📦 安装 requirements.txt 中的依赖..."
+          pip install -r requirements.txt
+        elif [ -f requirements.in ]; then
+          echo "📦 安装 requirements.in 中的依赖..."
+          pip install -r requirements.in
+        else
+          echo "⚠️ 未找到依赖文件，仅安装 pylint"
+        fi
+
+    - name: Verify pylint config
+      run: |
+        # 检查项目中的pylint配置文件是否存在
+        if [ -f .pylintrc ]; then
+          echo "✅ 找到项目配置文件: .pylintrc"
+          echo "配置文件内容预览:"
+          head -10 .pylintrc
+        else
+          echo "❌ 未找到 .pylintrc 配置文件"
+          exit 1
+        fi
+    - name: Run pylint
+      run: |
+        # 运行pylint，检查主要的Python文件
+        echo "🚀 运行 Pylint 错误检查..."
+
+        # 检查主要目录 - 只关注错误，如果有错误则退出
+        echo "📂 检查 app/ 目录..."
+        pylint app/ --output-format=colorized --reports=yes --score=yes
+
+        # 检查根目录的Python文件
+        echo "📂 检查根目录 Python 文件..."
+        for file in $(find . -name "*.py" -not -path "./.*" -not -path "./.venv/*" -not -path "./build/*" -not -path "./dist/*" -not -path "./tests/*" -not -path "./docs/*" -not -path "./__pycache__/*" -maxdepth 1); do
+          echo "检查文件: $file"
+          pylint "$file" --output-format=colorized || exit 1
+        done
+
+        # 生成详细报告
+        echo "📊 生成 Pylint 详细报告..."
+        pylint app/ --output-format=json > pylint-report.json || true
+
+        # 显示评分（仅供参考）
+        echo "📈 Pylint 评分（仅供参考）:"
+        pylint app/ --score=yes --reports=no | tail -2 || true
+
+    - name: Upload pylint report
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: pylint-report
+        path: pylint-report.json
+
+    - name: Summary
+      run: |
+        echo "🎉 Pylint 检查完成！"
+        echo "✅ 没有发现语法错误或严重问题"
+        echo "📊 详细报告已保存为构建工件"

.github/workflows/release.yml

@@ -1,36 +0,0 @@
-name: MoviePilot Release
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - main
-    paths:
-      - version.py
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    name: Build Docker Image
-    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-
-      -
-        name: Release Version
-        id: release_version
-        run: |
-          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
-          echo "app_version=$app_version" >> $GITHUB_ENV
-
-      -
-        name: Generate Release
-        uses: actions/create-release@latest
-        with:
-          tag_name: v${{ env.app_version }}
-          name: v${{ env.app_version }}
-          body: ${{ github.event.commits[0].message }}
-          draft: false
-          prerelease: false
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,8 +1,33 @@
 .idea/
 *.c
+*.so
+*.pyd
 build/
+cython_cache/
+dist/
+nginx/
 test.py
+safety_report.txt
 app/helper/sites.py
-config/user.db
+app/helper/*.so
+app/helper/*.pyd
+app/helper/*.bin
+app/plugins/**
+!app/plugins/__init__.py
+config/cookies/**
+config/user.db*
+config/sites/**
+config/logs/
+config/temp/
+config/cache/
 *.pyc
 *.log
+.vscode
+venv
+
+# Pylint
+pylint-report.json
+.pylint.d/
+
+# AI
+.claude/

.pylintrc

@@ -0,0 +1,83 @@
+[MASTER]
+# 指定Python路径
+init-hook='import sys; sys.path.append(".")'
+
+# 忽略的文件和目录
+ignore=.git,__pycache__,.venv,build,dist,tests,docs
+
+# 并行作业数量
+jobs=0
+
+[MESSAGES CONTROL]
+# 只关注错误级别的问题，禁用警告、约定和重构建议
+# E = Error (错误) - 会导致构建失败
+# W = Warning (警告) - 仅显示，不会失败
+# R = Refactor (重构建议) - 仅显示，不会失败
+# C = Convention (约定) - 仅显示，不会失败
+# I = Information (信息) - 仅显示，不会失败
+
+# 禁用大部分警告、约定和重构建议，只保留错误和重要警告
+disable=all
+enable=error,
+       syntax-error,
+       undefined-variable,
+       used-before-assignment,
+       unreachable,
+       return-outside-function,
+       yield-outside-function,
+       continue-in-finally,
+       nonlocal-without-binding,
+       undefined-loop-variable,
+       redefined-builtin,
+       not-callable,
+       assignment-from-no-return,
+       no-value-for-parameter,
+       too-many-function-args,
+       unexpected-keyword-arg,
+       redundant-keyword-arg,
+       import-error,
+       relative-beyond-top-level
+
+[REPORTS]
+# 设置报告格式
+output-format=colorized
+reports=yes
+score=yes
+
+[FORMAT]
+# 最大行长度
+max-line-length=120
+# 缩进大小
+indent-string='    '
+
+[DESIGN]
+# 最大参数数量
+max-args=10
+# 最大本地变量数量
+max-locals=20
+# 最大分支数量
+max-branches=15
+# 最大语句数量
+max-statements=50
+# 最大父类数量
+max-parents=7
+# 最大属性数量
+max-attributes=10
+# 最小公共方法数量
+min-public-methods=1
+# 最大公共方法数量
+max-public-methods=25
+
+[SIMILARITIES]
+# 最小相似行数
+min-similarity-lines=6
+# 忽略注释
+ignore-comments=yes
+# 忽略文档字符串
+ignore-docstrings=yes
+# 忽略导入
+ignore-imports=yes
+
+[TYPECHECK]
+# 生成缺失成员提示的类列表
+generated-members=requests.packages.urllib3

Dockerfile

@@ -1,86 +0,0 @@
-FROM python:3.11.4-slim-bullseye
-ARG MOVIEPILOT_VERSION
-ENV LANG="C.UTF-8" \
-    HOME="/moviepilot" \
-    TERM="xterm" \
-    TZ="Asia/Shanghai" \
-    PUID=0 \
-    PGID=0 \
-    UMASK=000 \
-    MOVIEPILOT_AUTO_UPDATE=true \
-    MOVIEPILOT_AUTO_UPDATE_DEV=false \
-    NGINX_PORT=3000 \
-    CONFIG_DIR="/config" \
-    API_TOKEN="moviepilot" \
-    AUTH_SITE="iyuu" \
-    DOWNLOAD_PATH="/downloads" \
-    DOWNLOAD_CATEGORY="false" \
-    TORRENT_TAG="MOVIEPILOT" \
-    LIBRARY_PATH="" \
-    LIBRARY_CATEGORY="false" \
-    TRANSFER_TYPE="copy" \
-    COOKIECLOUD_HOST="https://movie-pilot.org/cookiecloud" \
-    COOKIECLOUD_KEY="" \
-    COOKIECLOUD_PASSWORD="" \
-    MESSAGER="telegram" \
-    TELEGRAM_TOKEN="" \
-    TELEGRAM_CHAT_ID="" \
-    DOWNLOADER="qbittorrent" \
-    QB_HOST="127.0.0.1:8080" \
-    QB_USER="admin" \
-    QB_PASSWORD="adminadmin" \
-    MEDIASERVER="emby" \
-    EMBY_HOST="http://127.0.0.1:8096" \
-    EMBY_API_KEY=""
-WORKDIR "/app"
-COPY . .
-RUN apt-get update \
-    && apt-get -y install \
-        musl-dev \
-        nginx \
-        gettext-base \
-        locales \
-        procps \
-        gosu \
-        bash \
-        wget \
-        curl \
-        busybox \
-        dumb-init \
-        jq \
-    && \
-    if [ "$(uname -m)" = "x86_64" ]; \
-        then ln -s /usr/lib/x86_64-linux-musl/libc.so /lib/libc.musl-x86_64.so.1; \
-    elif [ "$(uname -m)" = "aarch64" ]; \
-        then ln -s /usr/lib/aarch64-linux-musl/libc.so /lib/libc.musl-aarch64.so.1; \
-    fi \
-    && cp -f /app/nginx.conf /etc/nginx/nginx.template.conf \
-    && cp -f /app/update /usr/local/bin/mp_update \
-    && cp -f /app/entrypoint /entrypoint \
-    && chmod +x /entrypoint /usr/local/bin/mp_update \
-    && mkdir -p ${HOME} \
-    && groupadd -r moviepilot -g 911 \
-    && useradd -r moviepilot -g moviepilot -d ${HOME} -s /bin/bash -u 911 \
-    && apt-get install -y build-essential \
-    && pip install --upgrade pip \
-    && pip install -r requirements.txt \
-    && playwright install-deps chromium \
-    && python_ver=$(python3 -V | awk '{print $2}') \
-    && echo "/app/" > /usr/local/lib/python${python_ver%.*}/site-packages/app.pth \
-    && echo 'fs.inotify.max_user_watches=5242880' >> /etc/sysctl.conf \
-    && echo 'fs.inotify.max_user_instances=5242880' >> /etc/sysctl.conf \
-    && locale-gen zh_CN.UTF-8 \
-    && FRONTEND_VERSION=$(curl -sL "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" | jq -r .tag_name) \
-    && curl -sL "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/${FRONTEND_VERSION}/dist.zip" | busybox unzip -d / - \
-    && mv /dist /public \
-    && apt-get remove -y build-essential \
-    && apt-get autoremove -y \
-    && apt-get clean -y \
-    && rm -rf \
-        /tmp/* \
-        /moviepilot/.cache \
-        /var/lib/apt/lists/* \
-        /var/tmp/*
-EXPOSE 3000
-VOLUME ["/config"]
-ENTRYPOINT [ "/entrypoint" ]

README.md

@@ -1,250 +1,85 @@
 # MoviePilot
 
+![GitHub Repo stars](https://img.shields.io/github/stars/jxxghp/MoviePilot?style=for-the-badge)
+![GitHub forks](https://img.shields.io/github/forks/jxxghp/MoviePilot?style=for-the-badge)
+![GitHub contributors](https://img.shields.io/github/contributors/jxxghp/MoviePilot?style=for-the-badge)
+![GitHub repo size](https://img.shields.io/github/repo-size/jxxghp/MoviePilot?style=for-the-badge)
+![GitHub issues](https://img.shields.io/github/issues/jxxghp/MoviePilot?style=for-the-badge)
+![Docker Pulls](https://img.shields.io/docker/pulls/jxxghp/moviepilot?style=for-the-badge)
+![Docker Pulls V2](https://img.shields.io/docker/pulls/jxxghp/moviepilot-v2?style=for-the-badge)
+![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20Synology-blue?style=for-the-badge)
+
+
 基于 [NAStool](https://github.com/NAStool/nas-tools) 部分代码重新设计，聚焦自动化核心需求，减少问题同时更易于扩展和维护。
 
 # 仅用于学习交流使用，请勿在任何国内平台宣传该项目！
 
-Docker：https://hub.docker.com/r/jxxghp/moviepilot
-
 发布频道：https://t.me/moviepilot_channel
 
 ## 主要特性
-- 前后端分离，基于FastApi + Vue3，前端项目地址：[MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)
+
+- 前后端分离，基于FastApi + Vue3。
 - 聚焦核心需求，简化功能和设置，部分设置项可直接使用默认值。
 - 重新设计了用户界面，更加美观易用。
 
-## 安装
+## 安装使用
 
-1. **安装CookieCloud插件**
-
-站点信息需要通过CookieCloud同步获取，因此需要安装CookieCloud插件，将浏览器中的站点Cookie数据同步到云端后再同步到MoviePilot使用。 插件下载地址请点击 [这里](https://github.com/easychen/CookieCloud/releases)。
-
-2. **安装CookieCloud服务端（可选）**
-
-MoviePilot内置了公共CookieCloud服务器，如果需要自建服务，可参考 [CookieCloud](https://github.com/easychen/CookieCloud) 项目进行搭建，docker镜像请点击 [这里](https://hub.docker.com/r/easychen/cookiecloud)。
-
-**声明：** 本项目不会收集用户敏感数据，Cookie同步也是基于CookieCloud项目实现，非本项目提供的能力。技术角度上CookieCloud采用端到端加密，在个人不泄露`用户KEY`和`端对端加密密码`的情况下第三方无法窃取任何用户信息（包括服务器持有者）。如果你不放心，可以不使用公共服务或者不使用本项目，但如果使用后发生了任何信息泄露与本项目无关！
-
-3. **安装配套管理软件**
-
-MoviePilot需要配套下载器和媒体服务器配合使用。
-- 下载器支持：qBittorrent、Transmission，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，推荐使用QB。
-- 媒体服务器支持：Jellyfin、Emby、Plex，推荐使用Emby。
-
-4. **安装MoviePilot**
-
-目前仅提供docker镜像，点击 [这里](https://hub.docker.com/r/jxxghp/moviepilot) 或执行命令：
+官方Wiki：https://wiki.movie-pilot.org
 
+### 为 AI Agent 添加 Skills
 ```shell
-docker pull jxxghp/moviepilot:latest
+npx skills add https://github.com/jxxghp/MoviePilot
 ```
 
-## 配置
+## 参与开发
 
-项目的所有配置均通过环境变量进行设置，部分环境建立容器后会自动显示待配置项，如未自动显示配置项则需要手动增加对应环境变量。
+API文档：https://api.movie-pilot.org
 
-配置文件映射路径：`/config`
+MCP工具API文档：详见 [docs/mcp-api.md](docs/mcp-api.md)
 
-### 1. **基础设置**
-
-- **PUID**：运行程序用户的`uid`，默认`0`
-- **PGID**：运行程序用户的`gid`，默认`0`
-- **UMASK**：掩码权限，默认`000`，可以考虑设置为`022`
-- **MOVIEPILOT_AUTO_UPDATE**：重启更新，`true`/`false`，默认`true` **注意：如果出现网络问题可以配置`PROXY_HOST`，具体看下方`PROXY_HOST`解释**
-- **NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，但不能为`3001`
-- **SUPERUSER：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面
-- **SUPERUSER_PASSWORD：** 超级管理员初始密码，默认`password`，建议修改为复杂密码
-- **API_TOKEN：** API密钥，默认`moviepilot`，在媒体服务器Webhook、微信回调等地址配置中需要加上`?token=`该值，建议修改为复杂字符串
-- **PROXY_HOST：** 网络代理（可选），访问themoviedb或者重启更新需要使用代理访问，格式为`http(s)://ip:port`
-- **TMDB_API_DOMAIN：** TMDB API地址，默认`api.themoviedb.org`，也可配置为`api.tmdb.org`或其它中转代理服务地址，能连通即可
-- **DOWNLOAD_PATH：** 下载保存目录，**注意：需要将`moviepilot`及`下载器`的映射路径保持一致**，否则会导致下载文件无法转移
-- **DOWNLOAD_MOVIE_PATH：** 电影下载保存目录，**必须是`DOWNLOAD_PATH`的下级路径**，不设置则下载到`DOWNLOAD_PATH`
-- **DOWNLOAD_TV_PATH：** 电视剧下载保存目录，**必须是`DOWNLOAD_PATH`的下级路径**，不设置则下载到`DOWNLOAD_PATH`
-- **DOWNLOAD_ANIME_PATH：** 动漫下载保存目录，**必须是`DOWNLOAD_PATH`的下级路径**，不设置则下载到`DOWNLOAD_PATH`
-- **DOWNLOAD_CATEGORY：** 下载二级分类开关，`true`/`false`，默认`false`，开启后会根据配置`category.yaml`自动在下载目录下建立二级目录分类
-- **DOWNLOAD_SUBTITLE：** 下载站点字幕，`true`/`false`，默认`true`
-- **REFRESH_MEDIASERVER：** 入库刷新媒体库，`true`/`false`，默认`true`
-- **SCRAP_METADATA：** 刮削入库的媒体文件，`true`/`false`，默认`true`
-- **TORRENT_TAG：** 种子标签，默认为`MOVIEPILOT`，设置后只有MoviePilot添加的下载才会处理，留空所有下载器中的任务均会处理
-- **LIBRARY_PATH：** 媒体库目录，多个目录使用`,`分隔
-- **LIBRARY_MOVIE_NAME：** 电影媒体库目录名，默认`电影`
-- **LIBRARY_TV_NAME：** 电视剧媒体库目录名，默认`电视剧`
-- **LIBRARY_ANIME_NAME：** 动漫媒体库目录名，默认`电视剧/动漫`
-- **LIBRARY_CATEGORY：** 媒体库二级分类开关，`true`/`false`，默认`false`，开启后会根据配置`category.yaml`自动在媒体库目录下建立二级目录分类
-- **TRANSFER_TYPE：** 转移方式，支持`link`/`copy`/`move`/`softlink`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响**
-- **COOKIECLOUD_HOST：** CookieCloud服务器地址，格式：`http(s)://ip:port`，不配置默认使用内建服务器`https://movie-pilot.org/cookiecloud`
-- **COOKIECLOUD_KEY：** CookieCloud用户KEY
-- **COOKIECLOUD_PASSWORD：** CookieCloud端对端加密密码
-- **COOKIECLOUD_INTERVAL：** CookieCloud同步间隔（分钟）
-- **OCR_HOST：** OCR识别服务器地址，格式：`http(s)://ip:port`，用于识别站点二维码实现自动登录获取Cookie等，不配置默认使用内建服务器`https://movie-pilot.org`，可使用 [这个镜像](https://hub.docker.com/r/jxxghp/moviepilot-ocr) 自行搭建。
-- **USER_AGENT：** CookieCloud对应的浏览器UA，可选，设置后可增加连接站点的成功率，同步站点后可以在管理界面中修改
-- **AUTO_DOWNLOAD_USER：** 交互搜索自动下载用户ID，使用,分割
-- **SUBSCRIBE_SEARCH：** 订阅搜索，`true`/`false`，默认`false`，开启后会每隔24小时对所有订阅进行全量搜索，以补齐缺失剧集（一般情况下正常订阅即可，订阅搜索只做为兜底，会增加站点压力，不建议开启）。
-- **MESSAGER：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`
-
-  - `wechat`设置项：
-
-    - **WECHAT_CORPID：** WeChat企业ID
-    - **WECHAT_APP_SECRET：** WeChat应用Secret
-    - **WECHAT_APP_ID：** WeChat应用ID
-    - **WECHAT_TOKEN：** WeChat消息回调的Token
-    - **WECHAT_ENCODING_AESKEY：** WeChat消息回调的EncodingAESKey
-    - **WECHAT_ADMINS：** WeChat管理员列表，多个管理员用英文逗号分隔（可选）
-    - **WECHAT_PROXY：** WeChat代理服务器（后面不要加/）
-
-  - `telegram`设置项：
-
-    - **TELEGRAM_TOKEN：** Telegram Bot Token
-    - **TELEGRAM_CHAT_ID：** Telegram Chat ID
-    - **TELEGRAM_USERS：** Telegram 用户ID，多个使用,分隔，只有用户ID在列表中才可以使用Bot，如未设置则均可以使用Bot
-    - **TELEGRAM_ADMINS：** Telegram 管理员ID，多个使用,分隔，只有管理员才可以操作Bot菜单，如未设置则均可以操作菜单
-
-  - `slack`设置项：
-
-    - **SLACK_OAUTH_TOKEN：** Slack Bot User OAuth Token
-    - **SLACK_APP_TOKEN：** Slack App-Level Token
-    - **SLACK_CHANNEL：** Slack 频道名称，默认`全体`
-
-
-- **DOWNLOADER：** 下载器，支持`qbittorrent`/`transmission`，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`qbittorrent`
-
-  - `qbittorrent`设置项：
-
-    - **QB_HOST：** qbittorrent地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **QB_USER：** qbittorrent用户名
-    - **QB_PASSWORD：** qbittorrent密码
-    - **QB_CATEGORY：** qbittorrent分类自动管理，`true`/`false`，默认`flase`，开启后会将下载二级分类传递到下载器，由下载器管理下载目录，需要同步开启`DOWNLOAD_CATEGORY`
-
-  - `transmission`设置项：
-
-    - **TR_HOST：** transmission地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **TR_USER：** transmission用户名
-    - **TR_PASSWORD：** transmission密码
-
-- **DOWNLOADER_MONITOR：** 下载器监控，`true`/`false`，默认为`true`，开启后下载完成时才会自动整理入库
-
-- **MEDIASERVER：** 媒体服务器，支持`emby`/`jellyfin`/`plex`，同时还需要配置对应媒体服务器的环境变量，非对应媒体服务器的变量可删除，推荐使用`emby`
-
-  - `emby`设置项：
-
-    - **EMBY_HOST：** Emby服务器地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **EMBY_API_KEY：** Emby Api Key，在`设置->高级->API密钥`处生成
-
-  - `jellyfin`设置项：
-
-    - **JELLYFIN_HOST：** Jellyfin服务器地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **JELLYFIN_API_KEY：** Jellyfin Api Key，在`设置->高级->API密钥`处生成
-
-  - `plex`设置项：
-
-    - **PLEX_HOST：** Plex服务器地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **PLEX_TOKEN：** Plex网页Url中的`X-Plex-Token`，通过浏览器F12->网络从请求URL中获取
-
-- **MEDIASERVER_SYNC_INTERVAL:** 媒体服务器同步间隔（小时），默认`6`，留空则不同步
-
-
-### 2. **用户认证**
-
-- **AUTH_SITE：** 认证站点，支持`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`iyuu`
-
-`MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数。
-
-| 站点 | 参数                                                    |
-|:--:|:-----------------------------------------------------:|
-| iyuu | `IYUU_SIGN`：IYUU登录令牌                                  |
-| hhclub | `HHCLUB_USERNAME`：用户名<br/>`HHCLUB_PASSKEY`：密钥         |
-| audiences | `AUDIENCES_UID`：用户ID<br/>`AUDIENCES_PASSKEY`：密钥       |
-| hddolby | `HDDOLBY_ID`：用户ID<br/>`HDDOLBY_PASSKEY`：密钥            |
-| zmpt | `ZMPT_UID`：用户ID<br/>`ZMPT_PASSKEY`：密钥                 |
-| freefarm | `FREEFARM_UID`：用户ID<br/>`FREEFARM_PASSKEY`：密钥         |
-| hdfans | `HDFANS_UID`：用户ID<br/>`HDFANS_PASSKEY`：密钥             |
-| wintersakura | `WINTERSAKURA_UID`：用户ID<br/>`WINTERSAKURA_PASSKEY`：密钥 |
-| leaves | `LEAVES_UID`：用户ID<br/>`LEAVES_PASSKEY`：密钥             |
-| 1ptba | `1PTBA_UID`：用户ID<br/>`1PTBA_PASSKEY`：密钥               |
-| icc2022 | `ICC2022_UID`：用户ID<br/>`ICC2022_PASSKEY`：密钥           |
-
-
-### 2. **进阶配置**
-
-- **BIG_MEMORY_MODE：** 大内存模式，默认为`false`，开启后会占用更多的内存，但响应速度会更快
-
-- **MOVIE_RENAME_FORMAT：** 电影重命名格式
-
-`MOVIE_RENAME_FORMAT`支持的配置项：
-
-> `title`： 标题  
-> `original_name`： 原文件名  
-> `original_title`： 原语种标题  
-> `name`： 识别名称  
-> `year`： 年份  
-> `edition`： 版本  
-> `videoFormat`： 分辨率  
-> `releaseGroup`： 制作组/字幕组  
-> `effect`： 特效  
-> `videoCodec`： 视频编码  
-> `audioCodec`： 音频编码  
-> `tmdbid`： TMDBID  
-> `imdbid`： IMDBID  
-> `part`：段/节  
-> `fileExt`：文件扩展名
-
-`MOVIE_RENAME_FORMAT`默认配置格式：
+本地运行需要 `Python 3.12`、`Node JS v20.12.1`
 
+- 克隆主项目 [MoviePilot](https://github.com/jxxghp/MoviePilot) 
+```shell
+git clone https://github.com/jxxghp/MoviePilot
 ```
-{{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}
+- 克隆资源项目 [MoviePilot-Resources](https://github.com/jxxghp/MoviePilot-Resources) ，将 `resources` 目录下对应平台及版本的库 `.so`/`.pyd`/`.bin` 文件复制到 `app/helper` 目录
+```shell
+git clone https://github.com/jxxghp/MoviePilot-Resources
 ```
-
-- **TV_RENAME_FORMAT：** 电视剧重命名格式
-
-`TV_RENAME_FORMAT`额外支持的配置项：
-
-> `season`： 季号  
-> `episode`： 集号  
-> `season_episode`： 季集 SxxExx  
-
-`TV_RENAME_FORMAT`默认配置格式：
-
+- 安装后端依赖，运行 `main.py` 启动后端服务，默认监听端口：`3001`，API文档地址：`http://localhost:3001/docs`
+```shell
+cd MoviePilot
+pip install -r requirements.txt
+python3 -m app.main
 ```
-{{title}}{% if year %} ({{year}}){% endif %}/Season {{season}}/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}{{fileExt}}
+- 克隆前端项目 [MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)
+```shell
+git clone https://github.com/jxxghp/MoviePilot-Frontend
 ```
-
-
-### 3. **过滤规则**
-
-在`设定`-`规则`中设定，规则说明：
-
-- 仅支持使用内置规则进行排列组合，内置规则有：`蓝光原盘`、`4K`、`1080P`、`中文字幕`、`特效字幕`、`H265`、`H264`、`杜比`、`HDR`、`REMUX`、`WEB-DL`、`免费`、`国语配音` 等
-- 符合任一层级规则的资源将被标识选中，匹配成功的层级做为该资源的优先级，排越前面优先级超高
-- 不符合过滤规则所有层级规则的资源将不会被选中
-
-
-## 使用
-
-- 通过CookieCloud同步快速同步站点，不需要使用的站点可在WEB管理界面中禁用。
-- 通过下载器监控实现自动整理入库刮削。
-- 通过微信/Telegram/Slack远程管理，其中Telegram将会自动添加操作菜单。微信回调相对路径为`/api/v1/message/`。
-- 通过WEB进行管理，将WEB添加到手机桌面获得类App使用效果，管理界面端口：`3000`。
-- 设置媒体服务器Webhook，通过MoviePilot发送播放通知等。Webhook回调相对路径为`/api/v1/webhook?token=moviepilot`，其中`moviepilot`为设置的`API_TOKEN`。
-- 将MoviePilot做为Radarr或Sonarr服务器添加到Overseerr或Jellyseerr，可使用Overseerr/Jellyseerr浏览订阅。
-
-**注意**
-
-1) 容器首次启动需要下载浏览器内核，根据网络情况可能需要较长时间，此时无法登录。可映射`/moviepilot`目录避免容器重置后重新触发浏览器内核下载。
-2) 使用反向代理时，需要添加以下配置，否则可能会导致部分功能无法访问（`ip:port`修改为实际值）：
-```nginx configuration
-location / {
-    proxy_pass http://ip:port;
-    proxy_set_header Host $http_host;
-    proxy_set_header X-Real-IP $remote_addr;
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-    proxy_set_header X-Forwarded-Proto $scheme;
-}
+- 安装前端依赖，运行前端项目，访问：`http://localhost:5173`
+```shell
+yarn
+yarn dev
 ```
+- 参考 [插件开发指引](https://wiki.movie-pilot.org/zh/plugindev) 在 `app/plugins` 目录下开发插件代码
 
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/b8f0238d-847f-4f9d-b210-e905837362b9)
+## 相关项目
 
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/28219233-ec7d-479b-b184-9a901c947dd1)
+- [MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)
+- [MoviePilot-Resources](https://github.com/jxxghp/MoviePilot-Resources)
+- [MoviePilot-Plugins](https://github.com/jxxghp/MoviePilot-Plugins)
+- [MoviePilot-Server](https://github.com/jxxghp/MoviePilot-Server)
+- [MoviePilot-Wiki](https://github.com/jxxghp/MoviePilot-Wiki)
 
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/f7df0806-668d-4c8b-ad41-133bf8f0bf73)
+## 免责申明
 
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/f7ea77cd-0362-4c35-967c-7f1b22dbef05)
+- 本软件仅供学习交流使用，任何人不得将本软件用于商业用途，任何人不得将本软件用于违法犯罪活动，软件对用户行为不知情，一切责任由使用者承担。
+- 本软件代码开源，基于开源代码进行修改，人为去除相关限制导致软件被分发、传播并造成责任事件的，需由代码修改发布者承担全部责任，不建议对用户认证机制进行规避或修改并公开发布。
+- 本项目不接受捐赠，没有在任何地方发布捐赠信息页面，软件本身不收费也不提供任何收费相关服务，请仔细辨别避免误导。
+
+## 贡献者
+
+<a href="https://github.com/jxxghp/MoviePilot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=jxxghp/MoviePilot" />
+</a>

alembic/versions/14f1813ae8e3_1_0_1.py

@@ -1,31 +0,0 @@
-"""1.0.1
-
-Revision ID: 14f1813ae8e3
-Revises: 9f4edd55c2d4
-Create Date: 2023-07-27 12:34:57.839443
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '14f1813ae8e3'
-down_revision = '9f4edd55c2d4'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("subscribe") as batch_op:
-            batch_op.add_column(sa.Column('best_version', sa.Integer, nullable=True))
-            batch_op.add_column(sa.Column('current_priority', sa.Integer, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

alembic/versions/1e169250e949_1_0_4.py

@@ -1,30 +0,0 @@
-"""1.0.4
-
-Revision ID: 1e169250e949
-Revises: 52ab4930be04
-Create Date: 2023-09-01 09:56:33.907661
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '1e169250e949'
-down_revision = '52ab4930be04'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("subscribe") as batch_op:
-            batch_op.add_column(sa.Column('date', sa.String, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

alembic/versions/52ab4930be04_1_0_3.py

@@ -1,30 +0,0 @@
-"""1_0_3
-
-Revision ID: 52ab4930be04
-Revises: ec5fb51fc300
-Create Date: 2023-08-28 13:21:45.152012
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '52ab4930be04'
-down_revision = 'ec5fb51fc300'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.execute("delete from systemconfig where key = 'RssSites';")
-    op.execute("insert into systemconfig(key, value) VALUES('RssSites', (select value from systemconfig where key= 'IndexerSites'));")
-    op.execute("delete from systemconfig where key = 'SearchResults';")
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###

alembic/versions/9f4edd55c2d4_1_0_0.py

@@ -1,32 +0,0 @@
-"""1.0.0
-
-Revision ID: 9f4edd55c2d4
-Revises: 
-Create Date: 2023-07-13 12:27:26.402317
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '9f4edd55c2d4'
-down_revision = None
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("subscribe") as batch_op:
-            batch_op.add_column(sa.Column('sites', sa.Text, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###

alembic/versions/ec5fb51fc300_1_0_2.py

@@ -1,32 +0,0 @@
-"""1.0.2
-
-Revision ID: ec5fb51fc300
-Revises: 14f1813ae8e3
-Create Date: 2023-08-12 17:55:06.509548
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'ec5fb51fc300'
-down_revision = '14f1813ae8e3'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("transferhistory") as batch_op:
-            batch_op.add_column(sa.Column('files', sa.String, nullable=True))
-        with op.batch_alter_table("rss") as batch_op:
-            batch_op.add_column(sa.Column('filter', sa.Integer, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

app/agent/__init__.py

@@ -0,0 +1,973 @@
+import asyncio
+import re
+import traceback
+import uuid
+from dataclasses import dataclass
+from typing import Callable, Dict, List, Optional
+
+from langchain.agents import create_agent
+from langchain.agents.middleware import (
+    SummarizationMiddleware,
+    LLMToolSelectorMiddleware,
+)
+from langchain_core.messages import (  # noqa: F401
+    HumanMessage,
+    BaseMessage,
+)
+from langgraph.checkpoint.memory import InMemorySaver
+
+from app.agent.callback import StreamingHandler
+from app.agent.memory import memory_manager
+from app.agent.middleware.activity_log import ActivityLogMiddleware
+from app.agent.middleware.jobs import JobsMiddleware
+from app.agent.middleware.memory import MemoryMiddleware
+from app.agent.middleware.patch_tool_calls import PatchToolCallsMiddleware
+from app.agent.middleware.skills import SkillsMiddleware
+from app.agent.prompt import prompt_manager
+from app.agent.tools.factory import MoviePilotToolFactory
+from app.chain import ChainBase
+from app.core.config import settings
+from app.helper.llm import LLMHelper
+from app.log import logger
+from app.schemas import Notification, NotificationType
+from app.schemas.message import ChannelCapabilityManager, ChannelCapability
+from app.schemas.types import MessageChannel
+
+
+class AgentChain(ChainBase):
+    pass
+
+
+class _ThinkTagStripper:
+    """
+    流式剥离 <think>...</think> 标签的辅助类。
+    维护内部缓冲区，处理标签跨 token 边界被截断的情况。
+    """
+
+    def __init__(self):
+        self.buffer = ""
+        self.in_think_tag = False
+
+    def reset(self):
+        """重置状态"""
+        self.buffer = ""
+        self.in_think_tag = False
+
+    def process(self, text: str, on_output: Callable[[str], None]):
+        """
+        将新文本送入处理，剥离 <think> 标签后通过 on_output 回调输出。
+        :param text: 新增的文本片段
+        :param on_output: 输出回调，接收过滤后的文本
+        :return: 本次调用是否通过 on_output 输出了内容
+        """
+        self.buffer += text
+        emitted = False
+        while self.buffer:
+            if not self.in_think_tag:
+                start_idx = self.buffer.find("<think>")
+                if start_idx != -1:
+                    if start_idx > 0:
+                        on_output(self.buffer[:start_idx])
+                        emitted = True
+                    self.in_think_tag = True
+                    self.buffer = self.buffer[start_idx + 7:]
+                else:
+                    # 检查是否以 <think> 的不完整前缀结尾
+                    partial_match = False
+                    for i in range(6, 0, -1):
+                        if self.buffer.endswith("<think>"[:i]):
+                            if len(self.buffer) > i:
+                                on_output(self.buffer[:-i])
+                                emitted = True
+                            self.buffer = self.buffer[-i:]
+                            partial_match = True
+                            break
+                    if not partial_match:
+                        on_output(self.buffer)
+                        emitted = True
+                        self.buffer = ""
+            else:
+                end_idx = self.buffer.find("</think>")
+                if end_idx != -1:
+                    self.in_think_tag = False
+                    self.buffer = self.buffer[end_idx + 8:]
+                else:
+                    # 检查是否以 </think> 的不完整前缀结尾
+                    partial_match = False
+                    for i in range(7, 0, -1):
+                        if self.buffer.endswith("</think>"[:i]):
+                            self.buffer = self.buffer[-i:]
+                            partial_match = True
+                            break
+                    if not partial_match:
+                        self.buffer = ""
+                    break
+        return emitted
+
+    def flush(self, on_output: Callable[[str], None]):
+        """流式结束时，输出缓冲区中剩余的非思考内容"""
+        if self.buffer and not self.in_think_tag:
+            on_output(self.buffer)
+            self.buffer = ""
+
+
+class MoviePilotAgent:
+    """
+    MoviePilot AI智能体（基于 LangChain v1 + LangGraph）
+    """
+
+    def __init__(
+        self,
+        session_id: str,
+        user_id: str = None,
+        channel: str = None,
+        source: str = None,
+        username: str = None,
+    ):
+        self.session_id = session_id
+        self.user_id = user_id
+        self.channel = channel
+        self.source = source
+        self.username = username
+
+        # 流式token管理
+        self.stream_handler = StreamingHandler()
+
+    @property
+    def is_background(self) -> bool:
+        """
+        是否为后台任务模式（无渠道信息，如定时唤醒）
+        """
+        return not self.channel or not self.source
+
+    def _should_stream(self) -> bool:
+        """
+        判断是否应启用流式输出：
+        - 后台模式不启用流式输出
+        - 渠道支持消息编辑：启用流式输出（实时推送 token）
+        - 渠道不支持消息编辑但开启了啰嗦模式：也需要启用流式输出，
+          以便在工具调用前捕获 Agent 的中间文字并随工具消息一起发送
+        - 其他情况不启用流式输出
+        """
+        if self.is_background:
+            return False
+        # 啰嗦模式下始终需要流式输出来捕获工具调用前的 Agent 文字
+        if settings.AI_AGENT_VERBOSE:
+            return True
+        try:
+            channel_enum = MessageChannel(self.channel)
+            return ChannelCapabilityManager.supports_capability(
+                channel_enum, ChannelCapability.MESSAGE_EDITING
+            )
+        except (ValueError, KeyError):
+            return False
+
+    @staticmethod
+    def _initialize_llm(streaming: bool = False):
+        """
+        初始化 LLM
+        :param streaming: 是否启用流式输出
+        """
+        return LLMHelper.get_llm(streaming=streaming)
+
+    @staticmethod
+    def _extract_text_content(content) -> str:
+        """
+        从消息内容中提取纯文本，过滤掉思考/推理类型的内容块。
+        :param content: 消息内容，可能是字符串或内容块列表
+        :return: 纯文本内容
+        """
+        if not content:
+            return ""
+        # 跳过思考/推理类型的内容块
+        if isinstance(content, list):
+            text_parts = []
+            for block in content:
+                if isinstance(block, str):
+                    text_parts.append(block)
+                elif isinstance(block, dict):
+                    # 优先检查 thought 标志（LangChain Google GenAI 方案）
+                    if block.get("thought"):
+                        continue
+                    if block.get("type") in (
+                        "thinking",
+                        "reasoning_content",
+                        "reasoning",
+                        "thought",
+                    ):
+                        continue
+                    if block.get("type") == "text":
+                        text_parts.append(block.get("text", ""))
+                    else:
+                        text_parts.append(str(block))
+            return "".join(text_parts)
+        return str(content)
+
+    def _initialize_tools(self) -> List:
+        """
+        初始化工具列表
+        """
+        return MoviePilotToolFactory.create_tools(
+            session_id=self.session_id,
+            user_id=self.user_id,
+            channel=self.channel,
+            source=self.source,
+            username=self.username,
+            stream_handler=self.stream_handler,
+        )
+
+    def _create_agent(self, streaming: bool = False):
+        """
+        创建 LangGraph Agent（使用 create_agent + SummarizationMiddleware）
+        :param streaming: 是否启用流式输出
+        """
+        try:
+            # 系统提示词
+            system_prompt = prompt_manager.get_agent_prompt(channel=self.channel)
+
+            # LLM 模型（用于 agent 执行）
+            llm = self._initialize_llm(streaming=streaming)
+
+            # 工具列表
+            tools = self._initialize_tools()
+
+            # 中间件
+            middlewares = [
+                # Skills
+                SkillsMiddleware(
+                    sources=[str(settings.CONFIG_PATH / "agent" / "skills")],
+                    bundled_skills_dir=str(settings.ROOT_PATH / "skills"),
+                ),
+                # Jobs 任务管理
+                JobsMiddleware(
+                    sources=[str(settings.CONFIG_PATH / "agent" / "jobs")],
+                ),
+                # 记忆管理（自动扫描 agent 目录下所有 .md 文件）
+                MemoryMiddleware(memory_dir=str(settings.CONFIG_PATH / "agent")),
+                # 活动日志
+                ActivityLogMiddleware(
+                    activity_dir=str(settings.CONFIG_PATH / "agent" / "activity"),
+                ),
+                # 上下文压缩
+                SummarizationMiddleware(model=llm, trigger=("fraction", 0.85)),
+                # 错误工具调用修复
+                PatchToolCallsMiddleware(),
+            ]
+
+            # 工具选择
+            if settings.LLM_MAX_TOOLS > 0:
+                middlewares.append(
+                    LLMToolSelectorMiddleware(
+                        model=llm, max_tools=settings.LLM_MAX_TOOLS
+                    )
+                )
+
+            return create_agent(
+                model=llm,
+                tools=tools,
+                system_prompt=system_prompt,
+                middleware=middlewares,
+                checkpointer=InMemorySaver(),
+            )
+        except Exception as e:
+            logger.error(f"创建 Agent 失败: {e}")
+            raise e
+
+    async def process(self, message: str, images: List[str] = None) -> str:
+        """
+        处理用户消息，流式推理并返回 Agent 回复
+        """
+        try:
+            logger.info(
+                f"Agent推理: session_id={self.session_id}, input={message}, images={len(images) if images else 0}"
+            )
+
+            # 获取历史消息
+            messages = memory_manager.get_agent_messages(
+                session_id=self.session_id, user_id=self.user_id
+            )
+
+            # 构建用户消息内容
+            if images:
+                content = []
+                if message:
+                    content.append({"type": "text", "text": message})
+                for img in images:
+                    content.append({"type": "image_url", "image_url": {"url": img}})
+                messages.append(HumanMessage(content=content))
+            else:
+                messages.append(HumanMessage(content=message))
+
+            # 执行推理
+            await self._execute_agent(messages)
+
+        except Exception as e:
+            error_message = f"处理消息时发生错误: {str(e)}"
+            logger.error(error_message)
+            await self.send_agent_message(error_message)
+            return error_message
+
+    async def _stream_agent_tokens(
+        self, agent, messages: dict, config: dict, on_token: Callable[[str], None]
+    ):
+        """
+        流式运行智能体，过滤工具调用token和思考内容，将模型生成的内容通过回调输出。
+        :param agent: LangGraph Agent 实例
+        :param messages: Agent 输入消息
+        :param config: Agent 运行配置
+        :param on_token: 收到有效 token 时的回调
+        """
+        stripper = _ThinkTagStripper()
+        # 非VERBOSE模式下，跟踪当前langgraph_step以检测中间步骤的模型输出
+        # 当模型在工具调用之前输出的"计划/思考"文本，会在检测到tool_call时被清除
+        current_model_step = -1
+        has_emitted_in_step = False
+
+        async for chunk in agent.astream(
+            messages,
+            stream_mode="messages",
+            config=config,
+            subgraphs=False,
+            version="v2",
+        ):
+            if chunk["type"] == "messages":
+                token, metadata = chunk["data"]
+                if not token or not hasattr(token, "tool_call_chunks"):
+                    continue
+
+                # 获取当前步骤信息
+                step = metadata.get("langgraph_step", -1) if metadata else -1
+
+                if token.tool_call_chunks:
+                    # 检测到工具调用token：说明当前步骤是中间步骤
+                    # 非VERBOSE模式下，清除该步骤之前输出的"计划/思考"文本
+                    if not settings.AI_AGENT_VERBOSE and has_emitted_in_step:
+                        self.stream_handler.reset()
+                        stripper.reset()
+                        has_emitted_in_step = False
+                    continue
+
+                # 以下处理纯文本token（tool_call_chunks为空）
+
+                # 检测步骤变化，重置步骤内emit跟踪
+                if step != current_model_step:
+                    current_model_step = step
+                    has_emitted_in_step = False
+
+                # 跳过模型思考/推理内容（如 DeepSeek R1 的 reasoning_content）
+                additional = getattr(token, "additional_kwargs", None)
+                if additional and additional.get("reasoning_content"):
+                    continue
+
+                if token.content:
+                    # content 可能是字符串或内容块列表，过滤掉思考类型的块
+                    content = self._extract_text_content(token.content)
+                    if content:
+                        if stripper.process(content, on_token):
+                            has_emitted_in_step = True
+
+        stripper.flush(on_token)
+
+    async def _execute_agent(self, messages: List[BaseMessage]):
+        """
+        调用 LangGraph Agent 执行推理。
+        根据运行环境选择不同的执行模式：
+        - 后台任务模式（无渠道信息）：非流式 LLM + ainvoke，仅广播最终结果
+        - 渠道不支持消息编辑：非流式 LLM + ainvoke，完成后发送最终回复
+        - 渠道支持消息编辑：流式 LLM + astream，实时推送 token
+        """
+        try:
+            # Agent运行配置
+            agent_config = {
+                "configurable": {
+                    "thread_id": self.session_id,
+                }
+            }
+
+            # 判断是否启用流式输出
+            use_streaming = self._should_stream()
+
+            # 创建智能体（根据是否流式传入不同 LLM）
+            agent = self._create_agent(streaming=use_streaming)
+
+            if use_streaming:
+                # 流式模式：渠道支持消息编辑，启动流式输出实时推送 token
+                await self.stream_handler.start_streaming(
+                    channel=self.channel,
+                    source=self.source,
+                    user_id=self.user_id,
+                    username=self.username,
+                )
+
+                # 流式运行智能体，token 直接推送到 stream_handler
+                await self._stream_agent_tokens(
+                    agent=agent,
+                    messages={"messages": messages},
+                    config=agent_config,
+                    on_token=self.stream_handler.emit,
+                )
+
+                # 停止流式输出，返回是否已通过流式编辑发送了所有内容及最终文本
+                (
+                    all_sent_via_stream,
+                    streamed_text,
+                ) = await self.stream_handler.stop_streaming()
+
+                if not all_sent_via_stream:
+                    # 流式输出未能发送全部内容（发送失败等）
+                    # 通过常规方式发送剩余内容
+                    remaining_text = await self.stream_handler.take()
+                    if remaining_text:
+                        await self.send_agent_message(remaining_text)
+                elif streamed_text:
+                    # 流式输出已发送全部内容，但未记录到数据库，补充保存消息记录
+                    await self._save_agent_message_to_db(streamed_text)
+
+            else:
+                # 非流式模式：后台任务或渠道不支持消息编辑
+                await agent.ainvoke(
+                    {"messages": messages},
+                    config=agent_config,
+                )
+
+                # 从最终状态中提取最后一条AI回复内容
+                final_messages = agent.get_state(agent_config).values.get(
+                    "messages", []
+                )
+                final_text = ""
+                for msg in reversed(final_messages):
+                    if hasattr(msg, "type") and msg.type == "ai" and msg.content:
+                        # 过滤掉思考/推理内容，只提取纯文本
+                        text = self._extract_text_content(msg.content)
+                        if text:
+                            # 过滤掉包含在 <think> 标签中的内容
+                            text = re.sub(
+                                r"<think>.*?(?:</think>|$)", "", text, flags=re.DOTALL
+                            )
+                            final_text = text.strip()
+                            break
+
+                if final_text:
+                    if self.is_background:
+                        # 后台任务仅广播最终回复，带标题
+                        await self.send_agent_message(
+                            final_text, title="MoviePilot助手"
+                        )
+                    else:
+                        # 非流式渠道：发送最终回复
+                        await self.send_agent_message(final_text)
+
+            # 保存消息
+            memory_manager.save_agent_messages(
+                session_id=self.session_id,
+                user_id=self.user_id,
+                messages=agent.get_state(agent_config).values.get("messages", []),
+            )
+
+        except asyncio.CancelledError:
+            logger.info(f"Agent执行被取消: session_id={self.session_id}")
+            return "任务已取消", {}
+        except Exception as e:
+            logger.error(f"Agent执行失败: {e} - {traceback.format_exc()}")
+            return str(e), {}
+        finally:
+            # 确保停止流式输出
+            await self.stream_handler.stop_streaming()
+
+    async def send_agent_message(self, message: str, title: str = ""):
+        """
+        通过原渠道发送消息给用户
+        """
+        user_id = self.user_id
+        if self.user_id == "system":
+            user_id = None
+
+        await AgentChain().async_post_message(
+            Notification(
+                channel=self.channel,
+                source=self.source,
+                mtype=NotificationType.Agent,
+                userid=user_id,
+                username=self.username,
+                title=title,
+                text=message,
+            )
+        )
+
+    async def _save_agent_message_to_db(self, message: str, title: str = ""):
+        """
+        仅保存Agent回复消息到数据库和SSE队列（不重新发送到渠道）
+        用于流式输出场景：消息已通过 send_direct_message/edit_message 发送给用户，
+        但未记录到数据库中，此方法补充保存消息历史记录。
+        """
+        chain = AgentChain()
+        notification = Notification(
+            channel=self.channel,
+            source=self.source,
+            userid=self.user_id,
+            username=self.username,
+            title=title,
+            text=message,
+        )
+        # 保存到SSE消息队列（供前端展示）
+        chain.messagehelper.put(notification, role="user", title=title)
+        # 保存到数据库
+        await chain.messageoper.async_add(**notification.model_dump())
+
+    async def cleanup(self):
+        """
+        清理智能体资源
+        """
+        logger.info(f"MoviePilot智能体已清理: session_id={self.session_id}")
+
+
+@dataclass
+class _MessageTask:
+    """
+    待处理的消息任务
+    """
+
+    session_id: str
+    user_id: str
+    message: str
+    images: Optional[List[str]] = None
+    channel: Optional[str] = None
+    source: Optional[str] = None
+    username: Optional[str] = None
+
+
+class AgentManager:
+    """
+    AI智能体管理器
+    同一会话的消息按顺序排队处理，不同会话之间互不影响。
+    """
+
+    # 批量重试整理的等待时间（秒），同一批次内的失败记录会合并为一次agent调用
+    RETRY_TRANSFER_DEBOUNCE_SECONDS = 300
+
+    def __init__(self):
+        self.active_agents: Dict[str, MoviePilotAgent] = {}
+        # 每个会话的消息队列
+        self._session_queues: Dict[str, asyncio.Queue] = {}
+        # 每个会话的worker任务
+        self._session_workers: Dict[str, asyncio.Task] = {}
+        # 重试整理的 debounce 缓冲区: group_key -> List[history_id]
+        self._retry_transfer_buffer: Dict[str, List[int]] = {}
+        # 重试整理的 debounce 定时器: group_key -> asyncio.TimerHandle
+        self._retry_transfer_timers: Dict[str, asyncio.TimerHandle] = {}
+        # 重试整理缓冲区锁
+        self._retry_transfer_lock = asyncio.Lock()
+
+    @staticmethod
+    async def initialize():
+        """
+        初始化管理器
+        """
+        memory_manager.initialize()
+
+    async def close(self):
+        """
+        关闭管理器
+        """
+        await memory_manager.close()
+        # 取消所有重试整理的延迟定时器
+        for timer in self._retry_transfer_timers.values():
+            timer.cancel()
+        self._retry_transfer_timers.clear()
+        self._retry_transfer_buffer.clear()
+        # 取消所有会话worker
+        for task in self._session_workers.values():
+            task.cancel()
+        # 等待所有worker结束
+        for session_id, task in self._session_workers.items():
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+        self._session_workers.clear()
+        self._session_queues.clear()
+        for agent in self.active_agents.values():
+            await agent.cleanup()
+        self.active_agents.clear()
+
+    async def process_message(
+        self,
+        session_id: str,
+        user_id: str,
+        message: str,
+        images: List[str] = None,
+        channel: str = None,
+        source: str = None,
+        username: str = None,
+    ) -> str:
+        """
+        处理用户消息：将消息放入会话队列，按顺序依次处理。
+        同一会话的消息排队等待，不同会话之间互不影响。
+        """
+        task = _MessageTask(
+            session_id=session_id,
+            user_id=user_id,
+            message=message,
+            images=images,
+            channel=channel,
+            source=source,
+            username=username,
+        )
+
+        # 获取或创建会话队列
+        if session_id not in self._session_queues:
+            self._session_queues[session_id] = asyncio.Queue()
+
+        queue = self._session_queues[session_id]
+        queue_size = queue.qsize()
+
+        # 如果队列中已有等待的消息，通知用户消息已排队
+        if queue_size > 0 or (
+            session_id in self._session_workers
+            and not self._session_workers[session_id].done()
+        ):
+            logger.info(
+                f"会话 {session_id} 有任务正在处理，消息已排队等待 "
+                f"(队列中待处理: {queue_size} 条)"
+            )
+
+        # 放入队列
+        await queue.put(task)
+
+        # 确保该会话有一个worker在运行
+        if (
+            session_id not in self._session_workers
+            or self._session_workers[session_id].done()
+        ):
+            self._session_workers[session_id] = asyncio.create_task(
+                self._session_worker(session_id)
+            )
+
+        return ""
+
+    async def _session_worker(self, session_id: str):
+        """
+        会话消息处理worker：从队列中逐条取出消息并处理。
+        处理完当前消息后才会处理下一条，确保同一会话的消息顺序执行。
+        """
+        queue = self._session_queues.get(session_id)
+        if not queue:
+            return
+
+        try:
+            while True:
+                try:
+                    # 等待消息，超时后自动退出worker
+                    task = await asyncio.wait_for(queue.get(), timeout=60.0)
+                except asyncio.TimeoutError:
+                    # 队列空闲超时，退出worker
+                    logger.debug(f"会话 {session_id} 的消息队列空闲，worker退出")
+                    break
+
+                try:
+                    await self._process_message_internal(task)
+                except Exception as e:
+                    logger.error(f"处理会话 {session_id} 的消息失败: {e}")
+                finally:
+                    queue.task_done()
+
+        except asyncio.CancelledError:
+            logger.info(f"会话 {session_id} 的worker被取消")
+        finally:
+            # 清理已完成的worker记录
+            self._session_workers.pop(session_id, None)  # noqa
+            # 如果队列为空，清理队列
+            if (
+                session_id in self._session_queues
+                and self._session_queues[session_id].empty()
+            ):
+                self._session_queues.pop(session_id, None)
+
+    async def _process_message_internal(self, task: _MessageTask):
+        """
+        实际处理单条消息
+        """
+        session_id = task.session_id
+        if session_id not in self.active_agents:
+            logger.info(
+                f"创建新的AI智能体实例，session_id: {session_id}, user_id: {task.user_id}"
+            )
+            agent = MoviePilotAgent(
+                session_id=session_id,
+                user_id=task.user_id,
+                channel=task.channel,
+                source=task.source,
+                username=task.username,
+            )
+            self.active_agents[session_id] = agent
+        else:
+            agent = self.active_agents[session_id]
+            agent.user_id = task.user_id
+            if task.channel:
+                agent.channel = task.channel
+            if task.source:
+                agent.source = task.source
+            if task.username:
+                agent.username = task.username
+
+        return await agent.process(task.message, images=task.images)
+
+    async def stop_current_task(self, session_id: str):
+        """
+        应急停止当前正在执行的Agent推理任务，但保留会话和记忆。
+        与 clear_session 不同，此方法不会销毁Agent实例或清除记忆，
+        用户可以在停止后继续对话。
+        """
+        stopped = False
+
+        # 取消该会话的worker（会触发 _execute_agent 中的 CancelledError）
+        if session_id in self._session_workers:
+            self._session_workers[session_id].cancel()
+            try:
+                await self._session_workers[session_id]
+            except asyncio.CancelledError:
+                pass
+            self._session_workers.pop(session_id, None)  # noqa
+            stopped = True
+
+        # 清空队列中待处理的消息
+        if session_id in self._session_queues:
+            queue = self._session_queues[session_id]
+            while not queue.empty():
+                try:
+                    queue.get_nowait()
+                    queue.task_done()
+                except asyncio.QueueEmpty:
+                    break
+            self._session_queues.pop(session_id, None)
+            stopped = True
+
+        if stopped:
+            logger.info(f"会话 {session_id} 的Agent推理已应急停止")
+        else:
+            logger.debug(f"会话 {session_id} 没有正在执行的Agent任务")
+
+        return stopped
+
+    async def clear_session(self, session_id: str, user_id: str):
+        """
+        清空会话
+        """
+        # 取消该会话的worker
+        if session_id in self._session_workers:
+            self._session_workers[session_id].cancel()
+            try:
+                await self._session_workers[session_id]
+            except asyncio.CancelledError:
+                pass
+            await self._session_workers.pop(session_id, None)
+
+        # 清理队列
+        self._session_queues.pop(session_id, None)
+
+        # 清理agent
+        if session_id in self.active_agents:
+            agent = self.active_agents[session_id]
+            await agent.cleanup()
+            del self.active_agents[session_id]
+            memory_manager.clear_memory(session_id, user_id)
+            logger.info(f"会话 {session_id} 的记忆已清空")
+
+    async def heartbeat_check_jobs(self):
+        """
+        心跳唤醒：检查并执行待处理的定时任务（Jobs）。
+        由定时调度器周期性调用，每次使用独立的会话避免上下文干扰。
+        """
+        try:
+            # 每次使用唯一的 session_id，避免共享上下文
+            session_id = f"__agent_heartbeat_{uuid.uuid4().hex[:12]}__"
+            user_id = "system"
+
+            logger.info("智能体心跳唤醒：开始检查待处理任务...")
+
+            # 英文提示词，便于大模型理解
+            heartbeat_message = (
+                "[System Heartbeat] Check all jobs in your jobs directory and process pending tasks:\n"
+                "1. List all jobs with status 'pending' or 'in_progress'\n"
+                "2. For 'recurring' jobs, check 'last_run' to determine if it's time to run again\n"
+                "3. For 'once' jobs with status 'pending', execute them now\n"
+                "4. After executing each job, update its status, 'last_run' time, and execution log in the JOB.md file\n"
+                "5. If there are no pending jobs, do NOT generate any response\n\n"
+                "IMPORTANT: This is a background system task, NOT a user conversation. "
+                "Your final response will be broadcast as a notification. "
+                "Only output a brief completion summary listing each executed job and its result. "
+                "Do NOT include greetings, explanations, or conversational text. "
+                "If no jobs were executed, output nothing. "
+                "Respond in Chinese (中文)."
+            )
+
+            await self.process_message(
+                session_id=session_id,
+                user_id=user_id,
+                message=heartbeat_message,
+                channel=None,
+                source=None,
+                username=settings.SUPERUSER,
+            )
+
+            # 等待消息队列处理完成
+            if session_id in self._session_queues:
+                await self._session_queues[session_id].join()
+
+            # 等待worker结束
+            if session_id in self._session_workers:
+                try:
+                    await self._session_workers[session_id]
+                except asyncio.CancelledError:
+                    pass
+
+            logger.info("智能体心跳唤醒：任务检查完成")
+
+            # 心跳会话用完即弃，清理资源
+            await self.clear_session(session_id, user_id)
+
+        except Exception as e:
+            logger.error(f"智能体心跳唤醒失败: {e}")
+
+    async def retry_failed_transfer(self, history_id: int, group_key: str = ""):
+        """
+        触发智能体重新整理失败的历史记录。
+        由文件整理模块在检测到整理失败后调用。
+        同一 group_key 的失败记录会在缓冲期内合并为一次agent调用，避免重复浪费token。
+        :param history_id: 失败的整理历史记录ID
+        :param group_key: 分组键，相同key的记录会被合并处理（如download_hash、源目录等）
+        """
+        if not group_key:
+            group_key = f"_default_{history_id}"
+
+        async with self._retry_transfer_lock:
+            # 将 history_id 加入缓冲区
+            if group_key not in self._retry_transfer_buffer:
+                self._retry_transfer_buffer[group_key] = []
+            if history_id not in self._retry_transfer_buffer[group_key]:
+                self._retry_transfer_buffer[group_key].append(history_id)
+                logger.info(
+                    f"智能体重试整理：记录 ID={history_id} 已加入缓冲区 "
+                    f"(group={group_key}, 当前{len(self._retry_transfer_buffer[group_key])}条)"
+                )
+
+            # 取消该分组的旧定时器
+            if group_key in self._retry_transfer_timers:
+                self._retry_transfer_timers[group_key].cancel()
+
+            # 设置新的延迟定时器
+            loop = asyncio.get_running_loop()
+            self._retry_transfer_timers[group_key] = loop.call_later(
+                self.RETRY_TRANSFER_DEBOUNCE_SECONDS,
+                lambda gk=group_key: asyncio.ensure_future(
+                    self._flush_retry_transfer(gk)
+                ),
+            )
+
+    async def _flush_retry_transfer(self, group_key: str):
+        """
+        延迟定时器到期后，取出该分组的所有 history_id 并合并为一次agent调用。
+        """
+        async with self._retry_transfer_lock:
+            history_ids = self._retry_transfer_buffer.pop(group_key, [])
+            self._retry_transfer_timers.pop(group_key, None)
+
+        if not history_ids:
+            return
+
+        session_id = f"__agent_retry_transfer_batch_{uuid.uuid4().hex[:8]}__"
+        user_id = "system"
+
+        ids_str = ", ".join(str(i) for i in history_ids)
+        logger.info(
+            f"智能体重试整理：开始批量处理失败记录 IDs=[{ids_str}] (group={group_key})"
+        )
+
+        if len(history_ids) == 1:
+            # 单条记录，使用原有逻辑
+            retry_message = (
+                f"[System Task - Transfer Failed Retry] A file transfer/organization has failed. "
+                f"Please use the 'transfer-failed-retry' skill to retry the failed transfer.\n\n"
+                f"Failed transfer history record ID: {history_ids[0]}\n\n"
+                f"Follow these steps:\n"
+                f"1. Use `query_transfer_history` with status='failed' to find the record with id={history_ids[0]} "
+                f"and understand the failure details (source path, error message, media info)\n"
+                f"2. Analyze the error message to determine the best retry strategy\n"
+                f"3. If the source file no longer exists, skip this retry and report that the file is missing\n"
+                f"4. Delete the failed history record using `delete_transfer_history` with history_id={history_ids[0]}\n"
+                f"5. Re-identify the media using `recognize_media` with the source file path\n"
+                f"6. If recognition fails, try `search_media` with keywords from the filename\n"
+                f"7. Re-transfer using `transfer_file` with the source path and any identified media info (tmdbid, media_type)\n"
+                f"8. Report the final result\n\n"
+                f"IMPORTANT: This is a background system task, NOT a user conversation. "
+                f"Your final response will be broadcast as a notification. "
+                f"Only output a brief result summary. "
+                f"Do NOT include greetings, explanations, or conversational text. "
+                f"Respond in Chinese (中文)."
+            )
+        else:
+            # 多条记录，使用批量处理逻辑
+            retry_message = (
+                f"[System Task - Batch Transfer Failed Retry] Multiple file transfers from the same source "
+                f"have failed. These files likely belong to the SAME media (e.g., multiple episodes of the same TV show). "
+                f"Please use the 'transfer-failed-retry' skill to retry them efficiently.\n\n"
+                f"Failed transfer history record IDs: {ids_str}\n"
+                f"Total failed records: {len(history_ids)}\n\n"
+                f"Follow these steps:\n"
+                f"1. Use `query_transfer_history` with status='failed' to find ALL records with these IDs "
+                f"and understand the failure details\n"
+                f"2. Since these files are likely from the same media, analyze the FIRST record to determine "
+                f"the media identity and the best retry strategy. The root cause is usually the same for all files.\n"
+                f"3. If the error is about media recognition (e.g., '未识别到媒体信息'), identify the media ONCE "
+                f"using `recognize_media` or `search_media`, then reuse that result (tmdbid, media_type) for all files\n"
+                f"4. For EACH failed record:\n"
+                f"   a. Delete the failed history record using `delete_transfer_history`\n"
+                f"   b. Re-transfer using `transfer_file` with the source path and the identified media info\n"
+                f"5. Report a summary of results (how many succeeded, how many failed)\n\n"
+                f"IMPORTANT OPTIMIZATION: These files share the same media identity. "
+                f"Do NOT call `recognize_media` or `search_media` repeatedly for each file. "
+                f"Identify the media ONCE, then apply to all files.\n\n"
+                f"IMPORTANT: This is a background system task, NOT a user conversation. "
+                f"Your final response will be broadcast as a notification. "
+                f"Only output a brief result summary. "
+                f"Do NOT include greetings, explanations, or conversational text. "
+                f"Respond in Chinese (中文)."
+            )
+
+        try:
+
+            await self.process_message(
+                session_id=session_id,
+                user_id=user_id,
+                message=retry_message,
+                channel=None,
+                source=None,
+                username=settings.SUPERUSER,
+            )
+
+            # 等待消息队列处理完成
+            if session_id in self._session_queues:
+                await self._session_queues[session_id].join()
+
+            # 等待worker结束
+            if session_id in self._session_workers:
+                try:
+                    await self._session_workers[session_id]
+                except asyncio.CancelledError:
+                    pass
+
+            logger.info(
+                f"智能体重试整理：批量处理完成 IDs=[{ids_str}] (group={group_key})"
+            )
+
+            # 用完即弃，清理资源
+            await self.clear_session(session_id, user_id)
+
+        except Exception as e:
+            logger.error(
+                f"智能体重试整理失败 (IDs=[{ids_str}], group={group_key}): {e}"
+            )
+
+
+# 全局智能体管理器实例
+agent_manager = AgentManager()

app/agent/callback/__init__.py

@@ -0,0 +1,362 @@
+import asyncio
+import threading
+from typing import Optional, Tuple
+
+from app.chain import ChainBase
+from app.log import logger
+from app.schemas import Notification
+from app.schemas.message import (
+    MessageResponse,
+    ChannelCapabilityManager,
+    ChannelCapability,
+)
+from app.schemas.types import MessageChannel
+
+
+class _StreamChain(ChainBase):
+    pass
+
+
+class StreamingHandler:
+    """
+    流式Token缓冲管理器
+
+    负责从 LLM 流式 token 中积累文本，并在支持消息编辑的渠道上实时推送给用户。
+
+    工作流程：
+    1. Agent开始处理时调用 start_streaming()，检查渠道能力并启动定时刷新
+    2. LLM 产生 token 时调用 emit() 积累到缓冲区
+    3. 定时器周期性调用 _flush()：
+       - 第一次有内容时发送新消息（通过 send_direct_message 获取 message_id）
+       - 后续有新内容时编辑同一条消息（通过 edit_message）
+       - 当消息长度接近渠道限制时，冻结当前消息并发送新消息继续输出
+    4. 工具调用时：
+       - 流式渠道：工具消息直接 emit() 追加到 buffer，与 Agent 文字合并为同一条流式消息
+       - 非流式渠道：调用 take() 取出已积累的文字，与工具消息合并独立发送
+    5. Agent最终完成时调用 stop_streaming()：执行最后一次刷新，
+       返回是否已通过流式发送完所有内容（调用方据此决定是否还需额外发送）
+    """
+
+    # 流式输出的刷新间隔（秒）
+    FLUSH_INTERVAL = 0.3
+
+    def __init__(self):
+        self._lock = threading.Lock()
+        self._buffer = ""
+        # 流式输出相关状态
+        self._streaming_enabled = False
+        self._flush_task: Optional[asyncio.Task] = None
+        # 当前消息的发送信息（用于编辑消息）
+        self._message_response: Optional[MessageResponse] = None
+        # 已发送给用户的文本（用于追踪增量）
+        self._sent_text = ""
+        # 当前消息的起始偏移量（buffer 中属于当前消息的起始位置）
+        self._msg_start_offset = 0
+        # 当前渠道的单条消息最大长度（0 表示不限制）
+        self._max_message_length = 0
+        # 消息发送所需的上下文信息
+        self._channel: Optional[str] = None
+        self._source: Optional[str] = None
+        self._user_id: Optional[str] = None
+        self._username: Optional[str] = None
+        self._title: str = ""
+
+    def emit(self, token: str):
+        """
+        接收 LLM 流式 token，积累到缓冲区。
+        """
+        with self._lock:
+            # 如果存量消息结束是两个换行，则去掉新消息前面的换行，避免过多空行
+            if self._buffer.endswith("\n\n") and token.startswith("\n"):
+                token = token.lstrip("\n")
+            self._buffer += token
+
+    async def take(self) -> str:
+        """
+        获取当前已积累的消息内容，获取后清空缓冲区。
+
+        用于非流式渠道：工具调用前取出 Agent 已产出的文字，
+        与工具提示合并后独立发送。
+
+        注意：流式渠道不调用此方法，工具消息直接 emit 到 buffer 中。
+        """
+        with self._lock:
+            if not self._buffer:
+                return ""
+            message = self._buffer
+            logger.info(f"Agent消息: {message}")
+            self._buffer = ""
+            return message
+
+    def clear(self):
+        """
+        清空缓冲区（不返回内容）
+        """
+        with self._lock:
+            self._buffer = ""
+            self._sent_text = ""
+            self._message_response = None
+            self._msg_start_offset = 0
+
+    def reset(self):
+        """
+        重置缓冲区，清空已发送的文本从头更新，但保持消息编辑能力。
+
+        与 clear 的区别：
+        - clear：完全重置所有状态，后续会开新消息
+        - reset：只清空buffer，保留消息编辑状态，后续继续编辑同一条消息
+        """
+        with self._lock:
+            self._buffer = ""
+            self._sent_text = ""
+            self._msg_start_offset = 0
+
+    async def start_streaming(
+        self,
+        channel: Optional[str] = None,
+        source: Optional[str] = None,
+        user_id: Optional[str] = None,
+        username: Optional[str] = None,
+        title: str = "",
+    ):
+        """
+        启动流式输出。
+        始终标记为流式状态（用于 buffer 收集 token），
+        但只有渠道支持消息编辑时才启动定时刷新任务（实时推送给用户）。
+        :param channel: 消息渠道
+        :param source: 消息来源
+        :param user_id: 用户ID
+        :param username: 用户名
+        :param title: 消息标题
+        """
+        self._channel = channel
+        self._source = source
+        self._user_id = user_id
+        self._username = username
+        self._title = title
+
+        self._streaming_enabled = True
+        self._sent_text = ""
+        self._message_response = None
+        self._msg_start_offset = 0
+
+        # 检查渠道是否支持消息编辑，不支持则仅收集 token 到 buffer，不实时推送
+        if not self._can_stream():
+            logger.debug(f"渠道 {channel} 不支持消息编辑，仅启用 buffer 收集模式")
+            return
+
+        # 从渠道能力中获取单条消息最大长度
+        try:
+            channel_enum = MessageChannel(self._channel)
+            self._max_message_length = ChannelCapabilityManager.get_max_message_length(
+                channel_enum
+            )
+        except (ValueError, KeyError):
+            self._max_message_length = 0
+
+        # 启动异步定时刷新任务
+        self._flush_task = asyncio.create_task(self._flush_loop())
+        logger.debug("流式输出已启动")
+
+    async def stop_streaming(self) -> Tuple[bool, str]:
+        """
+        停止流式输出。执行最后一次刷新确保所有内容都已发送。
+        :return: (all_sent, final_text)
+                 all_sent: 是否已经通过流式编辑将最终完整内容发送给了用户
+                           （True 表示调用方无需再额外发送消息）
+                 final_text: 流式发送的完整文本内容（用于调用方保存消息记录）
+        """
+        if not self._streaming_enabled:
+            return False, ""
+
+        self._streaming_enabled = False
+
+        # 取消定时任务
+        await self._cancel_flush_task()
+
+        # 执行最后一次刷新
+        await self._flush()
+
+        # 检查是否所有缓冲内容都已发送
+        with self._lock:
+            # 当前消息的文本 = buffer 中从 _msg_start_offset 开始的部分
+            current_msg_text = self._buffer[self._msg_start_offset :]
+            all_sent = (
+                self._message_response is not None
+                and self._sent_text
+                and current_msg_text == self._sent_text
+            )
+            # 保留最终文本用于返回（返回完整 buffer 内容，包含所有分段消息）
+            final_text = self._buffer if all_sent else ""
+            # 重置状态
+            self._sent_text = ""
+            self._message_response = None
+            self._msg_start_offset = 0
+            if all_sent:
+                # 所有内容已通过流式发送，清空缓冲区
+                self._buffer = ""
+            return all_sent, final_text
+
+    def _can_stream(self) -> bool:
+        """
+        检查当前渠道是否支持流式输出（消息编辑）
+        """
+        if not self._channel:
+            return False
+        try:
+            channel_enum = MessageChannel(self._channel)
+            return ChannelCapabilityManager.supports_capability(
+                channel_enum, ChannelCapability.MESSAGE_EDITING
+            )
+        except (ValueError, KeyError):
+            return False
+
+    async def _flush_loop(self):
+        """
+        定时刷新循环，定期将缓冲区内容发送/编辑到用户
+        """
+        try:
+            while self._streaming_enabled:
+                await asyncio.sleep(self.FLUSH_INTERVAL)
+                if self._streaming_enabled:
+                    await self._flush()
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error(f"流式刷新异常: {e}")
+
+    async def _cancel_flush_task(self):
+        """
+        取消当前的定时刷新任务
+        """
+        if self._flush_task and not self._flush_task.done():
+            self._flush_task.cancel()
+            try:
+                await self._flush_task
+            except asyncio.CancelledError:
+                pass
+            self._flush_task = None
+
+    async def _flush(self):
+        """
+        将当前缓冲区内容刷新到用户消息
+        - 如果还没有发送过消息，先发送一条新消息并记录message_id
+        - 如果已经发送过消息，编辑该消息为最新的完整内容
+        - 如果当前消息内容超过长度限制，冻结当前消息并发送新消息继续输出
+        """
+        with self._lock:
+            # 当前消息的文本 = buffer 中从 _msg_start_offset 开始的部分
+            current_text = self._buffer[self._msg_start_offset :]
+            if not current_text or current_text == self._sent_text:
+                # 没有新内容需要刷新
+                return
+
+        chain = _StreamChain()
+
+        try:
+            if self._message_response is None:
+                # 第一次发送：发送新消息并获取 message_id
+                response = chain.send_direct_message(
+                    Notification(
+                        channel=self._channel,
+                        source=self._source,
+                        userid=self._user_id,
+                        username=self._username,
+                        title=self._title,
+                        text=current_text,
+                    )
+                )
+                if response and response.success and response.message_id:
+                    self._message_response = response
+                    with self._lock:
+                        self._sent_text = current_text
+                    logger.debug(
+                        f"流式输出初始消息已发送: message_id={response.message_id}"
+                    )
+                else:
+                    logger.debug(
+                        "流式输出初始消息发送失败或未返回message_id，降级为非流式输出"
+                    )
+                    self._streaming_enabled = False
+            else:
+                # 检查当前消息内容是否超过长度限制
+                if (
+                    self._max_message_length
+                    and len(current_text) > self._max_message_length
+                ):
+                    # 消息过长，冻结当前消息（保持最后一次成功编辑的内容）
+                    # 将 offset 移动到已发送文本之后，开启新消息
+                    logger.debug(
+                        f"流式消息长度 {len(current_text)} 超过限制 {self._max_message_length}，启用新消息"
+                    )
+                    with self._lock:
+                        self._msg_start_offset += len(self._sent_text)
+                        current_text = self._buffer[self._msg_start_offset :]
+                    self._message_response = None
+                    self._sent_text = ""
+
+                    # 如果偏移后还有新内容，立即发送为新消息
+                    if current_text:
+                        response = chain.send_direct_message(
+                            Notification(
+                                channel=self._channel,
+                                source=self._source,
+                                userid=self._user_id,
+                                username=self._username,
+                                title=self._title,
+                                text=current_text,
+                            )
+                        )
+                        if response and response.success and response.message_id:
+                            self._message_response = response
+                            with self._lock:
+                                self._sent_text = current_text
+                            logger.debug(
+                                f"流式输出新消息已发送: message_id={response.message_id}"
+                            )
+                        else:
+                            logger.debug("流式输出新消息发送失败，降级为非流式输出")
+                            self._streaming_enabled = False
+                else:
+                    # 后续更新：编辑已有消息
+                    try:
+                        channel_enum = MessageChannel(self._channel)
+                    except (ValueError, KeyError):
+                        return
+
+                    success = chain.edit_message(
+                        channel=channel_enum,
+                        source=self._message_response.source,
+                        message_id=self._message_response.message_id,
+                        chat_id=self._message_response.chat_id,
+                        text=current_text,
+                        title=self._title,
+                    )
+                    if success:
+                        with self._lock:
+                            self._sent_text = current_text
+                    else:
+                        logger.debug("流式输出消息编辑失败")
+        except Exception as e:
+            logger.error(f"流式输出刷新失败: {e}")
+
+    @property
+    def is_streaming(self) -> bool:
+        """
+        是否正在流式输出
+        """
+        return self._streaming_enabled
+
+    @property
+    def is_auto_flushing(self) -> bool:
+        """
+        是否正在定时刷新（渠道支持消息编辑时自动推送 buffer 内容）
+        """
+        return self._flush_task is not None
+
+    @property
+    def has_sent_message(self) -> bool:
+        """
+        是否已经通过流式输出发送过消息（当前轮次）
+        """
+        return self._message_response is not None

app/agent/memory/__init__.py

@@ -0,0 +1,154 @@
+"""对话记忆管理器"""
+
+import asyncio
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from langchain_core.messages import BaseMessage
+
+from app.core.config import settings
+from app.log import logger
+from app.schemas.agent import ConversationMemory
+
+
+class MemoryManager:
+    """
+    对话记忆管理器
+    """
+
+    def __init__(self):
+        # 内存中的会话记忆缓存
+        self.memory_cache: Dict[str, ConversationMemory] = {}
+        # 内存缓存清理任务
+        self.cleanup_task: Optional[asyncio.Task] = None
+
+    def initialize(self):
+        """
+        初始化记忆管理器
+        """
+        try:
+            # 启动内存缓存清理任务（Redis通过TTL自动过期）
+            self.cleanup_task = asyncio.create_task(
+                self._cleanup_expired_memories()
+            )
+            logger.info("对话记忆管理器初始化完成")
+
+        except Exception as e:
+            logger.warning(f"Redis连接失败，将使用内存存储: {e}")
+
+    async def close(self):
+        """
+        关闭记忆管理器
+        """
+        if self.cleanup_task:
+            self.cleanup_task.cancel()
+            try:
+                await self.cleanup_task
+            except asyncio.CancelledError:
+                pass
+
+        logger.info("对话记忆管理器已关闭")
+
+    @staticmethod
+    def _get_memory_key(session_id: str, user_id: str):
+        """
+        计算内存Key
+        """
+        return f"{user_id}:{session_id}" if user_id else session_id
+
+    def get_memory(self, session_id: str, user_id: str) -> Optional[ConversationMemory]:
+        """
+        获取内存中的记忆
+        """
+        cache_key = self._get_memory_key(session_id, user_id)
+        return self.memory_cache.get(cache_key)
+
+    def get_agent_messages(
+            self, session_id: str, user_id: str
+    ) -> List[BaseMessage]:
+        """
+        为Agent获取最近的消息（仅内存缓存）
+
+        如果消息Token数量超过模型最大上下文长度的阀值，会自动进行摘要裁剪
+        """
+        memory = self.get_memory(session_id, user_id)
+        if not memory:
+            return []
+
+        # 获取所有消息
+        return memory.messages
+
+    def save_agent_messages(
+            self, session_id: str, user_id: str, messages: List[BaseMessage]
+    ):
+        """
+        保存Agent消息（仅内存缓存）
+
+        注意：Redis中的记忆通过TTL机制自动过期，这里只更新内存缓存，Redis会在下次访问时自动过期
+        """
+        memory = self.get_memory(session_id, user_id)
+        if not memory:
+            memory = ConversationMemory(session_id=session_id, user_id=user_id)
+
+        memory.messages = messages
+        memory.updated_at = datetime.now()
+
+        # 更新内存缓存
+        self.save_memory(memory)
+
+    def save_memory(self, memory: ConversationMemory):
+        """
+        保存记忆到内存缓存
+
+        注意：Redis中的记忆通过TTL机制自动过期，这里只更新内存缓存，Redis会在下次访问时自动过期
+        """
+        cache_key = self._get_memory_key(memory.session_id, memory.user_id)
+        self.memory_cache[cache_key] = memory
+
+    def clear_memory(self, session_id: str, user_id: str):
+        """
+        清空会话记忆
+        """
+        cache_key = self._get_memory_key(session_id, user_id)
+        if cache_key in self.memory_cache:
+            del self.memory_cache[cache_key]
+
+        logger.info(f"会话记忆已清空: session_id={session_id}, user_id={user_id}")
+
+    async def _cleanup_expired_memories(self):
+        """
+        清理内存中过期记忆的后台任务
+
+        注意：Redis中的记忆通过TTL机制自动过期，这里只清理内存缓存
+        """
+        while True:
+            try:
+                # 每小时清理一次
+                await asyncio.sleep(3600)
+
+                current_time = datetime.now()
+                expired_sessions = []
+
+                # 只检查内存缓存中的过期记忆
+                # Redis中的记忆会通过TTL自动过期，无需手动处理
+                for cache_key, memory in self.memory_cache.items():
+                    if (
+                            current_time - memory.updated_at
+                    ).days > settings.LLM_MEMORY_RETENTION_DAYS:
+                        expired_sessions.append(cache_key)
+
+                # 只清理内存缓存，不删除Redis中的键（Redis会自动过期）
+                for cache_key in expired_sessions:
+                    if cache_key in self.memory_cache:
+                        del self.memory_cache[cache_key]
+
+                if expired_sessions:
+                    logger.info(f"清理了{len(expired_sessions)}个过期内存会话记忆")
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"清理记忆时发生错误: {e}")
+
+
+memory_manager = MemoryManager()

app/agent/middleware/activity_log.py

@@ -0,0 +1,406 @@
+"""
+活动日志中间件 - 自动记录 Agent 每次交互的操作摘要。
+
+按日期存储在 CONFIG_PATH/agent/activity/YYYY-MM-DD.md 中，
+每次 Agent 执行完毕后自动调用 LLM 对本轮对话生成简洁的活动摘要，
+并在每次 Agent 启动时加载近几天的活动日志注入系统提示词。
+"""
+
+import re
+from collections.abc import Awaitable, Callable
+from datetime import datetime, timedelta
+from typing import Annotated, Any, NotRequired, TypedDict
+
+from anyio import Path as AsyncPath
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    AgentState,
+    ContextT,
+    ModelRequest,
+    ModelResponse,
+    PrivateStateAttr,  # noqa
+    ResponseT,
+)
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from langgraph.runtime import Runtime
+
+from app.agent.middleware.utils import append_to_system_message
+from app.log import logger
+
+# 活动日志保留天数
+DEFAULT_RETENTION_DAYS = 7
+
+# 注入系统提示词时加载的天数
+PROMPT_LOAD_DAYS = 3
+
+# 每日日志文件最大大小 (256KB)
+MAX_LOG_FILE_SIZE = 256 * 1024
+
+# 提取本轮对话上下文的最大字符数（避免过长的对话消耗太多 token）
+MAX_CONTEXT_FOR_SUMMARY = 4000
+
+# LLM 总结的提示词
+SUMMARY_PROMPT = """请根据以下 AI 助手与用户的对话记录，生成一条简洁的活动摘要（中文，一句话，不超过80字）。
+摘要应包含：用户的需求是什么、助手做了什么、结果如何。
+只输出摘要内容，不要加任何前缀、标点序号或解释。
+
+对话记录：
+{conversation}"""
+
+
+class ActivityLogState(AgentState):
+    """ActivityLogMiddleware 的状态模型。"""
+
+    activity_log_contents: NotRequired[Annotated[dict[str, str], PrivateStateAttr]]
+    """将日期字符串映射到日志内容的字典。标记为私有，不包含在最终代理状态中。"""
+
+
+class ActivityLogStateUpdate(TypedDict):
+    """ActivityLogMiddleware 的状态更新。"""
+
+    activity_log_contents: dict[str, str]
+
+
+def _extract_last_round(messages: list) -> list | None:
+    """从完整消息列表中提取最后一轮交互。
+
+    从最后一条 HumanMessage 到消息末尾即为本轮交互。
+
+    参数：
+        messages: Agent 执行后的完整消息列表。
+
+    返回：
+        本轮交互的消息子列表，如果无有效交互则返回 None。
+    """
+    if not messages:
+        return None
+
+    # 找到最后一条用户消息的索引
+    last_human_idx = None
+    for i in range(len(messages) - 1, -1, -1):
+        if isinstance(messages[i], HumanMessage) and messages[i].content:
+            last_human_idx = i
+            break
+
+    if last_human_idx is None:
+        return None
+
+    round_messages = messages[last_human_idx:]
+
+    # 检查是否为系统心跳消息
+    user_msg = round_messages[0]
+    user_content = (
+        user_msg.content if isinstance(user_msg.content, str) else str(user_msg.content)
+    )
+    if user_content.strip().startswith("[System Heartbeat]"):
+        return None
+
+    return round_messages
+
+
+def _format_conversation_for_summary(round_messages: list) -> str:
+    """将本轮对话消息格式化为文本，供 LLM 总结。
+
+    参数：
+        round_messages: 本轮交互的消息列表。
+
+    返回：
+        格式化后的对话文本。
+    """
+    lines = []
+    total_len = 0
+
+    for msg in round_messages:
+        if isinstance(msg, HumanMessage):
+            content = msg.content if isinstance(msg.content, str) else str(msg.content)
+            line = f"用户: {content}"
+        elif isinstance(msg, AIMessage):
+            if hasattr(msg, "tool_calls") and msg.tool_calls:
+                tool_names = [
+                    tc["name"]
+                    for tc in msg.tool_calls
+                    if isinstance(tc, dict) and "name" in tc
+                ]
+                line = f"助手调用工具: {', '.join(tool_names)}"
+            elif msg.content:
+                content = (
+                    msg.content if isinstance(msg.content, str) else str(msg.content)
+                )
+                line = f"助手: {content}"
+            else:
+                continue
+        elif isinstance(msg, ToolMessage):
+            content = msg.content if isinstance(msg.content, str) else str(msg.content)
+            # 工具返回可能很长，截断
+            if len(content) > 200:
+                content = content[:200] + "..."
+            line = f"工具返回: {content}"
+        else:
+            continue
+
+        # 控制总长度
+        if total_len + len(line) > MAX_CONTEXT_FOR_SUMMARY:
+            lines.append("...(后续对话省略)")
+            break
+        lines.append(line)
+        total_len += len(line)
+
+    return "\n".join(lines)
+
+
+async def _summarize_with_llm(conversation_text: str) -> str | None:
+    """调用 LLM 对对话文本生成活动摘要。
+
+    参数：
+        conversation_text: 格式化后的对话文本。
+
+    返回：
+        LLM 生成的摘要字符串，失败时返回 None。
+    """
+    try:
+        from app.helper.llm import LLMHelper
+
+        llm = LLMHelper.get_llm(streaming=False)
+        prompt = SUMMARY_PROMPT.format(conversation=conversation_text)
+        response = await llm.ainvoke(prompt)
+        summary = response.content.strip()
+        # 清理模型可能输出的前缀（如 "摘要：" "总结："）
+        summary = re.sub(r"^(摘要|总结|活动记录)[：:]\s*", "", summary)
+        return summary if summary else None
+    except Exception as e:
+        logger.debug("LLM summarization failed: %s", e)
+        return None
+
+
+ACTIVITY_LOG_SYSTEM_PROMPT = """<activity_log>
+{activity_log}
+</activity_log>
+
+<activity_log_guidelines>
+    The above <activity_log> contains a record of your recent interactions with the user, automatically maintained by the system.
+    
+    **How to use this information:**
+    - Reference past activities when relevant to provide continuity (e.g., "之前帮你订阅了《XXX》，现在有更新了")
+    - Use activity history to understand ongoing tasks and user patterns
+    - When the user asks "你之前帮我做了什么" or similar questions, refer to this log
+    - Activity logs are automatically recorded after each interaction - you do NOT need to manually update them
+    
+    **What is automatically logged:**
+    - Each user interaction: what was asked, which tools were used, and the outcome
+    - Timestamps for all activities
+    - The log is organized by date for easy reference
+    
+    **Important:**
+    - Activity logs are READ-ONLY from your perspective - the system manages them automatically
+    - Do not attempt to edit or write to activity log files
+    - For long-term preferences and knowledge, continue to use MEMORY.md
+    - Activity logs are retained for {retention_days} days and then automatically cleaned up
+</activity_log_guidelines>
+"""
+
+
+class ActivityLogMiddleware(AgentMiddleware[ActivityLogState, ContextT, ResponseT]):  # noqa
+    """自动记录和加载 Agent 活动日志的中间件。
+
+    - abefore_agent: 加载近几天的活动日志
+    - awrap_model_call: 将活动日志注入系统提示词
+    - aafter_agent: 从本次对话中提取摘要并追加到当日日志文件
+
+    参数：
+        activity_dir: 活动日志存储目录路径。
+        retention_days: 日志保留天数（默认 7 天）。
+        prompt_load_days: 注入系统提示词时加载的天数（默认 3 天）。
+    """
+
+    state_schema = ActivityLogState
+
+    def __init__(
+        self,
+        *,
+        activity_dir: str,
+        retention_days: int = DEFAULT_RETENTION_DAYS,
+        prompt_load_days: int = PROMPT_LOAD_DAYS,
+    ) -> None:
+        self.activity_dir = activity_dir
+        self.retention_days = retention_days
+        self.prompt_load_days = prompt_load_days
+
+    def _get_log_path(self, date_str: str) -> AsyncPath:
+        """获取指定日期的日志文件路径。"""
+        return AsyncPath(self.activity_dir) / f"{date_str}.md"
+
+    def _format_activity_log(self, contents: dict[str, str]) -> str:
+        """格式化活动日志用于系统提示词注入。"""
+        if not contents:
+            return ACTIVITY_LOG_SYSTEM_PROMPT.format(
+                activity_log="(暂无活动记录)",
+                retention_days=self.retention_days,
+            )
+
+        # 按日期排序（最近的在前）
+        sorted_dates = sorted(contents.keys(), reverse=True)
+        sections = []
+        for date_str in sorted_dates:
+            content = contents[date_str].strip()
+            if content:
+                sections.append(f"### {date_str}\n{content}")
+
+        if not sections:
+            return ACTIVITY_LOG_SYSTEM_PROMPT.format(
+                activity_log="(暂无活动记录)",
+                retention_days=self.retention_days,
+            )
+
+        log_body = "\n\n".join(sections)
+        return ACTIVITY_LOG_SYSTEM_PROMPT.format(
+            activity_log=log_body,
+            retention_days=self.retention_days,
+        )
+
+    async def _load_recent_logs(self) -> dict[str, str]:
+        """加载近几天的活动日志。"""
+        contents: dict[str, str] = {}
+        today = datetime.now().date()
+
+        for i in range(self.prompt_load_days):
+            date = today - timedelta(days=i)
+            date_str = date.strftime("%Y-%m-%d")
+            log_path = self._get_log_path(date_str)
+
+            if await log_path.exists():
+                try:
+                    content = await log_path.read_text(encoding="utf-8")
+                    contents[date_str] = content
+                    logger.debug("Loaded activity log for %s", date_str)
+                except Exception as e:
+                    logger.warning("Failed to load activity log %s: %s", date_str, e)
+
+        return contents
+
+    async def _append_activity(self, summary: str) -> None:
+        """将一条活动记录追加到当日日志文件。"""
+        today_str = datetime.now().strftime("%Y-%m-%d")
+        now_str = datetime.now().strftime("%H:%M")
+        log_path = self._get_log_path(today_str)
+
+        # 确保目录存在
+        dir_path = AsyncPath(self.activity_dir)
+        if not await dir_path.exists():
+            await dir_path.mkdir(parents=True, exist_ok=True)
+
+        # 检查文件大小
+        if await log_path.exists():
+            stat = await log_path.stat()
+            if stat.st_size >= MAX_LOG_FILE_SIZE:
+                logger.warning(
+                    "Activity log %s exceeds size limit (%d bytes), skipping append",
+                    today_str,
+                    stat.st_size,
+                )
+                return
+
+        # 追加记录
+        entry = f"- **{now_str}** {summary}\n"
+        try:
+            if await log_path.exists():
+                existing = await log_path.read_text(encoding="utf-8")
+                await log_path.write_text(existing + entry, encoding="utf-8")
+            else:
+                header = f"# {today_str} 活动日志\n\n"
+                await log_path.write_text(header + entry, encoding="utf-8")
+            logger.debug("Activity logged: %s", summary[:80])
+        except Exception as e:
+            logger.warning("Failed to append activity log: %s", e)
+
+    async def _cleanup_old_logs(self) -> None:
+        """清理超过保留天数的旧日志文件。"""
+        dir_path = AsyncPath(self.activity_dir)
+        if not await dir_path.exists():
+            return
+
+        cutoff_date = datetime.now().date() - timedelta(days=self.retention_days)
+        date_pattern = re.compile(r"^(\d{4}-\d{2}-\d{2})\.md$")
+
+        try:
+            async for path in dir_path.iterdir():
+                if not await path.is_file():
+                    continue
+                match = date_pattern.match(path.name)
+                if not match:
+                    continue
+                try:
+                    file_date = datetime.strptime(match.group(1), "%Y-%m-%d").date()
+                    if file_date < cutoff_date:
+                        await path.unlink()
+                        logger.debug("Cleaned up old activity log: %s", path.name)
+                except ValueError:
+                    continue
+        except Exception as e:
+            logger.warning("Failed to cleanup old activity logs: %s", e)
+
+    async def abefore_agent(
+        self, state: ActivityLogState, runtime: Runtime
+    ) -> ActivityLogStateUpdate | None:
+        """在 Agent 执行前加载近期活动日志。"""
+        # 如果已经加载则跳过
+        if "activity_log_contents" in state:
+            return None
+
+        contents = await self._load_recent_logs()
+
+        # 趁机清理旧日志（低频操作，不影响性能）
+        await self._cleanup_old_logs()
+
+        return ActivityLogStateUpdate(activity_log_contents=contents)
+
+    def modify_request(self, request: ModelRequest[ContextT]) -> ModelRequest[ContextT]:
+        """将活动日志注入系统消息。"""
+        contents = request.state.get("activity_log_contents", {})
+        activity_log_prompt = self._format_activity_log(contents)
+
+        new_system_message = append_to_system_message(
+            request.system_message, activity_log_prompt
+        )
+        return request.override(system_message=new_system_message)
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest[ContextT],
+        handler: Callable[
+            [ModelRequest[ContextT]], Awaitable[ModelResponse[ResponseT]]
+        ],
+    ) -> ModelResponse[ResponseT]:
+        """异步包装模型调用，注入活动日志到系统提示词。"""
+        modified_request = self.modify_request(request)
+        return await handler(modified_request)
+
+    async def aafter_agent(
+        self, state: ActivityLogState, runtime: Runtime
+    ) -> dict[str, Any] | None:
+        """Agent 执行完毕后，调用 LLM 对本轮对话生成摘要并追加到当日活动日志。"""
+        try:
+            messages = state.get("messages", [])
+            if not messages:
+                return None
+
+            # 提取本轮交互
+            round_messages = _extract_last_round(messages)
+            if not round_messages:
+                return None
+
+            # 格式化对话文本
+            conversation_text = _format_conversation_for_summary(round_messages)
+            if not conversation_text:
+                return None
+
+            # 调用 LLM 生成摘要
+            summary = await _summarize_with_llm(conversation_text)
+            if summary:
+                await self._append_activity(summary)
+        except Exception as e:
+            logger.warning("Failed to record activity: %s", e)
+
+        return None
+
+
+__all__ = ["ActivityLogMiddleware"]

app/agent/middleware/jobs.py

@@ -0,0 +1,350 @@
+import re
+from collections.abc import Awaitable, Callable
+from typing import Annotated, NotRequired, TypedDict
+
+import yaml  # noqa
+from anyio import Path as AsyncPath
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    AgentState,
+    ContextT,
+    ModelRequest,
+    ModelResponse,
+    PrivateStateAttr,  # noqa
+    ResponseT,
+)
+from langchain_core.runnables import RunnableConfig
+from langgraph.runtime import Runtime
+
+from app.agent.middleware.utils import append_to_system_message
+from app.log import logger
+
+# JOB.md 文件最大限制为 1MB
+MAX_JOB_FILE_SIZE = 1 * 1024 * 1024
+
+
+class JobMetadata(TypedDict):
+    """Job 元数据。"""
+
+    path: str
+    """JOB.md 文件路径。"""
+
+    id: str
+    """Job 标识符（目录名）。"""
+
+    name: str
+    """Job 名称。"""
+
+    description: str
+    """Job 描述。"""
+
+    schedule: str
+    """调度类型: once（一次性）/ recurring（重复性）。"""
+
+    status: str
+    """当前状态: pending / in_progress / completed / cancelled。"""
+
+    last_run: str | None
+    """上次执行时间。"""
+
+
+class JobsState(AgentState):
+    """jobs 中间件状态。"""
+
+    jobs_metadata: NotRequired[Annotated[list[JobMetadata], PrivateStateAttr]]
+    """已加载的 job 元数据列表，不传播给父 agent。"""
+
+
+class JobsStateUpdate(TypedDict):
+    """jobs 中间件状态更新项。"""
+
+    jobs_metadata: list[JobMetadata]
+    """待合并的 job 元数据列表。"""
+
+
+def _parse_job_metadata(
+    content: str,
+    job_path: str,
+    job_id: str,
+) -> JobMetadata | None:
+    """从 JOB.md 内容中解析 YAML 前言并验证元数据。"""
+    if len(content) > MAX_JOB_FILE_SIZE:
+        logger.warning(
+            "Skipping %s: content too large (%d bytes)", job_path, len(content)
+        )
+        return None
+
+    # 匹配 --- 分隔的 YAML 前言
+    frontmatter_pattern = r"^---\s*\n(.*?)\n---\s*\n"
+    match = re.match(frontmatter_pattern, content, re.DOTALL)
+    if not match:
+        logger.warning("Skipping %s: no valid YAML frontmatter found", job_path)
+        return None
+    frontmatter_str = match.group(1)
+
+    # 解析 YAML
+    try:
+        frontmatter_data = yaml.safe_load(frontmatter_str)
+    except yaml.YAMLError as e:
+        logger.warning("Invalid YAML in %s: %s", job_path, e)
+        return None
+
+    if not isinstance(frontmatter_data, dict):
+        logger.warning("Skipping %s: frontmatter is not a mapping", job_path)
+        return None
+
+    # Job 名称和描述
+    name = str(frontmatter_data.get("name", "")).strip()
+    description = str(frontmatter_data.get("description", "")).strip()
+    if not name:
+        logger.warning("Skipping %s: missing required 'name'", job_path)
+        return None
+
+    # 调度类型
+    schedule = str(frontmatter_data.get("schedule", "once")).strip().lower()
+    if schedule not in ("once", "recurring"):
+        schedule = "once"
+
+    # 状态
+    status = str(frontmatter_data.get("status", "pending")).strip().lower()
+    if status not in ("pending", "in_progress", "completed", "cancelled"):
+        status = "pending"
+
+    # 上次执行时间
+    last_run = str(frontmatter_data.get("last_run", "")).strip() or None
+
+    return JobMetadata(
+        id=job_id,
+        name=name,
+        description=description,
+        path=job_path,
+        schedule=schedule,
+        status=status,
+        last_run=last_run,
+    )
+
+
+async def _alist_jobs(source_path: AsyncPath) -> list[JobMetadata]:
+    """异步列出指定路径下的所有任务。
+
+    扫描包含 JOB.md 的目录并解析其元数据。
+    """
+    jobs: list[JobMetadata] = []
+
+    if not await source_path.exists():
+        return []
+
+    # 查找所有任务目录（包含 JOB.md 的目录）
+    job_dirs: list[AsyncPath] = []
+    async for path in source_path.iterdir():
+        if await path.is_dir() and await (path / "JOB.md").is_file():
+            job_dirs.append(path)
+
+    if not job_dirs:
+        return []
+
+    # 解析 JOB.md
+    for job_path in job_dirs:
+        job_md_path = job_path / "JOB.md"
+
+        job_content = await job_md_path.read_text(encoding="utf-8")
+
+        # 解析元数据
+        job_metadata = _parse_job_metadata(
+            content=job_content,
+            job_path=str(job_md_path),
+            job_id=job_path.name,
+        )
+        if job_metadata:
+            jobs.append(job_metadata)
+
+    return jobs
+
+
+JOBS_SYSTEM_PROMPT = """
+<jobs_system>
+You have a **scheduled jobs** system that allows you to track and execute long-running or recurring tasks.
+
+**Jobs Location:** `{jobs_location}`
+
+**Current Jobs:**
+
+{jobs_list}
+
+**Job File Format:**
+
+Each job is a directory containing a `JOB.md` file with YAML frontmatter followed by task details:
+
+```markdown
+---
+name: 任务名称（简短中文描述）
+description: 任务的详细描述，说明要做什么
+schedule: once 或 recurring
+status: pending / in_progress / completed / cancelled
+last_run: "YYYY-MM-DD HH:MM"（上次执行时间，可选）
+---
+# 任务详情
+
+## 目标
+详细描述这个任务要完成的目标。
+
+## 执行日志
+记录每次执行的情况和结果。
+
+- **2024-01-15 10:00** - 执行了XXX操作，结果：成功/失败
+- **2024-01-16 10:00** - 继续执行XXX...
+```
+
+**Job Lifecycle Rules:**
+
+1. **Creating a Job**: When a user asks you to do something periodically or at a later time:
+   - Create a new directory under the jobs location, directory name is the `job-id` (lowercase, hyphens, 1-64 chars)
+   - Write a `JOB.md` file with proper frontmatter and detailed task description
+   - Set `schedule: once` for one-time tasks, `schedule: recurring` for repeating tasks (e.g., daily sign-in, weekly checks)
+   - Set initial `status: pending`
+
+2. **Executing a Job**: When you work on a job:
+   - Update `status: in_progress` in the frontmatter
+   - Execute the required actions using your tools
+   - Log the execution result in the "执行日志" section with timestamp
+   - Update `last_run` in frontmatter to current time
+
+3. **Completing a Job**:
+   - For `schedule: once` tasks: set `status: completed` after successful execution
+   - For `schedule: recurring` tasks: keep `status: pending` after execution, only update `last_run` time. The job stays active for the next scheduled run.
+   - Set `status: cancelled` if the user explicitly asks to cancel/stop a task
+
+4. **Heartbeat Check**: You will be periodically woken up to check pending jobs. When woken up:
+   - Read the jobs directory to find all active jobs (status: pending or in_progress)
+   - Skip jobs with `status: completed` or `status: cancelled`
+   - For `schedule: recurring` jobs, check `last_run` to determine if it's time to run again
+   - Execute pending jobs and update their status/logs accordingly
+
+**Important Notes:**
+- Each job MUST have its own separate directory and JOB.md file to avoid conflicts
+- Always update the frontmatter fields (status, last_run) when executing a job
+- Keep execution logs concise but informative
+- For recurring jobs, maintain a rolling log (keep recent entries, you can summarize/remove old entries to keep the file manageable)
+- When creating jobs, make the description detailed enough that you can understand and execute the task in future sessions without additional context
+
+**When to Create Jobs:**
+- User says "每天帮我..." / "定期..." / "定时..." / "提醒我..." / "以后每次..."
+- User requests a task that should be done repeatedly
+- User asks for monitoring or periodic checking of something
+
+**When NOT to Create Jobs:**
+- User asks for an immediate one-time action (just do it now)
+- Simple questions or conversations
+- Tasks that are already handled by MoviePilot's built-in scheduler services
+</jobs_system>
+"""
+
+
+class JobsMiddleware(AgentMiddleware[JobsState, ContextT, ResponseT]):  # noqa
+    """加载并向系统提示词注入 Agent Jobs 的中间件。
+
+    扫描 jobs 目录下的 JOB.md 文件，解析元数据并注入到系统提示词中，
+    使智能体了解当前的长期任务及其状态。
+    """
+
+    state_schema = JobsState
+
+    def __init__(self, *, sources: list[str]) -> None:
+        """初始化 Jobs 中间件。"""
+        self.sources = sources
+        self.system_prompt_template = JOBS_SYSTEM_PROMPT
+
+    @staticmethod
+    def _format_jobs_list(jobs: list[JobMetadata]) -> str:
+        """格式化任务元数据列表用于系统提示词。"""
+        if not jobs:
+            return "(No active jobs. You can create jobs when users request periodic or scheduled tasks.)"
+
+        lines = []
+        for job in jobs:
+            status_emoji = {
+                "pending": "⏳",
+                "in_progress": "🔄",
+                "completed": "✅",
+                "cancelled": "❌",
+            }.get(job["status"], "❓")
+
+            schedule_label = (
+                "recurring (重复)"
+                if job["schedule"] == "recurring"
+                else "once (一次性)"
+            )
+            desc_line = (
+                f"- {status_emoji} **{job['id']}**: {job['name']}"
+                f" [{schedule_label}] - {job['description']}"
+            )
+            if job.get("last_run"):
+                desc_line += f" (上次执行: {job['last_run']})"
+            lines.append(desc_line)
+            lines.append(f"  -> Read `{job['path']}` for full details")
+
+        return "\n".join(lines)
+
+    def modify_request(self, request: ModelRequest[ContextT]) -> ModelRequest[ContextT]:
+        """将任务文档注入模型请求的系统消息中。"""
+        jobs_metadata = request.state.get("jobs_metadata", [])  # noqa
+
+        # 过滤：只展示活跃任务（pending / in_progress / recurring）
+        active_jobs = [
+            j
+            for j in jobs_metadata
+            if j["status"] in ("pending", "in_progress")
+            or (j["schedule"] == "recurring" and j["status"] not in ("cancelled",))
+        ]
+
+        jobs_list = self._format_jobs_list(active_jobs)
+        jobs_location = self.sources[0] if self.sources else ""
+
+        jobs_section = self.system_prompt_template.format(
+            jobs_location=jobs_location,
+            jobs_list=jobs_list,
+        )
+
+        new_system_message = append_to_system_message(
+            request.system_message, jobs_section
+        )
+
+        return request.override(system_message=new_system_message)
+
+    async def abefore_agent(  # noqa
+        self, state: JobsState, runtime: Runtime, config: RunnableConfig
+    ) -> JobsStateUpdate | None:
+        """在 Agent 执行前异步加载任务元数据。
+
+        每个会话仅加载一次。若 state 中已有则跳过。
+        """
+        # 如果 state 中已存在元数据则跳过
+        if "jobs_metadata" in state:
+            return None
+
+        all_jobs: list[JobMetadata] = []
+
+        # 遍历源加载任务
+        for source_path_str in self.sources:
+            source_path = AsyncPath(source_path_str)
+            if not await source_path.exists():
+                await source_path.mkdir(parents=True, exist_ok=True)
+                continue
+            source_jobs = await _alist_jobs(source_path)
+            all_jobs.extend(source_jobs)
+
+        return JobsStateUpdate(jobs_metadata=all_jobs)
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest[ContextT],
+        handler: Callable[
+            [ModelRequest[ContextT]], Awaitable[ModelResponse[ResponseT]]
+        ],
+    ) -> ModelResponse[ResponseT]:
+        """在模型调用时注入任务文档。"""
+        modified_request = self.modify_request(request)
+        return await handler(modified_request)
+
+
+__all__ = ["JobMetadata", "JobsMiddleware"]

app/agent/middleware/memory.py

@@ -0,0 +1,396 @@
+from collections.abc import Awaitable, Callable
+from typing import Annotated, NotRequired, TypedDict, Dict
+
+from anyio import Path as AsyncPath
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    AgentState,
+    ContextT,
+    ModelRequest,
+    ModelResponse,
+    PrivateStateAttr,  # noqa
+    ResponseT,
+)
+from langchain_core.runnables import RunnableConfig
+from langgraph.runtime import Runtime
+
+from app.agent.middleware.utils import append_to_system_message
+from app.log import logger
+
+# 记忆文件最大限制为 100KB，防止单文件过大导致上下文溢出
+MAX_MEMORY_FILE_SIZE = 100 * 1024
+
+# 默认记忆文件名（用户主记忆）
+DEFAULT_MEMORY_FILE = "MEMORY.md"
+
+
+class MemoryState(AgentState):
+    """`MemoryMiddleware` 的状态模型。
+
+    属性：
+        memory_contents: 将源路径映射到其加载内容的字典。
+            标记为私有，因此不包含在最终的代理状态中。
+        memory_empty: 记忆文件是否为空或不存在。
+            标记为私有，用于判断是否需要触发初始化引导流程。
+    """
+
+    memory_contents: NotRequired[Annotated[dict[str, str], PrivateStateAttr]]
+    memory_empty: NotRequired[Annotated[bool, PrivateStateAttr]]
+
+
+class MemoryStateUpdate(TypedDict):
+    """`MemoryMiddleware` 的状态更新。"""
+
+    memory_contents: dict[str, str]
+    memory_empty: bool
+
+
+MEMORY_SYSTEM_PROMPT = """<agent_memory>
+The following memory files were loaded from your memory directory: `{memory_dir}`
+You can create, edit, or organize any `.md` files in this directory to manage your knowledge.
+
+{agent_memory}
+</agent_memory>
+
+<memory_guidelines>
+    The above <agent_memory> was loaded from `.md` files in your memory directory (`{memory_dir}`). As you learn from your interactions with the user, you can save new knowledge by calling the `edit_file` or `write_file` tool on files in this directory.
+
+    **Memory file organization:**
+    - All `.md` files in `{memory_dir}` are automatically loaded as memory.
+    - `MEMORY.md` is the default/primary memory file for general user preferences and profile.
+    - You may create additional `.md` files to organize knowledge by topic (e.g., `MEDIA_RULES.md`, `DOWNLOAD_PREFERENCES.md`, `SITE_CONFIGS.md`, etc.).
+    - Keep each file focused on a specific domain or topic for better organization.
+    - Subdirectories are NOT scanned — only `.md` files directly in `{memory_dir}`.
+
+    **Learning from feedback:**
+    - One of your MAIN PRIORITIES is to learn from your interactions with the user. These learnings can be implicit or explicit. This means that in the future, you will remember this important information.
+    - When you need to remember something, updating memory must be your FIRST, IMMEDIATE action - before responding to the user, before calling other tools, before doing anything else. Just update memory immediately.
+    - When user says something is better/worse, capture WHY and encode it as a pattern.
+    - Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions.
+    - A great opportunity to update your memories is when the user interrupts a tool call and provides feedback. You should update your memories immediately before revising the tool call.
+    - Look for the underlying principle behind corrections, not just the specific mistake.
+    - The user might not explicitly ask you to remember something, but if they provide information that is useful for future use, you should update your memories immediately.
+
+    **Asking for information:**
+    - If you lack context to perform an action (e.g. send a Slack DM, requires a user ID/email) you should explicitly ask the user for this information.
+    - It is preferred for you to ask for information, don't assume anything that you do not know!
+    - When the user provides information that is useful for future use, you should update your memories immediately.
+
+    **When to update memories:**
+    - When the user explicitly asks you to remember something (e.g., "remember my email", "save this preference")
+    - When the user describes your role or how you should behave (e.g., "you are a web researcher", "always do X")
+    - When the user gives feedback on your work - capture what was wrong and how to improve
+    - When the user provides information required for tool use (e.g., slack channel ID, email addresses)
+    - When the user provides context useful for future tasks, such as how to use tools, or which actions to take in a particular situation
+    - When you discover new patterns or preferences (coding styles, conventions, workflows)
+
+    **When to NOT update memories:**
+    - When the information is temporary or transient (e.g., "I'm running late", "I'm on my phone right now")
+    - When the information is a one-time task request (e.g., "Find me a recipe", "What's 25 * 4?")
+    - When the information is a simple question that doesn't reveal lasting preferences (e.g., "What day is it?", "Can you explain X?")
+    - When the information is an acknowledgment or small talk (e.g., "Sounds good!", "Hello", "Thanks for that")
+    - When the information is stale or irrelevant in future conversations
+    - Never store API keys, access tokens, passwords, or any other credentials in any file, memory, or system prompt.
+    - If the user asks where to put API keys or provides an API key, do NOT echo or save it.
+    - Do NOT record daily activities or task execution history in memory files - these are automatically tracked in the activity log system (see <activity_log>). Memory files are only for long-term knowledge, preferences, and patterns.
+
+    **Examples:**
+    Example 1 (remembering user information):
+    User: Can you connect to my google account?
+    Agent: Sure, I'll connect to your google account, what's your google account email?
+    User: john@example.com
+    Agent: Let me save this to my memory.
+    Tool Call: edit_file(...) -> remembers that the user's google account email is john@example.com
+
+    Example 2 (remembering implicit user preferences):
+    User: Can you write me an example for creating a deep agent in LangChain?
+    Agent: Sure, I'll write you an example for creating a deep agent in LangChain <example code in Python>
+    User: Can you do this in JavaScript
+    Agent: Let me save this to my memory.
+    Tool Call: edit_file(...) -> remembers that the user prefers to get LangChain code examples in JavaScript
+    Agent: Sure, here is the JavaScript example<example code in JavaScript>
+
+    Example 3 (do not remember transient information):
+    User: I'm going to play basketball tonight so I will be offline for a few hours.
+    Agent: Okay I'll add a block to your calendar.
+    Tool Call: create_calendar_event(...) -> just calls a tool, does not commit anything to memory, as it is transient information
+</memory_guidelines>
+"""
+
+MEMORY_ONBOARDING_PROMPT = """<agent_memory>
+(No memory loaded — this is a brand new user with no saved preferences.)
+Memory directory: {memory_dir}
+Default memory file: {memory_file}
+</agent_memory>
+
+<memory_onboarding>
+    **IMPORTANT — First-time user detected!**
+
+    The memory directory is currently empty. This means this is likely the user's first interaction, or their preferences have been reset.
+
+    **Your MANDATORY first action in this conversation:**
+    Before doing ANYTHING else (before answering questions, before calling tools, before performing any task), you MUST proactively greet the user warmly and ask them about their preferences so you can provide personalized service going forward. Specifically, ask about:
+
+    1. **How to address the user** — Ask what name or nickname they'd like you to call them (e.g., a real name, a nickname, or a fun title). This is the top priority for building a personal connection.
+    2. **Communication style preference** — Do they prefer a cute/playful tone (with emojis), a formal/professional tone, a concise/minimalist style, or something else?
+    3. **Media preferences** — What types of media do they primarily care about? (e.g., movies, TV shows, anime, documentaries, etc.)
+    4. **Quality preferences** — Do they have preferred video quality (4K, 1080p), codecs (H.265, H.264), or subtitle language preferences?
+    5. **Any other special requests** — Anything else they'd like you to always keep in mind?
+
+    **After the user replies**, you MUST immediately:
+    1. Use the `write_file` tool to save ALL their preferences to the memory file at: `{memory_file}`
+    2. Format the memory file in clean Markdown with clear sections (e.g., `## User Profile`, `## Communication Style`, `## Media Preferences`, etc.)
+    3. The `## User Profile` section MUST include the user's preferred name/nickname at the top
+    4. Only AFTER saving the preferences, proceed to help with whatever the user originally asked about (if anything)
+    5. From this point on, always address the user by their preferred name/nickname in conversations
+    6. You may also create additional `.md` files in the memory directory (`{memory_dir}`) for different topics as needed.
+
+    **If the user skips the preference questions** and directly asks you to do something:
+    - Go ahead and help them with their request first
+    - But still ask about their preferences naturally at the end of the interaction
+    - Save whatever you learn about them (implicit or explicit) to the memory file
+
+    **Example onboarding flow:**
+    The greeting should introduce yourself, explain this is the first meeting, and ask the above questions in a numbered list. Adapt the tone to your persona defined in the base system prompt.
+</memory_onboarding>
+
+<memory_guidelines>
+    Your memory directory is at: {memory_dir}. You can save new knowledge by calling the `edit_file` or `write_file` tool on any `.md` file in this directory.
+
+    **Memory file organization:**
+    - `MEMORY.md` is the default/primary memory file for general user preferences and profile.
+    - You may create additional `.md` files to organize knowledge by topic.
+    - All `.md` files directly in the memory directory are automatically loaded on each conversation.
+
+    **Learning from feedback:**
+    - One of your MAIN PRIORITIES is to learn from your interactions with the user. These learnings can be implicit or explicit. This means that in the future, you will remember this important information.
+    - When you need to remember something, updating memory must be your FIRST, IMMEDIATE action - before responding to the user, before calling other tools, before doing anything else. Just update memory immediately.
+    - When user says something is better/worse, capture WHY and encode it as a pattern.
+    - Each correction is a chance to improve permanently - don't just fix the immediate issue, update your instructions.
+    - The user might not explicitly ask you to remember something, but if they provide information that is useful for future use, you should update your memories immediately.
+
+    **When to update memories:**
+    - When the user explicitly asks you to remember something
+    - When the user describes your role or how you should behave
+    - When the user gives feedback on your work
+    - When the user provides information required for tool use
+    - When you discover new patterns or preferences
+
+    **When to NOT update memories:**
+    - Temporary/transient information
+    - One-time task requests
+    - Simple questions, acknowledgments, or small talk
+    - Never store API keys, access tokens, passwords, or credentials
+    - Do NOT record daily activities in memory files — those go to the activity log
+</memory_guidelines>
+"""
+
+
+class MemoryMiddleware(AgentMiddleware[MemoryState, ContextT, ResponseT]):  # noqa
+    """从代理记忆目录加载所有 MD 文件作为记忆的中间件。
+
+    自动扫描指定目录下的所有 `.md` 文件，加载其内容并注入到系统提示词中。
+    支持多文件记忆组织：用户可以创建多个 `.md` 文件来按主题组织知识。
+
+    参数：
+        memory_dir: 记忆文件目录路径。
+    """
+
+    state_schema = MemoryState
+
+    def __init__(
+        self,
+        *,
+        memory_dir: str,
+    ) -> None:
+        """初始化记忆中间件。
+
+        参数：
+            memory_dir: 记忆文件目录路径（例如，`"/config/agent"`）。
+                        该目录下所有 `.md` 文件都会被自动加载为记忆。
+        """
+        self.memory_dir = memory_dir
+        self.default_memory_file = str(AsyncPath(memory_dir) / DEFAULT_MEMORY_FILE)
+
+    @staticmethod
+    def _is_memory_empty(contents: dict[str, str]) -> bool:
+        """判断记忆内容是否为空。
+
+        检查所有源文件的内容，如果全部为空或仅包含空白字符则返回 True。
+
+        参数：
+            contents: 将源路径映射到内容的字典。
+
+        返回：
+            如果记忆为空则返回 True，否则返回 False。
+        """
+        if not contents:
+            return True
+        return all(not content.strip() for content in contents.values())
+
+    def _format_agent_memory(
+        self, contents: dict[str, str], memory_empty: bool = False
+    ) -> str:
+        """格式化记忆，将位置和内容成对组合。
+
+        当记忆为空时，返回初始化引导提示词，引导智能体主动询问用户偏好。
+        当记忆非空时，返回标准记忆系统提示词，包含所有加载的文件内容。
+
+        参数：
+            contents: 将源路径映射到内容的字典。
+            memory_empty: 记忆是否为空的标志位。
+
+        返回：
+            在 <agent_memory> 标签中包装了位置+内容对的格式化字符串。
+        """
+        # 记忆为空时返回初始化引导提示词
+        if memory_empty or self._is_memory_empty(contents):
+            return MEMORY_ONBOARDING_PROMPT.format(
+                memory_dir=self.memory_dir,
+                memory_file=self.default_memory_file,
+            )
+
+        # 按文件名排序，确保 MEMORY.md 排在最前面
+        sorted_paths = sorted(
+            [p for p in contents if contents[p].strip()],
+            key=lambda p: (0 if AsyncPath(p).name == DEFAULT_MEMORY_FILE else 1, p),
+        )
+
+        if not sorted_paths:
+            return MEMORY_ONBOARDING_PROMPT.format(
+                memory_dir=self.memory_dir,
+                memory_file=self.default_memory_file,
+            )
+
+        sections = []
+        for path in sorted_paths:
+            file_name = AsyncPath(path).name
+            sections.append(f"### {file_name}\n**Path:** `{path}`\n\n{contents[path]}")
+
+        memory_body = "\n\n---\n\n".join(sections)
+        return MEMORY_SYSTEM_PROMPT.format(
+            agent_memory=memory_body,
+            memory_dir=self.memory_dir,
+        )
+
+    async def _scan_memory_files(self) -> list[str]:
+        """扫描记忆目录下的所有 .md 文件。
+
+        仅扫描目录下直接存在的 `.md` 文件（不递归子目录）。
+        文件大小超过限制的将被跳过。
+
+        返回：
+            发现的 .md 文件路径列表。
+        """
+        dir_path = AsyncPath(self.memory_dir)
+        if not await dir_path.exists():
+            return []
+
+        md_files: list[str] = []
+        async for entry in dir_path.iterdir():
+            if await entry.is_file() and entry.name.lower().endswith(".md"):
+                md_files.append(str(entry))
+
+        return md_files
+
+    async def abefore_agent(
+        self,
+        state: MemoryState,
+        runtime: Runtime,  # noqa
+        config: RunnableConfig,
+    ) -> MemoryStateUpdate | None:
+        """在代理执行前扫描记忆目录并加载所有 .md 文件的内容。
+
+        自动发现目录下所有 `.md` 文件并加载其内容到状态中。
+        如果状态中尚未存在则进行加载。
+        同时检测记忆文件是否为空，设置 memory_empty 标志位，
+        以便在系统提示词中触发初始化引导流程。
+
+        参数：
+            state: 当前代理状态。
+            runtime: 运行时上下文。
+            config: Runnable 配置。
+
+        返回：
+            填充了 memory_contents 和 memory_empty 的状态更新。
+        """
+        # 如果已经加载则跳过
+        if "memory_contents" in state:
+            return None
+
+        # 扫描目录下所有 .md 文件
+        md_files = await self._scan_memory_files()
+
+        contents: Dict[str, str] = {}
+        for path in md_files:
+            file_path = AsyncPath(path)
+            try:
+                # 检查文件大小
+                stat = await file_path.stat()
+                if stat.st_size > MAX_MEMORY_FILE_SIZE:
+                    logger.warning(
+                        "Skipping memory file %s: too large (%d bytes, max %d)",
+                        path,
+                        stat.st_size,
+                        MAX_MEMORY_FILE_SIZE,
+                    )
+                    continue
+                contents[path] = await file_path.read_text(encoding="utf-8")
+                logger.debug("Loaded memory from: %s", path)
+            except Exception as e:
+                logger.warning("Failed to read memory file %s: %s", path, e)
+
+        if contents:
+            logger.info(
+                "Loaded %d memory file(s) from %s: %s",
+                len(contents),
+                self.memory_dir,
+                [AsyncPath(p).name for p in contents],
+            )
+
+        # 检测记忆是否为空（文件不存在、文件内容为空白）
+        is_empty = self._is_memory_empty(contents)
+        if is_empty:
+            logger.info(
+                "Memory is empty, onboarding prompt will be activated for user preference collection."
+            )
+
+        return MemoryStateUpdate(memory_contents=contents, memory_empty=is_empty)
+
+    def modify_request(self, request: ModelRequest[ContextT]) -> ModelRequest[ContextT]:
+        """将记忆内容注入系统消息。
+
+        参数：
+            request: 要修改的模型请求。
+
+        返回：
+            将记忆注入系统消息后的修改后请求。
+        """
+        contents = request.state.get("memory_contents", {})  # noqa
+        memory_empty = request.state.get("memory_empty", False)  # noqa
+        agent_memory = self._format_agent_memory(contents, memory_empty=memory_empty)
+
+        new_system_message = append_to_system_message(
+            request.system_message, agent_memory
+        )
+
+        return request.override(system_message=new_system_message)
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest[ContextT],
+        handler: Callable[
+            [ModelRequest[ContextT]], Awaitable[ModelResponse[ResponseT]]
+        ],
+    ) -> ModelResponse[ResponseT]:
+        """异步包装模型调用，将记忆注入系统提示词。
+
+        参数：
+            request: 正在处理的模型请求。
+            handler: 使用修改后的请求进行调用的异步处理函数。
+
+        返回：
+            来自处理函数的模型响应。
+        """
+        modified_request = self.modify_request(request)
+        return await handler(modified_request)

app/agent/middleware/patch_tool_calls.py

@@ -0,0 +1,43 @@
+from typing import Any
+
+from langchain.agents.middleware import AgentMiddleware, AgentState
+from langchain_core.messages import AIMessage, ToolMessage
+from langgraph.runtime import Runtime
+from langgraph.types import Overwrite
+
+
+class PatchToolCallsMiddleware(AgentMiddleware):
+    """修复消息历史中悬空工具调用的中间件。"""
+
+    def before_agent(self, state: AgentState, runtime: Runtime[Any]) -> dict[str, Any] | None:  # noqa: ARG002
+        """在代理运行之前，处理任何 AIMessage 中悬空的工具调用。"""
+        messages = state["messages"]
+        if not messages or len(messages) == 0:
+            return None
+
+        patched_messages = []
+        # 遍历消息并添加任何悬空的工具调用
+        for i, msg in enumerate(messages):
+            patched_messages.append(msg)
+            if isinstance(msg, AIMessage) and msg.tool_calls:
+                for tool_call in msg.tool_calls:
+                    corresponding_tool_msg = next(
+                        (msg for msg in messages[i:] if msg.type == "tool" and msg.tool_call_id == tool_call["id"]),
+                        # ty: ignore[unresolved-attribute]
+                        None,
+                    )
+                    if corresponding_tool_msg is None:
+                        # 我们有一个悬空的工具调用，需要一个 ToolMessage
+                        tool_msg = (
+                            f"Tool call {tool_call['name']} with id {tool_call['id']} was "
+                            "cancelled - another message came in before it could be completed."
+                        )
+                        patched_messages.append(
+                            ToolMessage(
+                                content=tool_msg,
+                                name=tool_call["name"],
+                                tool_call_id=tool_call["id"],
+                            )
+                        )
+
+        return {"messages": Overwrite(patched_messages)}

app/agent/middleware/skills.py

@@ -0,0 +1,524 @@
+import re
+import shutil
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Annotated, List
+from typing import NotRequired, TypedDict
+
+import yaml  # noqa
+from anyio import Path as AsyncPath
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    AgentState,
+    ContextT,
+    ModelRequest,
+    ModelResponse,
+    ResponseT,
+)
+from langchain.agents.middleware.types import PrivateStateAttr  # noqa
+from langchain_core.runnables import RunnableConfig
+from langgraph.runtime import Runtime
+
+from app.agent.middleware.utils import append_to_system_message
+from app.log import logger
+
+# 安全提示: SKILL.md 文件最大限制为 10MB，防止 DoS 攻击
+MAX_SKILL_FILE_SIZE = 10 * 1024 * 1024
+
+# Agent Skills 规范约束 (https://agentskills.io/specification)
+MAX_SKILL_NAME_LENGTH = 64
+MAX_SKILL_DESCRIPTION_LENGTH = 1024
+MAX_SKILL_COMPATIBILITY_LENGTH = 500
+
+
+class SkillMetadata(TypedDict):
+    """Skill 元数据，符合 Agent Skills 规范。"""
+
+    path: str
+    """SKILL.md 文件路径。"""
+
+    id: str
+    """Skill 标识符。
+    约束: 1-64 字符，仅限小写字母/数字/连字符，不能以连字符开头或结尾，无连续连字符，需与父目录名一致。
+    """
+
+    name: str
+    """Skill 名称。
+    约束: Skill中文描述。
+    """
+
+    version: int
+    """Skill 版本号。
+    用于内置技能的版本管理，同步时比较版本号决定是否覆盖用户目录中的旧版本。
+    """
+
+    description: str
+    """Skill 功能描述。
+    约束: 1-1024 字符，应说明功能及适用场景。
+    """
+
+    license: str | None
+    """许可证信息。"""
+
+    compatibility: str | None
+    """环境依赖或兼容性要求 (最多 500 字符)。"""
+
+    metadata: dict[str, str]
+    """附加元数据。"""
+
+    allowed_tools: list[str]
+    """(实验性) Skill 建议使用的工具列表。"""
+
+
+class SkillsState(AgentState):
+    """skills 中间件状态。"""
+
+    skills_metadata: NotRequired[Annotated[list[SkillMetadata], PrivateStateAttr]]
+    """已加载的 skill 元数据列表，不传播给父 agent。"""
+
+
+class SkillsStateUpdate(TypedDict):
+    """skills 中间件状态更新项。"""
+
+    skills_metadata: list[SkillMetadata]
+    """待合并的 skill 元数据列表。"""
+
+
+def _parse_skill_metadata(  # noqa: C901
+    content: str,
+    skill_path: str,
+    skill_id: str,
+) -> SkillMetadata | None:
+    """从 SKILL.md 内容中解析 YAML 前言并验证元数据。"""
+    if len(content) > MAX_SKILL_FILE_SIZE:
+        logger.warning(
+            "Skipping %s: content too large (%d bytes)", skill_path, len(content)
+        )
+        return None
+
+    # 匹配 --- 分隔的 YAML 前言
+    frontmatter_pattern = r"^---\s*\n(.*?)\n---\s*\n"
+    match = re.match(frontmatter_pattern, content, re.DOTALL)
+    if not match:
+        logger.warning("Skipping %s: no valid YAML frontmatter found", skill_path)
+        return None
+    frontmatter_str = match.group(1)
+
+    # 解析 YAML
+    try:
+        frontmatter_data = yaml.safe_load(frontmatter_str)
+    except yaml.YAMLError as e:
+        logger.warning("Invalid YAML in %s: %s", skill_path, e)
+        return None
+
+    if not isinstance(frontmatter_data, dict):
+        logger.warning("Skipping %s: frontmatter is not a mapping", skill_path)
+        return None
+
+    # SKill名称和描述
+    name = str(frontmatter_data.get("name", "")).strip()
+    description = str(frontmatter_data.get("description", "")).strip()
+    if not name or not description:
+        logger.warning(
+            "Skipping %s: missing required 'name' or 'description'", skill_path
+        )
+        return None
+    description_str = description
+    if len(description_str) > MAX_SKILL_DESCRIPTION_LENGTH:
+        logger.warning(
+            "Description exceeds %d characters in %s, truncating",
+            MAX_SKILL_DESCRIPTION_LENGTH,
+            skill_path,
+        )
+        description_str = description_str[:MAX_SKILL_DESCRIPTION_LENGTH]
+
+    # 可选的工具列表，支持空格或逗号分隔
+    raw_tools = frontmatter_data.get("allowed-tools")
+    if isinstance(raw_tools, str):
+        allowed_tools = [
+            t.strip(",")  # 兼容 Claude Code 风格的逗号分隔
+            for t in raw_tools.split()
+            if t.strip(",")
+        ]
+    else:
+        if raw_tools is not None:
+            logger.warning(
+                "Ignoring non-string 'allowed-tools' in %s (got %s)",
+                skill_path,
+                type(raw_tools).__name__,
+            )
+        allowed_tools = []
+
+    # 能力或环境兼容性说明，最多 500 字符
+    compatibility_str = str(frontmatter_data.get("compatibility", "")).strip() or None
+    if compatibility_str and len(compatibility_str) > MAX_SKILL_COMPATIBILITY_LENGTH:
+        logger.warning(
+            "Compatibility exceeds %d characters in %s, truncating",
+            MAX_SKILL_COMPATIBILITY_LENGTH,
+            skill_path,
+        )
+        compatibility_str = compatibility_str[:MAX_SKILL_COMPATIBILITY_LENGTH]
+
+    # 版本号，默认为 0（表示未设置版本）
+    raw_version = frontmatter_data.get("version")
+    version = 0
+    if raw_version is not None:
+        try:
+            version = int(raw_version)
+        except (ValueError, TypeError):
+            logger.warning(
+                "Invalid 'version' in %s (got %r), defaulting to 0",
+                skill_path,
+                raw_version,
+            )
+
+    return SkillMetadata(
+        id=skill_id,
+        name=name,
+        version=version,
+        description=description_str,
+        path=skill_path,
+        metadata=_validate_metadata(frontmatter_data.get("metadata", {}), skill_path),
+        license=str(frontmatter_data.get("license", "")).strip() or None,
+        compatibility=compatibility_str,
+        allowed_tools=allowed_tools,
+    )
+
+
+def _validate_metadata(
+    raw: object,
+    skill_path: str,
+) -> dict[str, str]:
+    """验证并规范化 YAML 前言中的元数据字段，确保为 dict[str, str] 类型。"""
+    if not isinstance(raw, dict):
+        if raw:
+            logger.warning(
+                "Ignoring non-dict metadata in %s (got %s)",
+                skill_path,
+                type(raw).__name__,
+            )
+        return {}
+    return {str(k): str(v) for k, v in raw.items()}
+
+
+def _format_skill_annotations(skill: SkillMetadata) -> str:
+    """构建许可证和兼容性说明字符串。"""
+    parts: list[str] = []
+    if skill.get("license"):
+        parts.append(f"License: {skill['license']}")
+    if skill.get("compatibility"):
+        parts.append(f"Compatibility: {skill['compatibility']}")
+    return ", ".join(parts)
+
+
+async def _alist_skills(source_path: AsyncPath) -> list[SkillMetadata]:
+    """异步列出指定路径下的所有技能。
+
+    扫描包含 SKILL.md 的目录并解析其元数据。
+    """
+    skills: list[SkillMetadata] = []
+
+    # 查找所有技能目录 (包含 SKILL.md 的目录)
+    skill_dirs: List[AsyncPath] = []
+    async for path in source_path.iterdir():
+        if await path.is_dir() and await (path / "SKILL.md").is_file():
+            skill_dirs.append(path)
+
+    if not skill_dirs:
+        return []
+
+    # 解析已下载的 SKILL.md
+    for skill_path in skill_dirs:
+        skill_md_path = skill_path / "SKILL.md"
+
+        skill_content = await skill_md_path.read_text(encoding="utf-8")
+
+        # 解析元数据
+        skill_metadata = _parse_skill_metadata(
+            content=skill_content,
+            skill_path=str(skill_md_path),
+            skill_id=skill_path.name,
+        )
+        if skill_metadata:
+            skills.append(skill_metadata)
+
+    return skills
+
+
+SKILLS_SYSTEM_PROMPT = """
+<skills_system>
+You have access to a skills library that provides specialized capabilities and domain knowledge.
+
+{skills_locations}
+
+**Available Skills:**
+
+{skills_list}
+
+**How to Use Skills (Progressive Disclosure):**
+
+Skills follow a **progressive disclosure** pattern - you see their name and description above, but only read full instructions when needed:
+
+1. **Recognize when a skill applies**: Check if the user's task matches a skill's description
+2. **Read the skill's full instructions**: Use the path shown in the skill list above
+3. **Follow the skill's instructions**: SKILL.md contains step-by-step workflows, best practices, and examples
+4. **Access supporting files**: Skills may include helper scripts, configs, or reference docs - use absolute paths
+
+**Creating New Skills:**
+
+When you identify a repetitive complex workflow or specialized task that would benefit from being a skill, you can create one:
+
+1. **Directory Structure**: Create a new directory in one of the skills locations. The directory name is the `skill-id`.
+   - Path format: `<skills_location>/<skill-id>/SKILL.md`
+   - `skill-id` constraints: 1-64 characters, lowercase letters, numbers, and hyphens only.
+2. **SKILL.md Format**: Must start with a YAML frontmatter followed by markdown instructions.
+   ```markdown
+   ---
+   name: Brief tool name (Chinese)
+   description: Detailed functional description and use cases (1-1024 chars)
+   allowed-tools: "tool1 tool2" (optional, space-separated list of recommended tools)
+   compatibility: "Environment requirements" (optional, max 500 chars)
+   ---
+   # Skill Instructions
+   Step-by-step workflows, best practices, and examples go here.
+   ```
+3. **Supporting Files**: You can add `.py` scripts, `.yaml` configs, or other files within the same skill directory. Reference them using absolute paths in `SKILL.md`.
+
+**When to Use Skills:**
+- User's request matches a skill's domain (e.g., "research X" -> web-research skill)
+- You need specialized knowledge or structured workflows
+- A skill provides proven patterns for complex tasks
+
+**Executing Skill Scripts:**
+Skills may contain Python scripts or other executable files. Always use absolute paths from the skill list.
+
+**Example Workflow:**
+
+User: "Can you research the latest developments in quantum computing?"
+
+1. Check available skills -> See "web-research" skill with its path
+2. Read the skill using the path shown
+3. Follow the skill's research workflow (search -> organize -> synthesize)
+4. Use any helper scripts with absolute paths
+
+Remember: Skills make you more capable and consistent. When in doubt, check if a skill exists for the task!
+</skills_system>
+"""
+
+
+def _extract_version(skill_md: Path) -> int:
+    """从 SKILL.md 文件中快速提取 version 字段，无法提取时返回 0。"""
+    try:
+        content = skill_md.read_text(encoding="utf-8")
+    except Exception:
+        return 0
+    match = re.match(r"^---\s*\n(.*?)\n---\s*\n", content, re.DOTALL)
+    if not match:
+        return 0
+    try:
+        frontmatter = yaml.safe_load(match.group(1))
+    except yaml.YAMLError:
+        return 0
+    if not isinstance(frontmatter, dict):
+        return 0
+    raw = frontmatter.get("version")
+    if raw is None:
+        return 0
+    try:
+        return int(raw)
+    except (ValueError, TypeError):
+        return 0
+
+
+def _sync_bundled_skills(bundled_dir: Path, target_dir: Path) -> None:
+    """将项目自带的技能同步到用户目录。
+
+    - 目标目录中不存在对应技能子目录时，直接复制。
+    - 目标目录中已存在时，比较内置与用户目录中 SKILL.md 的 version 字段：
+      - 内置版本更高时，直接覆盖用户目录中的旧版本。
+      - 版本相同或用户版本更高时，跳过。
+    - 内置 SKILL.md 无 version 字段（视为 0）时，不覆盖。
+
+    Parameters
+    ----------
+    bundled_dir : Path
+        项目内置技能目录（如 ``ROOT_PATH / "skills"``）。
+    target_dir : Path
+        用户配置技能目录（如 ``CONFIG_PATH / "agent" / "skills"``）。
+    """
+    if not bundled_dir.is_dir():
+        return
+
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    for skill_src in bundled_dir.iterdir():
+        if not skill_src.is_dir():
+            continue
+        skill_md = skill_src / "SKILL.md"
+        if not skill_md.is_file():
+            continue
+
+        skill_dst = target_dir / skill_src.name
+
+        if not skill_dst.exists():
+            # 目标不存在，直接复制
+            try:
+                shutil.copytree(str(skill_src), str(skill_dst))
+                logger.info(
+                    "已自动复制内置技能 '%s' -> '%s'", skill_src.name, skill_dst
+                )
+            except Exception as e:
+                logger.warning("复制内置技能 '%s' 失败: %s", skill_src.name, e)
+            continue
+
+        # 目标已存在，比较版本号
+        bundled_version = _extract_version(skill_md)
+        if bundled_version <= 0:
+            # 内置技能无版本号，保持旧逻辑不覆盖
+            continue
+
+        user_skill_md = skill_dst / "SKILL.md"
+        user_version = _extract_version(user_skill_md) if user_skill_md.is_file() else 0
+
+        if bundled_version <= user_version:
+            # 用户版本 >= 内置版本，跳过
+            continue
+
+        # 内置版本更高，删除旧版本后覆盖
+        try:
+            shutil.rmtree(str(skill_dst))
+            shutil.copytree(str(skill_src), str(skill_dst))
+            logger.info(
+                "已更新内置技能 '%s' (v%d -> v%d)",
+                skill_src.name,
+                user_version,
+                bundled_version,
+            )
+        except Exception as e:
+            logger.warning("更新内置技能 '%s' 失败: %s", skill_src.name, e)
+
+
+class SkillsMiddleware(AgentMiddleware[SkillsState, ContextT, ResponseT]):  # noqa
+    """加载并向系统提示词注入 Agent Skill 的中间件。
+
+    按源顺序加载 Skill，后加载的会覆盖重名的。
+    启动时自动将项目内置技能（bundled_skills_dir）同步到用户技能目录。
+    """
+
+    state_schema = SkillsState
+
+    def __init__(
+        self,
+        *,
+        sources: list[str],
+        bundled_skills_dir: str | None = None,
+    ) -> None:
+        """初始化 Skill 中间件。
+
+        Parameters
+        ----------
+        sources : list[str]
+            用户技能目录列表。
+        bundled_skills_dir : str | None
+            项目内置技能目录路径。若提供，在首次加载前会将其中不存在于
+            sources 首个目录的技能自动复制过去。
+        """
+        self.sources = sources
+        self.bundled_skills_dir = bundled_skills_dir
+        self.system_prompt_template = SKILLS_SYSTEM_PROMPT
+
+    def _format_skills_locations(self) -> str:
+        """格式化技能位置信息用于系统提示词。"""
+        locations = []
+
+        for i, source_path in enumerate(self.sources):
+            suffix = " (higher priority)" if i == len(self.sources) - 1 else ""
+            locations.append(f"**MoviePilot Skills**: `{source_path}`{suffix}")
+
+        return "\n".join(locations)
+
+    def _format_skills_list(self, skills: list[SkillMetadata]) -> str:
+        """格式化技能元数据列表用于系统提示词。"""
+        if not skills:
+            paths = [f"{source_path}" for source_path in self.sources]
+            return f"(No skills available yet. You can create skills in {' or '.join(paths)})"
+
+        lines = []
+        for skill in skills:
+            annotations = _format_skill_annotations(skill)
+            desc_line = f"- **{skill['id']}**: {skill['name']} - {skill['description']}"
+            if annotations:
+                desc_line += f" ({annotations})"
+            lines.append(desc_line)
+            if skill["allowed_tools"]:
+                lines.append(f"  -> Allowed tools: {', '.join(skill['allowed_tools'])}")
+            lines.append(f"  -> Read `{skill['path']}` for full instructions")
+
+        return "\n".join(lines)
+
+    def modify_request(self, request: ModelRequest[ContextT]) -> ModelRequest[ContextT]:
+        """将技能文档注入模型请求的系统消息中。"""
+        skills_metadata = request.state.get("skills_metadata", [])  # noqa
+        skills_locations = self._format_skills_locations()
+        skills_list = self._format_skills_list(skills_metadata)
+
+        skills_section = self.system_prompt_template.format(
+            skills_locations=skills_locations,
+            skills_list=skills_list,
+        )
+
+        new_system_message = append_to_system_message(
+            request.system_message, skills_section
+        )
+
+        return request.override(system_message=new_system_message)
+
+    async def abefore_agent(  # noqa
+        self, state: SkillsState, runtime: Runtime, config: RunnableConfig
+    ) -> SkillsStateUpdate | None:  # ty: ignore[invalid-method-override]
+        """在 Agent 执行前异步加载技能元数据。
+
+        每个会话仅加载一次。若 state 中已有则跳过。
+        首次加载时，会先将内置技能同步到用户目录（如不存在）。
+        """
+        # 如果 state 中已存在元数据则跳过
+        if "skills_metadata" in state:
+            return None
+
+        # 自动同步内置技能到首个用户技能目录
+        if self.bundled_skills_dir and self.sources:
+            bundled = Path(self.bundled_skills_dir)
+            target = Path(self.sources[0])
+            try:
+                _sync_bundled_skills(bundled, target)
+            except Exception as e:
+                logger.warning("同步内置技能失败: %s", e)
+
+        all_skills: dict[str, SkillMetadata] = {}
+
+        # 遍历源按顺序加载技能，重名时后者覆盖前者
+        for source_path in self.sources:
+            skill_source_path = AsyncPath(source_path)
+            if not await skill_source_path.exists():
+                await skill_source_path.mkdir(parents=True, exist_ok=True)
+                continue
+            source_skills = await _alist_skills(skill_source_path)
+            for skill in source_skills:
+                all_skills[skill["name"]] = skill
+
+        skills = list(all_skills.values())
+        return SkillsStateUpdate(skills_metadata=skills)
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest[ContextT],
+        handler: Callable[
+            [ModelRequest[ContextT]], Awaitable[ModelResponse[ResponseT]]
+        ],
+    ) -> ModelResponse[ResponseT]:
+        """在模型调用时注入技能文档。"""
+        modified_request = self.modify_request(request)
+        return await handler(modified_request)
+
+
+__all__ = ["SkillMetadata", "SkillsMiddleware"]

app/agent/middleware/utils.py

@@ -0,0 +1,21 @@
+from langchain_core.messages import SystemMessage, ContentBlock
+
+
+def append_to_system_message(
+        system_message: SystemMessage | None,
+        text: str,
+) -> SystemMessage:
+    """将文本追加到系统消息。
+
+    参数：
+        system_message: 现有的系统消息或 None。
+        text: 要添加到系统消息的文本。
+
+    返回：
+        追加了文本的新 SystemMessage。
+    """
+    new_content: list[ContentBlock] = list(system_message.content_blocks) if system_message else []  # noqa
+    if new_content:
+        text = f"\n\n{text}"
+    new_content.append({"type": "text", "text": text})
+    return SystemMessage(content_blocks=new_content)

app/agent/prompt/Agent Prompt.txt

@@ -0,0 +1,64 @@
+You are an AI media assistant powered by MoviePilot. You specialize in managing home media ecosystems: searching for movies/TV shows, managing subscriptions, overseeing downloads, and organizing media libraries.
+
+All your responses must be in **Chinese (中文)**.
+
+You act as a proactive agent. Your goal is to fully resolve the user's media-related requests autonomously. Do not end your turn until the task is complete or you are blocked and require user feedback.
+
+Core Capabilities:
+1. Media Search & Recognition — Identify movies, TV shows, and anime; recognize media from fuzzy filenames or incomplete titles.
+2. Subscription Management — Create rules for automated downloading; monitor trending content.
+3. Download Control — Search torrents across trackers; filter by quality, codec, and release group.
+4. System Status & Organization — Monitor downloads, server health, file transfers, renaming, and library cleanup.
+5. Visual Input Handling — Users may attach images from supported channels; analyze them together with the text when relevant.
+
+<communication>
+{verbose_spec}
+
+- Tone: friendly, concise. Like a knowledgeable friend, not a corporate bot.
+- Use emojis sparingly (1-3 per response): greetings, completions, errors.
+- Be direct. NO unnecessary preamble, NO repeating user's words, NO explaining your thinking.
+- Use Markdown for structured data. Use `inline code` for media titles/paths.
+- Include key details (year, rating, resolution) but do NOT over-explain.
+- Do not stop for approval on read-only operations. Only confirm before critical actions (starting downloads, deleting subscriptions).
+- If the current channel supports image sending and an image would materially help, you may use the `send_message` tool with `image_url` to send it.
+- NOT a coding assistant. Do not offer code snippets.
+- If user has set preferred communication style in memory, follow that strictly.
+</communication>
+
+<response_format>
+- Responses MUST be short and punchy: one sentence for confirmations, brief list for search results.
+- NO filler phrases like "Let me help you", "Here are the results", "I found..." — skip all unnecessary preamble.
+- NO repeating what user said.
+- NO narrating your internal reasoning.
+- After task completion: one line summary only.
+- When error occurs: brief acknowledgment + suggestion, then move on.
+</response_format>
+
+<flow>
+1. Media Discovery: Identify exact media metadata (TMDB ID, Season/Episode) using search tools.
+2. Context Checking: Verify current status (already in library? already subscribed?).
+3. Action Execution: Perform the task with a brief status update only if the operation takes time.
+4. Final Confirmation: State the result concisely.
+</flow>
+
+<tool_calling_strategy>
+- Call independent tools in parallel whenever possible.
+- If search results are ambiguous, use `query_media_detail` or `recognize_media` to clarify before proceeding.
+- If `search_media` fails, fall back to `search_web` or `recognize_media`. Only ask the user when all automated methods are exhausted.
+</tool_calling_strategy>
+
+<media_management_rules>
+1. Download Safety: Present found torrents (size, seeds, quality) and get explicit consent before downloading.
+2. Subscription Logic: Check for the best matching quality profile based on user history or defaults.
+3. Library Awareness: Check if content already exists in the library to avoid duplicates.
+4. Error Handling: If a tool or site fails, briefly explain what went wrong and suggest an alternative.
+</media_management_rules>
+
+<markdown_spec>
+Specific markdown rules:
+{markdown_spec}
+</markdown_spec>
+
+<system_info>
+{moviepilot_info}
+</system_info>

app/agent/prompt/__init__.py

@@ -0,0 +1,177 @@
+"""提示词管理器"""
+
+import socket
+from pathlib import Path
+from time import strftime
+from typing import Dict
+
+from app.core.config import settings
+from app.log import logger
+from app.schemas import (
+    ChannelCapability,
+    ChannelCapabilities,
+    MessageChannel,
+    ChannelCapabilityManager,
+)
+from app.utils.system import SystemUtils
+
+
+class PromptManager:
+    """
+    提示词管理器
+    """
+
+    def __init__(self, prompts_dir: str = None):
+        if prompts_dir is None:
+            self.prompts_dir = Path(__file__).parent
+        else:
+            self.prompts_dir = Path(prompts_dir)
+        self.prompts_cache: Dict[str, str] = {}
+
+    def load_prompt(self, prompt_name: str) -> str:
+        """
+        加载指定的提示词
+        """
+        if prompt_name in self.prompts_cache:
+            return self.prompts_cache[prompt_name]
+
+        prompt_file = self.prompts_dir / prompt_name
+        try:
+            with open(prompt_file, "r", encoding="utf-8") as f:
+                content = f.read().strip()
+            # 缓存提示词
+            self.prompts_cache[prompt_name] = content
+            logger.info(f"提示词加载成功: {prompt_name}，长度：{len(content)} 字符")
+            return content
+        except FileNotFoundError:
+            logger.error(f"提示词文件不存在: {prompt_file}")
+            raise
+        except Exception as e:
+            logger.error(f"加载提示词失败: {prompt_name}, 错误: {e}")
+            raise
+
+    def get_agent_prompt(self, channel: str = None) -> str:
+        """
+        获取智能体提示词
+        :param channel: 消息渠道（Telegram、微信、Slack等）
+        :return: 提示词内容
+        """
+        # 基础提示词
+        base_prompt = self.load_prompt("Agent Prompt.txt")
+
+        # 识别渠道
+        markdown_spec = ""
+        msg_channel = (
+            next(
+                (c for c in MessageChannel if c.value.lower() == channel.lower()), None
+            )
+            if channel
+            else None
+        )
+        # 获取渠道能力说明
+        if msg_channel:
+            caps = ChannelCapabilityManager.get_capabilities(msg_channel)
+            if caps:
+                markdown_spec = self._generate_formatting_instructions(caps)
+
+        # 啰嗦模式
+        verbose_spec = ""
+        if not settings.AI_AGENT_VERBOSE:
+            verbose_spec = (
+                "\n\n[Important Instruction] STRICTLY ENFORCED: DO NOT output any conversational "
+                "text, thinking processes, or explanations before or during tool calls. Call tools "
+                "directly without any transitional phrases. "
+                "You MUST remain completely silent until the task is completely finished. "
+                "DO NOT output any content whatsoever until your final summary reply."
+            )
+
+        # MoviePilot系统信息
+        moviepilot_info = self._get_moviepilot_info()
+
+        # 始终替换占位符，避免后续 .format() 时因残留花括号报 KeyError
+        base_prompt = base_prompt.format(
+            markdown_spec=markdown_spec,
+            verbose_spec=verbose_spec,
+            moviepilot_info=moviepilot_info,
+        )
+
+        return base_prompt
+
+    @staticmethod
+    def _get_moviepilot_info() -> str:
+        """
+        获取MoviePilot系统信息，用于注入到系统提示词中
+        """
+        # 获取主机名和IP地址
+        try:
+            hostname = socket.gethostname()
+            ip_address = socket.gethostbyname(hostname)
+        except Exception:  # noqa
+            hostname = "localhost"
+            ip_address = "127.0.0.1"
+
+        # 配置文件和日志文件目录
+        config_path = str(settings.CONFIG_PATH)
+        log_path = str(settings.LOG_PATH)
+
+        # API地址构建
+        api_port = settings.PORT
+        api_path = settings.API_V1_STR
+
+        # API令牌
+        api_token = settings.API_TOKEN or "未设置"
+
+        # 数据库信息
+        db_type = settings.DB_TYPE
+        if db_type == "sqlite":
+            db_info = f"SQLite ({settings.CONFIG_PATH / 'db' / 'moviepilot.db'})"
+        else:
+            db_password = settings.DB_POSTGRESQL_PASSWORD or ""
+            db_info = f"PostgreSQL ({settings.DB_POSTGRESQL_USERNAME}:{db_password}@{settings.DB_POSTGRESQL_HOST}:{settings.DB_POSTGRESQL_PORT}/{settings.DB_POSTGRESQL_DATABASE})"
+
+        info_lines = [
+            f"- 当前时间: {strftime('%Y-%m-%d %H:%M:%S')}",
+            f"- 运行环境: {SystemUtils.platform} {'docker' if SystemUtils.is_docker() else ''}",
+            f"- 主机名: {hostname}",
+            f"- IP地址: {ip_address}",
+            f"- API端口: {api_port}",
+            f"- API路径: {api_path}",
+            f"- API令牌: {api_token}",
+            f"- 外网域名: {settings.APP_DOMAIN or '未设置'}",
+            f"- 数据库类型: {db_type}",
+            f"- 数据库: {db_info}",
+            f"- 配置文件目录: {config_path}",
+            f"- 日志文件目录: {log_path}",
+            f"- 系统安装目录: {settings.ROOT_PATH}",
+        ]
+
+        return "\n".join(info_lines)
+
+    @staticmethod
+    def _generate_formatting_instructions(caps: ChannelCapabilities) -> str:
+        """
+        根据渠道能力动态生成格式指令
+        """
+        instructions = []
+        if ChannelCapability.RICH_TEXT not in caps.capabilities:
+            instructions.append(
+                "- Formatting: Use **Plain Text ONLY**. The channel does NOT support Markdown."
+            )
+            instructions.append(
+                "- No Markdown Symbols: NEVER use `**`, `*`, `__`, or `[` blocks. Use natural text to emphasize (e.g., using ALL CAPS or separators)."
+            )
+            instructions.append(
+                "- Lists: Use plain text symbols like `>` or `*` at the start of lines, followed by manual line breaks."
+            )
+            instructions.append("- Links: Paste URLs directly as text.")
+        return "\n".join(instructions)
+
+    def clear_cache(self):
+        """
+        清空缓存
+        """
+        self.prompts_cache.clear()
+        logger.info("提示词缓存已清空")
+
+
+prompt_manager = PromptManager()

app/agent/tools/base.py

@@ -0,0 +1,268 @@
+import json
+from abc import ABCMeta, abstractmethod
+from typing import Any, Optional
+
+from langchain_core.tools import BaseTool
+from pydantic import PrivateAttr
+
+from app.agent import StreamingHandler
+from app.chain import ChainBase
+from app.core.config import settings
+from app.db.user_oper import UserOper
+from app.helper.service import ServiceConfigHelper
+from app.log import logger
+from app.schemas import Notification
+from app.schemas.types import MessageChannel
+
+
+class ToolChain(ChainBase):
+    pass
+
+
+class MoviePilotTool(BaseTool, metaclass=ABCMeta):
+    """
+    MoviePilot专用工具基类（LangChain v1 / langchain_core）
+    """
+
+    _session_id: str = PrivateAttr()
+    _user_id: str = PrivateAttr()
+    _channel: Optional[str] = PrivateAttr(default=None)
+    _source: Optional[str] = PrivateAttr(default=None)
+    _username: Optional[str] = PrivateAttr(default=None)
+    _stream_handler: Optional[StreamingHandler] = PrivateAttr(default=None)
+    _require_admin: bool = PrivateAttr(default=False)
+
+    def __init__(self, session_id: str, user_id: str, **kwargs):
+        super().__init__(**kwargs)
+        self._session_id = session_id
+        self._user_id = user_id
+        self._require_admin = getattr(self.__class__, "require_admin", False)
+
+    def _run(self, *args: Any, **kwargs: Any) -> Any:
+        raise NotImplementedError("MoviePilotTool 只支持异步调用，请使用 _arun")
+
+    async def _arun(self, *args: Any, **kwargs: Any) -> str:
+        """
+        异步运行工具，负责：
+        1. 在工具调用前将流式消息推送给用户
+        2. 持久化工具调用记录到会话记忆
+        3. 调用具体工具逻辑（子类实现的 execute 方法）
+        4. 持久化工具结果到会话记忆
+        5. 权限检查
+        """
+
+        permission_result = await self._check_permission()
+        if permission_result:
+            return permission_result
+
+        # 获取工具执行提示消息
+        tool_message = self.get_tool_message(**kwargs)
+        if not tool_message:
+            explanation = kwargs.get("explanation")
+            if explanation:
+                tool_message = explanation
+
+        # 发送工具执行过程消息
+        if self._stream_handler and self._stream_handler.is_streaming:
+            if settings.AI_AGENT_VERBOSE:
+                if self._stream_handler.is_auto_flushing:
+                    # 渠道支持编辑：工具消息追加到 buffer，由定时刷新推送
+                    if tool_message:
+                        self._stream_handler.emit(f"\n\n⚙️ => {tool_message}\n\n")
+                else:
+                    # 渠道不支持编辑：取出 Agent 文字 + 工具消息合并独立发送
+                    agent_message = await self._stream_handler.take()
+                    messages = []
+                    if agent_message:
+                        messages.append(agent_message)
+                    if tool_message:
+                        messages.append(f"⚙️ => {tool_message}")
+                    if messages:
+                        merged_message = "\n\n".join(messages)
+                        await self.send_tool_message(merged_message)
+            else:
+                # 非VERBOSE，重置缓冲区从头更新，保持消息编辑能力
+                self._stream_handler.reset()
+        else:
+            # 未启用流式传输，不发送任何工具消息内容
+            pass
+
+        logger.debug(f"Executing tool {self.name} with args: {kwargs}")
+
+        # 执行具体工具逻辑
+        try:
+            result = await self.run(**kwargs)
+            logger.debug(f"Tool {self.name} executed with result: {result}")
+        except Exception as e:
+            error_message = f"工具执行异常 ({type(e).__name__}): {str(e)}"
+            logger.error(f"Tool {self.name} execution failed: {e}", exc_info=True)
+            result = error_message
+
+        # 格式化结果
+        if isinstance(result, str):
+            formatted_result = result
+        elif isinstance(result, (int, float)):
+            formatted_result = str(result)
+        else:
+            formatted_result = json.dumps(result, ensure_ascii=False, indent=2)
+
+        return formatted_result
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """
+        获取工具执行时的友好提示消息。
+
+        子类可以重写此方法，根据实际参数生成个性化的提示消息。
+        如果返回 None 或空字符串，将回退使用 explanation 参数。
+
+        Args:
+            **kwargs: 工具的所有参数（包括 explanation）
+
+        Returns:
+            str: 友好的提示消息，如果返回 None 或空字符串则使用 explanation
+        """
+        return None
+
+    @abstractmethod
+    async def run(self, **kwargs) -> str:
+        """子类实现具体的工具执行逻辑"""
+        raise NotImplementedError
+
+    def set_message_attr(self, channel: str, source: str, username: str):
+        """
+        设置消息属性
+        """
+        self._channel = channel
+        self._source = source
+        self._username = username
+
+    def set_stream_handler(self, stream_handler: StreamingHandler):
+        """
+        设置回调处理器
+        """
+        self._stream_handler = stream_handler
+
+    async def _check_permission(self) -> Optional[str]:
+        """
+        检查用户权限：
+        1. 首先检查工具是否需要管理员权限
+        2. 如果需要管理员权限，则检查用户是否是渠道管理员
+        3. 如果渠道没有设置管理员名单，则检查用户是否是系统管理员
+        4. 如果都不是系统管理员，检查用户ID是否等于渠道配置的用户ID
+        5. 如果都不是，返回权限拒绝消息
+        """
+        if not self._require_admin:
+            return None
+
+        if not self._channel or not self._source:
+            return None
+
+        user_id_str = str(self._user_id) if self._user_id else None
+
+        channel_type_map = {
+            MessageChannel.Telegram: "telegram",
+            MessageChannel.Discord: "discord",
+            MessageChannel.Wechat: "wechat",
+            MessageChannel.Slack: "slack",
+            MessageChannel.VoceChat: "vocechat",
+            MessageChannel.SynologyChat: "synologychat",
+            MessageChannel.QQ: "qqbot",
+        }
+
+        channel_type = None
+        for key, value in channel_type_map.items():
+            if self._channel == key.value:
+                channel_type = value
+                break
+
+        if not channel_type:
+            return None
+
+        admin_key_map = {
+            "telegram": "TELEGRAM_ADMINS",
+            "discord": "DISCORD_ADMINS",
+            "wechat": "WECHAT_ADMINS",
+            "slack": "SLACK_ADMINS",
+            "vocechat": "VOCECHAT_ADMINS",
+            "synologychat": "SYNOLOGYCHAT_ADMINS",
+            "qqbot": "QQBOT_ADMINS",
+        }
+
+        user_id_key_map = {
+            "telegram": "TELEGRAM_CHAT_ID",
+            "vocechat": "VOCECHAT_CHANNEL_ID",
+            "wechat": "WECHAT_BOT_CHAT_ID",
+        }
+
+        admin_key = admin_key_map.get(channel_type)
+        user_id_key = user_id_key_map.get(channel_type)
+
+        try:
+            configs = ServiceConfigHelper.get_notification_configs()
+            for config in configs:
+                if config.name == self._source and config.config:
+                    channel_admins = config.config.get(admin_key) if admin_key else None
+                    if channel_admins:
+                        admin_list = [
+                            aid.strip()
+                            for aid in str(channel_admins).split(",")
+                            if aid.strip()
+                        ]
+                        if user_id_str and user_id_str in admin_list:
+                            return None
+
+                        user = (
+                            UserOper().get_by_name(self._username)
+                            if self._username
+                            else None
+                        )
+                        if user and user.is_superuser:
+                            return None
+
+                        return (
+                            "抱歉，您没有执行此工具的权限。"
+                            "只有渠道管理员或系统管理员才能执行工具操作。"
+                            "如需执行工具，请联系渠道管理员将您的用户ID添加到渠道管理员列表中，"
+                            "或联系系统管理员为您设置权限。"
+                        )
+                    else:
+                        user = (
+                            UserOper().get_by_name(self._username)
+                            if self._username
+                            else None
+                        )
+                        if user and user.is_superuser:
+                            return None
+
+                        if user_id_key:
+                            config_user_id = config.config.get(user_id_key)
+                            if config_user_id and str(config_user_id) == user_id_str:
+                                return None
+
+                        return (
+                            "抱歉，您没有执行此工具的权限。"
+                            "只有系统管理员才能执行工具操作。"
+                            "如需执行工具，请联系系统管理员为您设置权限。"
+                        )
+        except Exception as e:
+            logger.error(f"检查权限失败: {e}")
+
+        return None
+
+    async def send_tool_message(
+        self, message: str, title: str = "", image: Optional[str] = None
+    ):
+        """
+        发送工具消息
+        """
+        await ToolChain().async_post_message(
+            Notification(
+                channel=self._channel,
+                source=self._source,
+                userid=self._user_id,
+                username=self._username,
+                title=title,
+                text=message,
+                image=image,
+            )
+        )

app/agent/tools/factory.py

@@ -0,0 +1,181 @@
+from typing import List, Callable
+
+from app.agent.tools.impl.add_download import AddDownloadTool
+from app.agent.tools.impl.add_subscribe import AddSubscribeTool
+from app.agent.tools.impl.update_subscribe import UpdateSubscribeTool
+from app.agent.tools.impl.search_subscribe import SearchSubscribeTool
+from app.agent.tools.impl.get_recommendations import GetRecommendationsTool
+from app.agent.tools.impl.query_downloaders import QueryDownloadersTool
+from app.agent.tools.impl.query_download_tasks import QueryDownloadTasksTool
+from app.agent.tools.impl.query_library_exists import QueryLibraryExistsTool
+from app.agent.tools.impl.query_library_latest import QueryLibraryLatestTool
+from app.agent.tools.impl.query_sites import QuerySitesTool
+from app.agent.tools.impl.update_site import UpdateSiteTool
+from app.agent.tools.impl.query_site_userdata import QuerySiteUserdataTool
+from app.agent.tools.impl.test_site import TestSiteTool
+from app.agent.tools.impl.query_subscribes import QuerySubscribesTool
+from app.agent.tools.impl.query_subscribe_shares import QuerySubscribeSharesTool
+from app.agent.tools.impl.query_rule_groups import QueryRuleGroupsTool
+from app.agent.tools.impl.query_popular_subscribes import QueryPopularSubscribesTool
+from app.agent.tools.impl.query_subscribe_history import QuerySubscribeHistoryTool
+from app.agent.tools.impl.delete_subscribe import DeleteSubscribeTool
+from app.agent.tools.impl.search_media import SearchMediaTool
+from app.agent.tools.impl.search_person import SearchPersonTool
+from app.agent.tools.impl.search_person_credits import SearchPersonCreditsTool
+from app.agent.tools.impl.recognize_media import RecognizeMediaTool
+from app.agent.tools.impl.scrape_metadata import ScrapeMetadataTool
+from app.agent.tools.impl.query_episode_schedule import QueryEpisodeScheduleTool
+from app.agent.tools.impl.query_media_detail import QueryMediaDetailTool
+from app.agent.tools.impl.search_torrents import SearchTorrentsTool
+from app.agent.tools.impl.get_search_results import GetSearchResultsTool
+from app.agent.tools.impl.search_web import SearchWebTool
+from app.agent.tools.impl.send_message import SendMessageTool
+from app.agent.tools.impl.query_schedulers import QuerySchedulersTool
+from app.agent.tools.impl.run_scheduler import RunSchedulerTool
+from app.agent.tools.impl.query_workflows import QueryWorkflowsTool
+from app.agent.tools.impl.run_workflow import RunWorkflowTool
+from app.agent.tools.impl.update_site_cookie import UpdateSiteCookieTool
+from app.agent.tools.impl.delete_download import DeleteDownloadTool
+from app.agent.tools.impl.delete_download_history import DeleteDownloadHistoryTool
+from app.agent.tools.impl.delete_transfer_history import DeleteTransferHistoryTool
+from app.agent.tools.impl.modify_download import ModifyDownloadTool
+from app.agent.tools.impl.query_directory_settings import QueryDirectorySettingsTool
+from app.agent.tools.impl.list_directory import ListDirectoryTool
+from app.agent.tools.impl.query_transfer_history import QueryTransferHistoryTool
+from app.agent.tools.impl.transfer_file import TransferFileTool
+from app.agent.tools.impl.execute_command import ExecuteCommandTool
+from app.agent.tools.impl.edit_file import EditFileTool
+from app.agent.tools.impl.write_file import WriteFileTool
+from app.agent.tools.impl.read_file import ReadFileTool
+from app.agent.tools.impl.browse_webpage import BrowseWebpageTool
+from app.agent.tools.impl.query_installed_plugins import QueryInstalledPluginsTool
+from app.agent.tools.impl.query_plugin_capabilities import QueryPluginCapabilitiesTool
+from app.agent.tools.impl.run_slash_command import RunSlashCommandTool
+from app.agent.tools.impl.list_slash_commands import ListSlashCommandsTool
+from app.agent.tools.impl.query_custom_identifiers import QueryCustomIdentifiersTool
+from app.agent.tools.impl.update_custom_identifiers import UpdateCustomIdentifiersTool
+from app.core.plugin import PluginManager
+from app.log import logger
+from .base import MoviePilotTool
+
+
+class MoviePilotToolFactory:
+    """
+    MoviePilot工具工厂
+    """
+
+    @staticmethod
+    def create_tools(
+        session_id: str,
+        user_id: str,
+        channel: str = None,
+        source: str = None,
+        username: str = None,
+        stream_handler: Callable = None,
+    ) -> List[MoviePilotTool]:
+        """
+        创建MoviePilot工具列表
+        """
+        tools = []
+        tool_definitions = [
+            SearchMediaTool,
+            SearchPersonTool,
+            SearchPersonCreditsTool,
+            RecognizeMediaTool,
+            ScrapeMetadataTool,
+            QueryEpisodeScheduleTool,
+            QueryMediaDetailTool,
+            AddSubscribeTool,
+            UpdateSubscribeTool,
+            SearchSubscribeTool,
+            SearchTorrentsTool,
+            GetSearchResultsTool,
+            SearchWebTool,
+            AddDownloadTool,
+            QuerySubscribesTool,
+            QuerySubscribeSharesTool,
+            QueryPopularSubscribesTool,
+            QueryRuleGroupsTool,
+            QuerySubscribeHistoryTool,
+            DeleteSubscribeTool,
+            QueryDownloadTasksTool,
+            DeleteDownloadTool,
+            DeleteDownloadHistoryTool,
+            DeleteTransferHistoryTool,
+            ModifyDownloadTool,
+            QueryDownloadersTool,
+            QuerySitesTool,
+            UpdateSiteTool,
+            QuerySiteUserdataTool,
+            TestSiteTool,
+            UpdateSiteCookieTool,
+            GetRecommendationsTool,
+            QueryLibraryExistsTool,
+            QueryLibraryLatestTool,
+            QueryDirectorySettingsTool,
+            ListDirectoryTool,
+            QueryTransferHistoryTool,
+            TransferFileTool,
+            SendMessageTool,
+            QuerySchedulersTool,
+            RunSchedulerTool,
+            QueryWorkflowsTool,
+            RunWorkflowTool,
+            ExecuteCommandTool,
+            EditFileTool,
+            WriteFileTool,
+            ReadFileTool,
+            BrowseWebpageTool,
+            QueryInstalledPluginsTool,
+            QueryPluginCapabilitiesTool,
+            RunSlashCommandTool,
+            ListSlashCommandsTool,
+            QueryCustomIdentifiersTool,
+            UpdateCustomIdentifiersTool,
+        ]
+        # 创建内置工具
+        for ToolClass in tool_definitions:
+            tool = ToolClass(session_id=session_id, user_id=user_id)
+            tool.set_message_attr(channel=channel, source=source, username=username)
+            tool.set_stream_handler(stream_handler=stream_handler)
+            tools.append(tool)
+
+        # 加载插件提供的工具
+        plugin_tools_count = 0
+        plugin_tools_info = PluginManager().get_plugin_agent_tools()
+        for plugin_info in plugin_tools_info:
+            plugin_id = plugin_info.get("plugin_id")
+            plugin_name = plugin_info.get("plugin_name")
+            tool_classes = plugin_info.get("tools", [])
+            for ToolClass in tool_classes:
+                try:
+                    # 验证工具类是否继承自 MoviePilotTool
+                    if not issubclass(ToolClass, MoviePilotTool):
+                        logger.warning(
+                            f"插件 {plugin_name}({plugin_id}) 提供的工具类 {ToolClass.__name__} 未继承自 MoviePilotTool，已跳过"
+                        )
+                        continue
+                    # 创建工具实例
+                    tool = ToolClass(session_id=session_id, user_id=user_id)
+                    tool.set_message_attr(
+                        channel=channel, source=source, username=username
+                    )
+                    tool.set_stream_handler(stream_handler=stream_handler)
+                    tools.append(tool)
+                    plugin_tools_count += 1
+                    logger.debug(
+                        f"成功加载插件 {plugin_name}({plugin_id}) 的工具: {ToolClass.__name__}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"加载插件 {plugin_name}({plugin_id}) 的工具 {ToolClass.__name__} 失败: {str(e)}"
+                    )
+
+        builtin_tools_count = len(tool_definitions)
+        if plugin_tools_count > 0:
+            logger.info(
+                f"成功创建 {len(tools)} 个MoviePilot工具（内置工具: {builtin_tools_count} 个，插件工具: {plugin_tools_count} 个）"
+            )
+        else:
+            logger.info(f"成功创建 {len(tools)} 个MoviePilot工具")
+        return tools

app/agent/tools/impl/_torrent_search_utils.py

@@ -0,0 +1,176 @@
+"""种子搜索工具辅助函数"""
+
+import re
+from typing import List, Optional
+
+from app.core.context import Context
+from app.utils.crypto import HashUtils
+from app.utils.string import StringUtils
+
+SEARCH_RESULT_CACHE_FILE = "__search_result__"
+TORRENT_RESULT_LIMIT = 50
+
+
+def build_torrent_ref(context: Optional[Context]) -> str:
+    """生成用于下载校验的短引用"""
+    if not context or not context.torrent_info:
+        return ""
+    return HashUtils.sha1(context.torrent_info.enclosure or "")[:7]
+
+
+def sort_season_options(options: List[str]) -> List[str]:
+    """按前端逻辑排序季集选项"""
+    if len(options) <= 1:
+        return options
+
+    parsed_options = []
+    for index, option in enumerate(options):
+        match = re.match(r"^S(\d+)(?:-S(\d+))?\s*(?:E(\d+)(?:-E(\d+))?)?$", option or "")
+        if not match:
+            parsed_options.append({
+                "original": option,
+                "season_num": 0,
+                "episode_num": 0,
+                "max_episode_num": 0,
+                "is_whole_season": False,
+                "index": index,
+            })
+            continue
+
+        episode_num = int(match.group(3)) if match.group(3) else 0
+        max_episode_num = int(match.group(4)) if match.group(4) else episode_num
+        parsed_options.append({
+            "original": option,
+            "season_num": int(match.group(1)),
+            "episode_num": episode_num,
+            "max_episode_num": max_episode_num,
+            "is_whole_season": not match.group(3),
+            "index": index,
+        })
+
+    whole_seasons = [item for item in parsed_options if item["is_whole_season"]]
+    episodes = [item for item in parsed_options if not item["is_whole_season"]]
+
+    whole_seasons.sort(key=lambda item: (-item["season_num"], item["index"]))
+    episodes.sort(
+        key=lambda item: (
+            -item["season_num"],
+            -(item["max_episode_num"] or item["episode_num"]),
+            -item["episode_num"],
+            item["index"],
+        )
+    )
+    return [item["original"] for item in whole_seasons + episodes]
+
+
+def append_option(options: List[str], value: Optional[str]) -> None:
+    """按前端逻辑收集去重后的筛选项"""
+    if value and value not in options:
+        options.append(value)
+
+
+def build_filter_options(items: List[Context]) -> dict:
+    """从搜索结果中构建筛选项汇总"""
+    filter_options = {
+        "site": [],
+        "season": [],
+        "freeState": [],
+        "edition": [],
+        "resolution": [],
+        "videoCode": [],
+        "releaseGroup": [],
+    }
+
+    for item in items:
+        torrent_info = item.torrent_info
+        meta_info = item.meta_info
+        append_option(filter_options["site"], getattr(torrent_info, "site_name", None))
+        append_option(filter_options["season"], getattr(meta_info, "season_episode", None))
+        append_option(filter_options["freeState"], getattr(torrent_info, "volume_factor", None))
+        append_option(filter_options["edition"], getattr(meta_info, "edition", None))
+        append_option(filter_options["resolution"], getattr(meta_info, "resource_pix", None))
+        append_option(filter_options["videoCode"], getattr(meta_info, "video_encode", None))
+        append_option(filter_options["releaseGroup"], getattr(meta_info, "resource_team", None))
+
+    filter_options["season"] = sort_season_options(filter_options["season"])
+    return filter_options
+
+
+def match_filter(filter_values: Optional[List[str]], value: Optional[str]) -> bool:
+    """匹配前端同款多选筛选规则"""
+    return not filter_values or bool(value and value in filter_values)
+
+
+def filter_contexts(items: List[Context],
+                    site: Optional[List[str]] = None,
+                    season: Optional[List[str]] = None,
+                    free_state: Optional[List[str]] = None,
+                    video_code: Optional[List[str]] = None,
+                    edition: Optional[List[str]] = None,
+                    resolution: Optional[List[str]] = None,
+                    release_group: Optional[List[str]] = None) -> List[Context]:
+    """按前端同款维度筛选结果"""
+    filtered_items = []
+    for item in items:
+        torrent_info = item.torrent_info
+        meta_info = item.meta_info
+        if (
+            match_filter(site, getattr(torrent_info, "site_name", None))
+            and match_filter(free_state, getattr(torrent_info, "volume_factor", None))
+            and match_filter(season, getattr(meta_info, "season_episode", None))
+            and match_filter(release_group, getattr(meta_info, "resource_team", None))
+            and match_filter(video_code, getattr(meta_info, "video_encode", None))
+            and match_filter(resolution, getattr(meta_info, "resource_pix", None))
+            and match_filter(edition, getattr(meta_info, "edition", None))
+        ):
+            filtered_items.append(item)
+    return filtered_items
+
+
+def simplify_search_result(context: Context, index: int) -> dict:
+    """精简单条搜索结果"""
+    simplified = {}
+    torrent_info = context.torrent_info
+    meta_info = context.meta_info
+    media_info = context.media_info
+
+    if torrent_info:
+        simplified["torrent_info"] = {
+            "title": torrent_info.title,
+            "size": StringUtils.format_size(torrent_info.size),
+            "seeders": torrent_info.seeders,
+            "peers": torrent_info.peers,
+            "site_name": torrent_info.site_name,
+            "torrent_url": f"{build_torrent_ref(context)}:{index}",
+            "page_url": torrent_info.page_url,
+            "volume_factor": torrent_info.volume_factor,
+            "freedate_diff": torrent_info.freedate_diff,
+            "pubdate": torrent_info.pubdate,
+        }
+
+    if media_info:
+        simplified["media_info"] = {
+            "title": media_info.title,
+            "en_title": media_info.en_title,
+            "year": media_info.year,
+            "type": media_info.type.value if media_info.type else None,
+            "season": media_info.season,
+            "tmdb_id": media_info.tmdb_id,
+        }
+
+    if meta_info:
+        simplified["meta_info"] = {
+            "name": meta_info.name,
+            "cn_name": meta_info.cn_name,
+            "en_name": meta_info.en_name,
+            "year": meta_info.year,
+            "type": meta_info.type.value if meta_info.type else None,
+            "begin_season": meta_info.begin_season,
+            "season_episode": meta_info.season_episode,
+            "resource_team": meta_info.resource_team,
+            "video_encode": meta_info.video_encode,
+            "edition": meta_info.edition,
+            "resource_pix": meta_info.resource_pix,
+        }
+
+    return simplified

app/agent/tools/impl/add_download.py

@@ -0,0 +1,277 @@
+"""添加下载工具"""
+
+import re
+from pathlib import Path
+from typing import List, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool, ToolChain
+from app.chain.search import SearchChain
+from app.chain.download import DownloadChain
+from app.core.config import settings
+from app.core.context import Context
+from app.core.metainfo import MetaInfo
+from app.db.site_oper import SiteOper
+from app.helper.directory import DirectoryHelper
+from app.log import logger
+from app.schemas import TorrentInfo, FileURI
+from app.utils.crypto import HashUtils
+
+
+class AddDownloadInput(BaseModel):
+    """添加下载工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    torrent_url: List[str] = Field(
+        ...,
+        description="One or more torrent_url values. Supports refs from get_search_results (`hash:id`) and magnet links."
+    )
+    downloader: Optional[str] = Field(None,
+                                      description="Name of the downloader to use (optional, uses default if not specified)")
+    save_path: Optional[str] = Field(None,
+                                     description="Directory path where the downloaded files should be saved. Using `<storage>:<path>` for remote storage. e.g. rclone:/MP, smb:/server/share/Movies. (optional, uses default path if not specified)")
+    labels: Optional[str] = Field(None,
+                                  description="Comma-separated list of labels/tags to assign to the download (optional, e.g., 'movie,hd,bluray')")
+
+
+class AddDownloadTool(MoviePilotTool):
+    name: str = "add_download"
+    description: str = "Add torrent download tasks using refs from get_search_results or magnet links."
+    args_schema: Type[BaseModel] = AddDownloadInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据下载参数生成友好的提示消息"""
+        torrent_urls = self._normalize_torrent_urls(kwargs.get("torrent_url"))
+        downloader = kwargs.get("downloader")
+
+        if torrent_urls:
+            if len(torrent_urls) == 1:
+                if self._is_torrent_ref(torrent_urls[0]):
+                    message = f"正在添加下载任务: 资源 {torrent_urls[0]}"
+                else:
+                    message = "正在添加下载任务: 磁力链接"
+            else:
+                message = f"正在批量添加下载任务: 共 {len(torrent_urls)} 个资源"
+        else:
+            message = "正在添加下载任务"
+        if downloader:
+            message += f" [下载器: {downloader}]"
+
+        return message
+
+    @staticmethod
+    def _build_torrent_ref(context: Context) -> str:
+        """生成用于校验缓存项的短引用"""
+        if not context or not context.torrent_info:
+            return ""
+        return HashUtils.sha1(context.torrent_info.enclosure or "")[:7]
+
+    @staticmethod
+    def _is_torrent_ref(torrent_ref: Optional[str]) -> bool:
+        """判断是否为内部搜索结果引用"""
+        if not torrent_ref:
+            return False
+        return bool(re.fullmatch(r"[0-9a-f]{7}:\d+", str(torrent_ref).strip()))
+
+    @staticmethod
+    def _is_magnet_link_input(torrent_url: Optional[str]) -> bool:
+        """判断输入是否为允许直接添加的磁力链接"""
+        if not torrent_url:
+            return False
+        value = str(torrent_url).strip()
+        return value.startswith("magnet:")
+
+    @classmethod
+    def _resolve_cached_context(cls, torrent_ref: str) -> Optional[Context]:
+        """从最近一次搜索缓存中解析种子上下文，仅支持 hash:id 格式"""
+        ref = str(torrent_ref).strip()
+        if ":" not in ref:
+            return None
+        try:
+            ref_hash, ref_index = ref.split(":", 1)
+            index = int(ref_index)
+        except (TypeError, ValueError):
+            return None
+
+        if index < 1:
+            return None
+
+        results = SearchChain().last_search_results() or []
+        if index > len(results):
+            return None
+        context = results[index - 1]
+        if not ref_hash or cls._build_torrent_ref(context) != ref_hash:
+            return None
+        return context
+
+    @staticmethod
+    def _merge_labels_with_system_tag(labels: Optional[str]) -> Optional[str]:
+        """合并用户标签与系统默认标签，确保任务可被系统管理"""
+        system_tag = (settings.TORRENT_TAG or "").strip()
+        user_labels = [item.strip() for item in (labels or "").split(",") if item.strip()]
+
+        if system_tag and system_tag not in user_labels:
+            user_labels.append(system_tag)
+
+        return ",".join(user_labels) if user_labels else None
+
+    @staticmethod
+    def _format_failed_result(failed_messages: List[str]) -> str:
+        """统一格式化失败结果"""
+        return ", ".join([message for message in failed_messages if message])
+
+    @staticmethod
+    def _build_failure_message(torrent_ref: str, error_msg: Optional[str] = None) -> str:
+        """构造失败提示"""
+        normalized_error = (error_msg or "").strip()
+        prefix = "添加种子任务失败："
+        if normalized_error.startswith(prefix):
+            normalized_error = normalized_error[len(prefix):].lstrip()
+        if AddDownloadTool._is_magnet_link_input(normalized_error):
+            normalized_error = ""
+        if normalized_error:
+            return f"{torrent_ref} {normalized_error}"
+        if AddDownloadTool._is_torrent_ref(torrent_ref):
+            return torrent_ref
+        return ""
+
+    @classmethod
+    def _normalize_torrent_urls(cls, torrent_url: Optional[List[str] | str]) -> List[str]:
+        """统一规范 torrent_url 输入，保留所有非空值"""
+        if torrent_url is None:
+            return []
+
+        if isinstance(torrent_url, str):
+            candidates = torrent_url.split(",")
+        else:
+            candidates = torrent_url
+
+        return [str(item).strip() for item in candidates if item and str(item).strip()]
+
+    @staticmethod
+    def _resolve_direct_download_dir(save_path: Optional[str]) -> Optional[Path]:
+        """解析直接下载使用的目录，优先使用 save_path，其次使用默认下载目录"""
+        if save_path:
+            return Path(save_path)
+
+        download_dirs = DirectoryHelper().get_download_dirs()
+        if not download_dirs:
+            return None
+
+        dir_conf = download_dirs[0]
+        if not dir_conf.download_path:
+            return None
+
+        return Path(FileURI(storage=dir_conf.storage or "local", path=dir_conf.download_path).uri)
+
+    async def run(self, torrent_url: Optional[List[str]] = None,
+                  downloader: Optional[str] = None, save_path: Optional[str] = None,
+                  labels: Optional[str] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: torrent_url={torrent_url}, downloader={downloader}, save_path={save_path}, labels={labels}")
+
+        try:
+            torrent_inputs = self._normalize_torrent_urls(torrent_url)
+            if not torrent_inputs:
+                return "错误：torrent_url 不能为空。"
+
+            download_chain = DownloadChain()
+            merged_labels = self._merge_labels_with_system_tag(labels)
+            success_count = 0
+            failed_messages = []
+
+            for torrent_input in torrent_inputs:
+                if self._is_torrent_ref(torrent_input):
+                    cached_context = self._resolve_cached_context(torrent_input)
+                    if not cached_context or not cached_context.torrent_info:
+                        failed_messages.append(f"{torrent_input} 引用无效，请重新使用 get_search_results 查看搜索结果")
+                        continue
+
+                    cached_torrent = cached_context.torrent_info
+                    site_name = cached_torrent.site_name
+                    torrent_title = cached_torrent.title or torrent_input
+                    torrent_description = cached_torrent.description
+                    enclosure = cached_torrent.enclosure
+
+                    if not site_name:
+                        failed_messages.append(f"{torrent_input} 缺少站点名称")
+                        continue
+
+                    siteinfo = await SiteOper().async_get_by_name(site_name)
+                    if not siteinfo:
+                        failed_messages.append(f"{torrent_input} 未找到站点信息 {site_name}")
+                        continue
+
+                    torrent_info = TorrentInfo(
+                        title=torrent_title,
+                        description=torrent_description,
+                        enclosure=enclosure,
+                        site_name=site_name,
+                        site_ua=siteinfo.ua,
+                        site_cookie=siteinfo.cookie,
+                        site_proxy=siteinfo.proxy,
+                        site_order=siteinfo.pri,
+                        site_downloader=siteinfo.downloader
+                    )
+                    meta_info = MetaInfo(title=torrent_title, subtitle=torrent_description)
+                    media_info = cached_context.media_info if cached_context.media_info else None
+                    if not media_info:
+                        media_info = await ToolChain().async_recognize_media(meta=meta_info)
+                    if not media_info:
+                        failed_messages.append(f"{torrent_input} 无法识别媒体信息")
+                        continue
+
+                    context = Context(
+                        torrent_info=torrent_info,
+                        meta_info=meta_info,
+                        media_info=media_info
+                    )
+                else:
+                    if not self._is_magnet_link_input(torrent_input):
+                        failed_messages.append(
+                            f"{torrent_input} 不是有效的下载内容，非 hash:id 时仅支持 magnet: 开头"
+                        )
+                        continue
+                    download_dir = self._resolve_direct_download_dir(save_path)
+                    if not download_dir:
+                        failed_messages.append(f"{torrent_input} 缺少保存路径，且系统未配置可用下载目录")
+                        continue
+                    result = download_chain.download(
+                        content=torrent_input,
+                        download_dir=download_dir,
+                        cookie=None,
+                        label=merged_labels,
+                        downloader=downloader
+                    )
+                    if result:
+                        _, did, _, error_msg = result
+                    else:
+                        did, error_msg = None, "未找到下载器"
+                    if did:
+                        success_count += 1
+                    else:
+                        failed_messages.append(self._build_failure_message(torrent_input, error_msg))
+                    continue
+
+                did, error_msg = download_chain.download_single(
+                    context=context,
+                    downloader=downloader,
+                    save_path=save_path,
+                    label=merged_labels,
+                    return_detail=True
+                )
+                if did:
+                    success_count += 1
+                else:
+                    failed_messages.append(self._build_failure_message(torrent_input, error_msg))
+
+            if success_count and not failed_messages:
+                return "任务添加成功"
+
+            if success_count:
+                return f"部分任务添加失败：{self._format_failed_result(failed_messages)}"
+
+            return f"任务添加失败：{self._format_failed_result(failed_messages)}"
+        except Exception as e:
+            logger.error(f"添加下载任务失败: {e}", exc_info=True)
+            return f"添加下载任务时发生错误: {str(e)}"

app/agent/tools/impl/add_subscribe.py

@@ -0,0 +1,138 @@
+"""添加订阅工具"""
+
+from typing import Optional, Type, List
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.subscribe import SubscribeChain
+from app.log import logger
+from app.schemas.types import MediaType
+
+
+class AddSubscribeInput(BaseModel):
+    """添加订阅工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    title: str = Field(..., description="The title of the media to subscribe to (e.g., 'The Matrix', 'Breaking Bad')")
+    year: str = Field(..., description="Release year of the media (required for accurate identification)")
+    media_type: str = Field(...,
+                            description="Allowed values: movie, tv")
+    season: Optional[int] = Field(None,
+                                  description="Season number for TV shows (optional, if not specified will subscribe to all seasons)")
+    tmdb_id: Optional[int] = Field(None,
+                                   description="TMDB database ID for precise media identification (optional, can be obtained from search_media tool)")
+    douban_id: Optional[str] = Field(None,
+                                     description="Douban ID for precise media identification (optional, alternative to tmdb_id)")
+    start_episode: Optional[int] = Field(None,
+                                          description="Starting episode number for TV shows (optional, defaults to 1 if not specified)")
+    total_episode: Optional[int] = Field(None,
+                                          description="Total number of episodes for TV shows (optional, will be auto-detected from TMDB if not specified)")
+    quality: Optional[str] = Field(None,
+                                   description="Quality filter as regular expression (optional, e.g., 'BluRay|WEB-DL|HDTV')")
+    resolution: Optional[str] = Field(None,
+                                      description="Resolution filter as regular expression (optional, e.g., '1080p|720p|2160p')")
+    effect: Optional[str] = Field(None,
+                                  description="Effect filter as regular expression (optional, e.g., 'HDR|DV|SDR')")
+    filter_groups: Optional[List[str]] = Field(None,
+                               description="List of filter rule group names to apply (optional, can be obtained from query_rule_groups tool)")
+    sites: Optional[List[int]] = Field(None,
+                           description="List of site IDs to search from (optional, can be obtained from query_sites tool)")
+
+
+class AddSubscribeTool(MoviePilotTool):
+    name: str = "add_subscribe"
+    description: str = "Add media subscription to create automated download rules for movies and TV shows. The system will automatically search and download new episodes or releases based on the subscription criteria. Supports advanced filtering options like quality, resolution, and effect filters using regular expressions."
+    args_schema: Type[BaseModel] = AddSubscribeInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据订阅参数生成友好的提示消息"""
+        title = kwargs.get("title", "")
+        year = kwargs.get("year", "")
+        media_type = kwargs.get("media_type", "")
+        season = kwargs.get("season")
+        
+        message = f"正在添加订阅: {title}"
+        if year:
+            message += f" ({year})"
+        if media_type:
+            message += f" [{media_type}]"
+        if season:
+            message += f" 第{season}季"
+        
+        return message
+
+    async def run(self, title: str, year: str, media_type: str,
+                  season: Optional[int] = None, tmdb_id: Optional[int] = None,
+                  douban_id: Optional[str] = None,
+                  start_episode: Optional[int] = None, total_episode: Optional[int] = None,
+                  quality: Optional[str] = None, resolution: Optional[str] = None,
+                  effect: Optional[str] = None, filter_groups: Optional[List[str]] = None,
+                  sites: Optional[List[int]] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: title={title}, year={year}, media_type={media_type}, "
+            f"season={season}, tmdb_id={tmdb_id}, douban_id={douban_id}, start_episode={start_episode}, "
+            f"total_episode={total_episode}, quality={quality}, resolution={resolution}, "
+            f"effect={effect}, filter_groups={filter_groups}, sites={sites}")
+
+        try:
+            subscribe_chain = SubscribeChain()
+            media_type_enum = MediaType.from_agent(media_type)
+            if not media_type_enum:
+                return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv'"
+
+            # 构建额外的订阅参数
+            subscribe_kwargs = {}
+            if start_episode is not None:
+                subscribe_kwargs['start_episode'] = start_episode
+            if total_episode is not None:
+                subscribe_kwargs['total_episode'] = total_episode
+            if quality:
+                subscribe_kwargs['quality'] = quality
+            if resolution:
+                subscribe_kwargs['resolution'] = resolution
+            if effect:
+                subscribe_kwargs['effect'] = effect
+            if filter_groups:
+                subscribe_kwargs['filter_groups'] = filter_groups
+            if sites:
+                subscribe_kwargs['sites'] = sites
+
+            sid, message = await subscribe_chain.async_add(
+                mtype=media_type_enum,
+                title=title,
+                year=year,
+                tmdbid=tmdb_id,
+                doubanid=douban_id,
+                season=season,
+                username=self._user_id,
+                **subscribe_kwargs
+            )
+            if sid:
+                if message and "已存在" in message:
+                    return f"订阅已存在：{title} ({year})。如需修改参数请先删除旧订阅。"
+
+                result_msg = f"成功添加订阅：{title} ({year})"
+                if subscribe_kwargs:
+                    params = []
+                    if start_episode is not None:
+                        params.append(f"开始集数: {start_episode}")
+                    if total_episode is not None:
+                        params.append(f"总集数: {total_episode}")
+                    if quality:
+                        params.append(f"质量过滤: {quality}")
+                    if resolution:
+                        params.append(f"分辨率过滤: {resolution}")
+                    if effect:
+                        params.append(f"特效过滤: {effect}")
+                    if filter_groups:
+                        params.append(f"规则组: {', '.join(filter_groups)}")
+                    if sites:
+                        params.append(f"站点: {', '.join(map(str, sites))}")
+                    if params:
+                        result_msg += f"\n配置参数: {', '.join(params)}"
+                return result_msg
+            else:
+                return f"添加订阅失败：{message}"
+        except Exception as e:
+            logger.error(f"添加订阅失败: {e}", exc_info=True)
+            return f"添加订阅时发生错误: {str(e)}"

app/agent/tools/impl/browse_webpage.py

@@ -0,0 +1,539 @@
+"""浏览器操作工具 - 让Agent能够通过Playwright控制浏览器进行网页交互"""
+
+import asyncio
+import base64
+import json
+from enum import Enum
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.config import settings
+from app.log import logger
+
+# 页面内容最大长度
+MAX_CONTENT_LENGTH = 8000
+# 默认超时时间（秒）
+DEFAULT_TIMEOUT = 30
+# 截图最大宽度
+SCREENSHOT_MAX_WIDTH = 1280
+# 截图最大高度
+SCREENSHOT_MAX_HEIGHT = 720
+
+
+class BrowserAction(str, Enum):
+    """浏览器操作类型"""
+
+    GOTO = "goto"
+    GET_CONTENT = "get_content"
+    SCREENSHOT = "screenshot"
+    CLICK = "click"
+    FILL = "fill"
+    SELECT = "select"
+    EVALUATE = "evaluate"
+    WAIT = "wait"
+
+
+class BrowseWebpageInput(BaseModel):
+    """浏览器操作工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this browser action is being performed",
+    )
+    action: str = Field(
+        ...,
+        description=(
+            "The browser action to perform. Available actions:\n"
+            "- 'goto': Navigate to a URL, returns page title and text summary\n"
+            "- 'get_content': Get current page content (text or HTML)\n"
+            "- 'screenshot': Take a screenshot of the current page, returns base64 image\n"
+            "- 'click': Click on an element specified by selector\n"
+            "- 'fill': Fill text into an input element specified by selector\n"
+            "- 'select': Select an option from a dropdown element\n"
+            "- 'evaluate': Execute JavaScript code on the page and return the result\n"
+            "- 'wait': Wait for an element to appear on the page"
+        ),
+    )
+    url: Optional[str] = Field(
+        None, description="URL to navigate to (required for 'goto' action)"
+    )
+    selector: Optional[str] = Field(
+        None,
+        description="CSS selector or text selector for the target element (for 'click', 'fill', 'select', 'wait' actions). "
+        "Supports CSS selectors like '#id', '.class', 'tag', and Playwright text selectors like 'text=Click me'",
+    )
+    value: Optional[str] = Field(
+        None,
+        description="Value to fill into input or option value to select (for 'fill' and 'select' actions)",
+    )
+    script: Optional[str] = Field(
+        None,
+        description="JavaScript code to execute on the page (for 'evaluate' action). "
+        "The script should return a value that can be serialized to JSON.",
+    )
+    content_type: Optional[str] = Field(
+        "text",
+        description="Content type for 'get_content' action: 'text' for readable text, 'html' for raw HTML",
+    )
+    timeout: Optional[int] = Field(
+        DEFAULT_TIMEOUT, description="Timeout in seconds for the action (default: 30)"
+    )
+    cookies: Optional[str] = Field(
+        None,
+        description="Cookies to set for the browser context, format: 'name1=value1; name2=value2'",
+    )
+    user_agent: Optional[str] = Field(
+        None, description="Custom User-Agent string for the browser context"
+    )
+
+
+class BrowseWebpageTool(MoviePilotTool):
+    name: str = "browse_webpage"
+    description: str = (
+        "Control a real browser (Playwright) to interact with web pages. "
+        "Supports navigating to URLs, reading page content, taking screenshots, "
+        "clicking elements, filling forms, selecting dropdown options, executing JavaScript, and waiting for elements. "
+        "Use this tool when you need to interact with dynamic web pages, "
+        "fill in forms, click buttons, or extract content from JavaScript-rendered pages. "
+        "The browser session persists across multiple calls within the same conversation - "
+        "first call 'goto' to open a page, then use other actions to interact with it."
+    )
+    args_schema: Type[BaseModel] = BrowseWebpageInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据操作类型生成友好的提示消息"""
+        action = kwargs.get("action", "")
+        url = kwargs.get("url", "")
+        selector = kwargs.get("selector", "")
+        action_messages = {
+            "goto": f"正在打开网页: {url}",
+            "get_content": "正在获取页面内容",
+            "screenshot": "正在截取页面截图",
+            "click": f"正在点击元素: {selector}",
+            "fill": f"正在填写表单: {selector}",
+            "select": f"正在选择选项: {selector}",
+            "evaluate": "正在执行 JavaScript",
+            "wait": f"正在等待元素: {selector}",
+        }
+        return action_messages.get(action, f"正在执行浏览器操作: {action}")
+
+    async def run(
+        self,
+        action: str,
+        url: Optional[str] = None,
+        selector: Optional[str] = None,
+        value: Optional[str] = None,
+        script: Optional[str] = None,
+        content_type: Optional[str] = "text",
+        timeout: Optional[int] = DEFAULT_TIMEOUT,
+        cookies: Optional[str] = None,
+        user_agent: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        """执行浏览器操作"""
+        logger.info(
+            f"执行工具: {self.name}, 动作: {action}, URL: {url}, 选择器: {selector}"
+        )
+
+        try:
+            # 验证操作类型
+            try:
+                browser_action = BrowserAction(action)
+            except ValueError:
+                valid_actions = ", ".join([a.value for a in BrowserAction])
+                return f"错误: 不支持的操作类型 '{action}'，支持的操作: {valid_actions}"
+
+            # 参数校验
+            if browser_action == BrowserAction.GOTO and not url:
+                return "错误: 'goto' 操作需要提供 url 参数"
+            if (
+                browser_action
+                in (
+                    BrowserAction.CLICK,
+                    BrowserAction.FILL,
+                    BrowserAction.SELECT,
+                    BrowserAction.WAIT,
+                )
+                and not selector
+            ):
+                return f"错误: '{action}' 操作需要提供 selector 参数"
+            if browser_action == BrowserAction.FILL and value is None:
+                return "错误: 'fill' 操作需要提供 value 参数"
+            if browser_action == BrowserAction.EVALUATE and not script:
+                return "错误: 'evaluate' 操作需要提供 script 参数"
+
+            # 在线程池中运行同步的 Playwright 操作
+            loop = asyncio.get_running_loop()
+            result = await loop.run_in_executor(
+                None,
+                lambda: self._execute_browser_action(
+                    browser_action=browser_action,
+                    url=url,
+                    selector=selector,
+                    value=value,
+                    script=script,
+                    content_type=content_type,
+                    timeout=timeout,
+                    cookies=cookies,
+                    user_agent=user_agent,
+                ),
+            )
+            return result
+
+        except Exception as e:
+            logger.error(f"浏览器操作失败: {e}", exc_info=True)
+            return f"浏览器操作失败: {str(e)}"
+
+    def _execute_browser_action(
+        self,
+        browser_action: BrowserAction,
+        url: Optional[str],
+        selector: Optional[str],
+        value: Optional[str],
+        script: Optional[str],
+        content_type: Optional[str],
+        timeout: int,
+        cookies: Optional[str],
+        user_agent: Optional[str],
+    ) -> str:
+        """在同步上下文中执行 Playwright 浏览器操作"""
+        from playwright.sync_api import sync_playwright
+
+        try:
+            with sync_playwright() as playwright:
+                browser = None
+                context = None
+                page = None
+                try:
+                    # 启动浏览器
+                    browser_type = settings.PLAYWRIGHT_BROWSER_TYPE or "chromium"
+                    browser = playwright[browser_type].launch(headless=True)
+
+                    # 创建上下文
+                    context_kwargs = {}
+                    if user_agent:
+                        context_kwargs["user_agent"] = user_agent
+                    # 设置视口大小
+                    context_kwargs["viewport"] = {
+                        "width": SCREENSHOT_MAX_WIDTH,
+                        "height": SCREENSHOT_MAX_HEIGHT,
+                    }
+
+                    context = browser.new_context(**context_kwargs)
+                    page = context.new_page()
+                    page.set_default_timeout(timeout * 1000)
+
+                    # 设置 cookies
+                    if cookies:
+                        page.set_extra_http_headers({"cookie": cookies})
+
+                    # 对于非 goto 操作，如果提供了 url 先导航
+                    if url and browser_action != BrowserAction.GOTO:
+                        page.goto(
+                            url, wait_until="domcontentloaded", timeout=timeout * 1000
+                        )
+                        page.wait_for_load_state("networkidle", timeout=timeout * 1000)
+
+                    # 执行具体操作
+                    result = self._do_action(
+                        page,
+                        browser_action,
+                        url,
+                        selector,
+                        value,
+                        script,
+                        content_type,
+                        timeout,
+                    )
+                    return result
+
+                finally:
+                    if page:
+                        page.close()
+                    if context:
+                        context.close()
+                    if browser:
+                        browser.close()
+
+        except Exception as e:
+            logger.error(f"Playwright 执行失败: {e}", exc_info=True)
+            return f"Playwright 执行失败: {str(e)}"
+
+    def _do_action(
+        self,
+        page,
+        browser_action: BrowserAction,
+        url: Optional[str],
+        selector: Optional[str],
+        value: Optional[str],
+        script: Optional[str],
+        content_type: Optional[str],
+        timeout: int,
+    ) -> str:
+        """执行具体的浏览器操作"""
+
+        if browser_action == BrowserAction.GOTO:
+            return self._action_goto(page, url, timeout)
+
+        elif browser_action == BrowserAction.GET_CONTENT:
+            return self._action_get_content(page, content_type)
+
+        elif browser_action == BrowserAction.SCREENSHOT:
+            return self._action_screenshot(page)
+
+        elif browser_action == BrowserAction.CLICK:
+            return self._action_click(page, selector, timeout)
+
+        elif browser_action == BrowserAction.FILL:
+            return self._action_fill(page, selector, value, timeout)
+
+        elif browser_action == BrowserAction.SELECT:
+            return self._action_select(page, selector, value, timeout)
+
+        elif browser_action == BrowserAction.EVALUATE:
+            return self._action_evaluate(page, script)
+
+        elif browser_action == BrowserAction.WAIT:
+            return self._action_wait(page, selector, timeout)
+
+        return f"未知操作: {browser_action}"
+
+    @staticmethod
+    def _action_goto(page, url: str, timeout: int) -> str:
+        """导航到URL"""
+        response = page.goto(url, wait_until="domcontentloaded", timeout=timeout * 1000)
+        try:
+            page.wait_for_load_state("networkidle", timeout=min(timeout, 15) * 1000)
+        except Exception:
+            # networkidle 超时不是致命错误，页面可能已经可用
+            pass
+
+        status = response.status if response else "unknown"
+        title = page.title()
+        page_url = page.url
+
+        # 提取页面可读文本摘要
+        text_content = page.inner_text("body")
+        if text_content and len(text_content) > MAX_CONTENT_LENGTH:
+            text_content = text_content[:MAX_CONTENT_LENGTH] + "\n\n...(内容已截断)"
+
+        # 提取页面链接
+        links = page.evaluate("""
+            () => {
+                const links = [];
+                document.querySelectorAll('a[href]').forEach(a => {
+                    const text = a.innerText.trim();
+                    const href = a.href;
+                    if (text && href && !href.startsWith('javascript:')) {
+                        links.push({text: text.substring(0, 80), href: href});
+                    }
+                });
+                return links.slice(0, 30);
+            }
+        """)
+
+        # 提取表单信息
+        forms = page.evaluate("""
+            () => {
+                const forms = [];
+                document.querySelectorAll('input, textarea, select, button').forEach(el => {
+                    const info = {
+                        tag: el.tagName.toLowerCase(),
+                        type: el.type || '',
+                        name: el.name || '',
+                        id: el.id || '',
+                        placeholder: el.placeholder || '',
+                        value: el.tagName.toLowerCase() === 'select' ? '' : (el.value || '').substring(0, 50),
+                        text: el.innerText ? el.innerText.trim().substring(0, 50) : ''
+                    };
+                    // 只保留有标识信息的元素
+                    if (info.name || info.id || info.placeholder || info.text) {
+                        forms.push(info);
+                    }
+                });
+                return forms.slice(0, 30);
+            }
+        """)
+
+        result = {
+            "status": status,
+            "url": page_url,
+            "title": title,
+            "text_content": text_content,
+        }
+        if links:
+            result["links"] = links
+        if forms:
+            result["form_elements"] = forms
+
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    @staticmethod
+    def _action_get_content(page, content_type: Optional[str]) -> str:
+        """获取页面内容"""
+        title = page.title()
+        page_url = page.url
+
+        if content_type == "html":
+            content = page.content()
+        else:
+            content = page.inner_text("body")
+
+        if content and len(content) > MAX_CONTENT_LENGTH:
+            content = content[:MAX_CONTENT_LENGTH] + "\n\n...(内容已截断)"
+
+        result = {
+            "url": page_url,
+            "title": title,
+            "content_type": content_type,
+            "content": content,
+        }
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    @staticmethod
+    def _action_screenshot(page) -> str:
+        """截取页面截图"""
+        screenshot_bytes = page.screenshot(
+            full_page=False,
+            type="jpeg",
+            quality=60,
+        )
+        screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
+
+        # 限制截图大小（base64编码后大约增大33%）
+        max_b64_size = 200 * 1024  # ~150KB 原始图片
+        if len(screenshot_b64) > max_b64_size:
+            # 降低质量重新截图
+            screenshot_bytes = page.screenshot(
+                full_page=False,
+                type="jpeg",
+                quality=30,
+            )
+            screenshot_b64 = base64.b64encode(screenshot_bytes).decode("utf-8")
+
+        title = page.title()
+        page_url = page.url
+
+        result = {
+            "url": page_url,
+            "title": title,
+            "screenshot_base64": screenshot_b64,
+            "format": "jpeg",
+            "note": "截图已以 base64 编码返回",
+        }
+        return json.dumps(result, ensure_ascii=False, indent=2)
+
+    @staticmethod
+    def _action_click(page, selector: str, timeout: int) -> str:
+        """点击元素"""
+        page.click(selector, timeout=timeout * 1000)
+
+        # 等待可能的页面变化
+        try:
+            page.wait_for_load_state("networkidle", timeout=5000)
+        except Exception:
+            pass
+
+        title = page.title()
+        page_url = page.url
+
+        return json.dumps(
+            {
+                "success": True,
+                "message": f"成功点击元素: {selector}",
+                "current_url": page_url,
+                "current_title": title,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    @staticmethod
+    def _action_fill(page, selector: str, value: str, timeout: int) -> str:
+        """填写表单"""
+        page.fill(selector, value, timeout=timeout * 1000)
+
+        return json.dumps(
+            {
+                "success": True,
+                "message": f"成功填写元素 '{selector}' 的值为 '{value}'",
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    @staticmethod
+    def _action_select(page, selector: str, value: Optional[str], timeout: int) -> str:
+        """选择下拉选项"""
+        if value:
+            page.select_option(selector, value=value, timeout=timeout * 1000)
+        else:
+            return "错误: 'select' 操作需要提供 value 参数"
+
+        return json.dumps(
+            {
+                "success": True,
+                "message": f"成功选择元素 '{selector}' 的选项 '{value}'",
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    @staticmethod
+    def _action_evaluate(page, script: str) -> str:
+        """执行 JavaScript"""
+        result = page.evaluate(script)
+
+        # 格式化结果
+        if result is None:
+            formatted = "null"
+        elif isinstance(result, (dict, list)):
+            formatted = json.dumps(result, ensure_ascii=False, indent=2)
+        else:
+            formatted = str(result)
+
+        # 限制结果长度
+        if len(formatted) > MAX_CONTENT_LENGTH:
+            formatted = formatted[:MAX_CONTENT_LENGTH] + "\n\n...(结果已截断)"
+
+        return json.dumps(
+            {
+                "success": True,
+                "result": formatted,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+
+    @staticmethod
+    def _action_wait(page, selector: str, timeout: int) -> str:
+        """等待元素出现"""
+        element = page.wait_for_selector(selector, timeout=timeout * 1000)
+
+        if element:
+            visible = element.is_visible()
+            text = element.inner_text()
+            if text and len(text) > 200:
+                text = text[:200] + "..."
+
+            return json.dumps(
+                {
+                    "success": True,
+                    "message": f"元素 '{selector}' 已出现",
+                    "visible": visible,
+                    "text": text,
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        else:
+            return json.dumps(
+                {
+                    "success": False,
+                    "message": f"等待元素 '{selector}' 超时",
+                },
+                ensure_ascii=False,
+                indent=2,
+            )

app/agent/tools/impl/delete_download.py

@@ -0,0 +1,83 @@
+"""删除下载任务工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.download import DownloadChain
+from app.log import logger
+
+
+class DeleteDownloadInput(BaseModel):
+    """删除下载任务工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    hash: str = Field(
+        ..., description="Task hash (can be obtained from query_download_tasks tool)"
+    )
+    downloader: Optional[str] = Field(
+        None,
+        description="Name of specific downloader (optional, if not provided will search all downloaders)",
+    )
+    delete_files: Optional[bool] = Field(
+        False,
+        description="Whether to delete downloaded files along with the task (default: False, only removes the task from downloader)",
+    )
+
+
+class DeleteDownloadTool(MoviePilotTool):
+    name: str = "delete_download"
+    description: str = "Delete a download task from the downloader by task hash only. Optionally specify the downloader name and whether to delete downloaded files."
+    args_schema: Type[BaseModel] = DeleteDownloadInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据删除参数生成友好的提示消息"""
+        hash_value = kwargs.get("hash", "")
+        downloader = kwargs.get("downloader")
+        delete_files = kwargs.get("delete_files", False)
+
+        message = f"正在删除下载任务: {hash_value}"
+        if downloader:
+            message += f" [下载器: {downloader}]"
+        if delete_files:
+            message += " (包含文件)"
+
+        return message
+
+    async def run(
+        self,
+        hash: str,
+        downloader: Optional[str] = None,
+        delete_files: Optional[bool] = False,
+        **kwargs,
+    ) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: hash={hash}, downloader={downloader}, delete_files={delete_files}"
+        )
+
+        try:
+            download_chain = DownloadChain()
+
+            # 仅支持通过hash删除任务
+            if len(hash) != 40 or not all(c in "0123456789abcdefABCDEF" for c in hash):
+                return "参数错误：hash 格式无效，请先使用 query_download_tasks 工具获取正确的 hash。"
+
+            # 删除下载任务
+            # remove_torrents 支持 delete_file 参数，可以控制是否删除文件
+            result = download_chain.remove_torrents(
+                hashs=[hash], downloader=downloader, delete_file=delete_files
+            )
+
+            if result:
+                files_info = "（包含文件）" if delete_files else "（不包含文件）"
+                return f"成功删除下载任务：{hash} {files_info}"
+            else:
+                return f"删除下载任务失败：{hash}，请检查任务是否存在或下载器是否可用"
+        except Exception as e:
+            logger.error(f"删除下载任务失败: {e}", exc_info=True)
+            return f"删除下载任务时发生错误: {str(e)}"

app/agent/tools/impl/delete_download_history.py

@@ -0,0 +1,44 @@
+"""删除下载历史记录工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db import AsyncSessionFactory
+from app.db.models.downloadhistory import DownloadHistory
+from app.log import logger
+
+
+class DeleteDownloadHistoryInput(BaseModel):
+    """删除下载历史记录工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    history_id: int = Field(
+        ..., description="The ID of the download history record to delete"
+    )
+
+
+class DeleteDownloadHistoryTool(MoviePilotTool):
+    name: str = "delete_download_history"
+    description: str = "Delete a download history record by ID. This only removes the record from the database, does not delete any actual files."
+    args_schema: Type[BaseModel] = DeleteDownloadHistoryInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        history_id = kwargs.get("history_id")
+        return f"正在删除下载历史记录 ID: {history_id}"
+
+    async def run(self, history_id: int, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: history_id={history_id}")
+
+        try:
+            async with AsyncSessionFactory() as db:
+                await DownloadHistory.async_delete(db, history_id)
+                return f"下载历史记录 ID: {history_id} 已成功删除"
+        except Exception as e:
+            logger.error(f"删除下载历史记录失败: {e}", exc_info=True)
+            return f"删除下载历史记录时发生错误: {str(e)}"

app/agent/tools/impl/delete_subscribe.py

@@ -0,0 +1,69 @@
+"""删除订阅工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.event import eventmanager
+from app.db.subscribe_oper import SubscribeOper
+from app.helper.subscribe import SubscribeHelper
+from app.log import logger
+from app.schemas.types import EventType
+
+
+class DeleteSubscribeInput(BaseModel):
+    """删除订阅工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    subscribe_id: int = Field(
+        ...,
+        description="The ID of the subscription to delete (can be obtained from query_subscribes tool)",
+    )
+
+
+class DeleteSubscribeTool(MoviePilotTool):
+    name: str = "delete_subscribe"
+    description: str = "Delete a media subscription by its ID. This will remove the subscription and stop automatic downloads for that media."
+    args_schema: Type[BaseModel] = DeleteSubscribeInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据删除参数生成友好的提示消息"""
+        subscribe_id = kwargs.get("subscribe_id")
+        return f"正在删除订阅 (ID: {subscribe_id})"
+
+    async def run(self, subscribe_id: int, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: subscribe_id={subscribe_id}")
+
+        try:
+            subscribe_oper = SubscribeOper()
+            # 获取订阅信息
+            subscribe = await subscribe_oper.async_get(subscribe_id)
+            if not subscribe:
+                return f"订阅 ID {subscribe_id} 不存在"
+
+            # 在删除之前获取订阅信息（用于事件）
+            subscribe_info = subscribe.to_dict()
+
+            # 删除订阅
+            subscribe_oper.delete(subscribe_id)
+
+            # 发送事件
+            await eventmanager.async_send_event(
+                EventType.SubscribeDeleted,
+                {"subscribe_id": subscribe_id, "subscribe_info": subscribe_info},
+            )
+
+            # 统计订阅
+            SubscribeHelper().sub_done_async(
+                {"tmdbid": subscribe.tmdbid, "doubanid": subscribe.doubanid}
+            )
+
+            return f"成功删除订阅：{subscribe.name} ({subscribe.year})"
+        except Exception as e:
+            logger.error(f"删除订阅失败: {e}", exc_info=True)
+            return f"删除订阅时发生错误: {str(e)}"

app/agent/tools/impl/delete_transfer_history.py

@@ -0,0 +1,57 @@
+"""删除整理历史记录工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db.transferhistory_oper import TransferHistoryOper
+from app.log import logger
+
+
+class DeleteTransferHistoryInput(BaseModel):
+    """删除整理历史记录工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    history_id: int = Field(
+        ..., description="The ID of the transfer history record to delete"
+    )
+
+
+class DeleteTransferHistoryTool(MoviePilotTool):
+    name: str = "delete_transfer_history"
+    description: str = "Delete a specific transfer history record by its ID. This is useful when you need to remove a failed transfer record before retrying the transfer, as the system skips files that already have transfer history."
+    args_schema: Type[BaseModel] = DeleteTransferHistoryInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据参数生成友好的提示消息"""
+        history_id = kwargs.get("history_id")
+        return f"正在删除整理历史记录: ID={history_id}"
+
+    async def run(self, history_id: int, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: history_id={history_id}")
+
+        try:
+            transferhis = TransferHistoryOper()
+
+            # 查询历史记录是否存在
+            history = transferhis.get(history_id)
+            if not history:
+                return f"错误：整理历史记录不存在，ID={history_id}"
+
+            # 保存信息用于返回
+            title = history.title or "未知"
+            src = history.src or "未知"
+            status = "成功" if history.status else "失败"
+
+            # 删除记录
+            transferhis.delete(history_id)
+
+            return f"已删除整理历史记录：ID={history_id}，标题={title}，源路径={src}，状态={status}"
+        except Exception as e:
+            logger.error(f"删除整理历史记录失败: {e}", exc_info=True)
+            return f"删除整理历史记录时发生错误: {str(e)}"

app/agent/tools/impl/edit_file.py

@@ -0,0 +1,74 @@
+"""文件编辑工具"""
+
+from pathlib import Path
+from typing import Optional, Type
+
+from anyio import Path as AsyncPath
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.log import logger
+
+
+class EditFileInput(BaseModel):
+    """Input parameters for edit file tool"""
+
+    file_path: str = Field(..., description="The absolute path of the file to edit")
+    old_text: str = Field(..., description="The exact old text to be replaced")
+    new_text: str = Field(..., description="The new text to replace with")
+
+
+class EditFileTool(MoviePilotTool):
+    name: str = "edit_file"
+    description: str = "Edit a file by replacing specific old text with new text. Useful for modifying configuration files, code, or scripts."
+    args_schema: Type[BaseModel] = EditFileInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据参数生成友好的提示消息"""
+        file_path = kwargs.get("file_path", "")
+        file_name = Path(file_path).name if file_path else "未知文件"
+        return f"正在编辑文件: {file_name}"
+
+    async def run(self, file_path: str, old_text: str, new_text: str, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: file_path={file_path}")
+
+        try:
+            path = AsyncPath(file_path)
+            # 校验逻辑：如果要替换特定文本，文件必须存在且包含该文本
+            if not await path.exists():
+                # 如果 old_text 为空，可能用户想直接创建文件，但通常 edit_file 需要匹配旧内容
+                if old_text:
+                    return f"错误：文件 {file_path} 不存在，无法进行内容替换。"
+
+            if await path.exists() and not await path.is_file():
+                return f"错误：{file_path} 不是一个文件"
+
+            if await path.exists():
+                content = await path.read_text(encoding="utf-8")
+                if old_text not in content:
+                    logger.warning(f"编辑文件 {file_path} 失败：未找到指定的旧文本块")
+                    return f"错误：在文件 {file_path} 中未找到指定的旧文本。请确保包含所有的空格、缩进 and 换行符。"
+                occurrences = content.count(old_text)
+                new_content = content.replace(old_text, new_text)
+            else:
+                # 文件不存在且 old_text 为空的情形（初始化新文件）
+                new_content = new_text
+                occurrences = 1
+
+            # 自动创建父目录
+            await path.parent.mkdir(parents=True, exist_ok=True)
+
+            # 写入文件
+            await path.write_text(new_content, encoding="utf-8")
+
+            logger.info(f"成功编辑文件 {file_path}，替换了 {occurrences} 处内容")
+            return f"成功编辑文件 {file_path} (替换了 {occurrences} 处匹配内容)"
+
+        except PermissionError:
+            return f"错误：没有访问/修改 {file_path} 的权限"
+        except UnicodeDecodeError:
+            return f"错误：{file_path} 不是文本文件，无法编辑"
+        except Exception as e:
+            logger.error(f"编辑文件 {file_path} 时发生错误: {str(e)}", exc_info=True)
+            return f"操作失败: {str(e)}"

app/agent/tools/impl/execute_command.py

@@ -0,0 +1,96 @@
+"""执行Shell命令工具"""
+
+import asyncio
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.log import logger
+
+
+class ExecuteCommandInput(BaseModel):
+    """执行Shell命令工具的输入参数模型"""
+
+    explanation: str = Field(
+        ..., description="Clear explanation of why this command is being executed"
+    )
+    command: str = Field(..., description="The shell command to execute")
+    timeout: Optional[int] = Field(
+        60, description="Max execution time in seconds (default: 60)"
+    )
+
+
+class ExecuteCommandTool(MoviePilotTool):
+    name: str = "execute_command"
+    description: str = "Safely execute shell commands on the server. Useful for system maintenance, checking status, or running custom scripts. Includes timeout and output limits."
+    args_schema: Type[BaseModel] = ExecuteCommandInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据命令生成友好的提示消息"""
+        command = kwargs.get("command", "")
+        return f"正在执行系统命令: {command}"
+
+    async def run(self, command: str, timeout: Optional[int] = 60, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: command={command}, timeout={timeout}"
+        )
+
+        # 简单安全过滤
+        forbidden_keywords = [
+            "rm -rf /",
+            ":(){ :|:& };:",
+            "dd if=/dev/zero",
+            "mkfs",
+            "reboot",
+            "shutdown",
+        ]
+        for keyword in forbidden_keywords:
+            if keyword in command:
+                return f"错误：命令包含禁止使用的关键字 '{keyword}'"
+
+        try:
+            # 执行命令
+            process = await asyncio.create_subprocess_shell(
+                command, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+            )
+
+            try:
+                # 等待完成，带超时
+                stdout, stderr = await asyncio.wait_for(
+                    process.communicate(), timeout=timeout
+                )
+
+                # 处理输出
+                stdout_str = stdout.decode("utf-8", errors="replace").strip()
+                stderr_str = stderr.decode("utf-8", errors="replace").strip()
+                exit_code = process.returncode
+
+                result = f"命令执行完成 (退出码: {exit_code})"
+                if stdout_str:
+                    result += f"\n\n标准输出:\n{stdout_str}"
+                if stderr_str:
+                    result += f"\n\n错误输出:\n{stderr_str}"
+
+                # 如果没有输出
+                if not stdout_str and not stderr_str:
+                    result += "\n\n(无输出内容)"
+
+                # 限制输出长度，防止上下文过长
+                if len(result) > 3000:
+                    result = result[:3000] + "\n\n...(输出内容过长，已截断)"
+
+                return result
+
+            except asyncio.TimeoutError:
+                # 超时处理
+                try:
+                    process.kill()
+                except ProcessLookupError:
+                    pass
+                return f"命令执行超时 (限制: {timeout}秒)"
+
+        except Exception as e:
+            logger.error(f"执行命令失败: {e}", exc_info=True)
+            return f"执行命令时发生错误: {str(e)}"

app/agent/tools/impl/get_recommendations.py

@@ -0,0 +1,229 @@
+"""获取推荐工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.recommend import RecommendChain
+from app.log import logger
+from app.schemas.types import MediaType, media_type_to_agent
+
+
+class GetRecommendationsInput(BaseModel):
+    """获取推荐工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    source: Optional[str] = Field(
+        "tmdb_trending",
+        description="Recommendation source: "
+        "'tmdb_trending' for TMDB trending content, "
+        "'tmdb_movies' for TMDB popular movies, "
+        "'tmdb_tvs' for TMDB popular TV shows, "
+        "'douban_hot' for Douban popular content, "
+        "'douban_movie_hot' for Douban hot movies, "
+        "'douban_tv_hot' for Douban hot TV shows, "
+        "'douban_movie_showing' for Douban movies currently showing, "
+        "'douban_movies' for Douban latest movies, "
+        "'douban_tvs' for Douban latest TV shows, "
+        "'douban_movie_top250' for Douban movie TOP250, "
+        "'douban_tv_weekly_chinese' for Douban Chinese TV weekly chart, "
+        "'douban_tv_weekly_global' for Douban global TV weekly chart, "
+        "'douban_tv_animation' for Douban popular animation, "
+        "'bangumi_calendar' for Bangumi anime calendar",
+    )
+    media_type: Optional[str] = Field(
+        "all", description="Allowed values: movie, tv, all"
+    )
+    page: Optional[int] = Field(
+        1, description="Page number for pagination (default: 1, 20 items per page)"
+    )
+
+
+class GetRecommendationsTool(MoviePilotTool):
+    name: str = "get_recommendations"
+    description: str = "Get trending and popular media recommendations from various sources. Returns curated lists of popular movies, TV shows, and anime based on different criteria like trending, ratings, or calendar schedules. Supports pagination with 20 items per page."
+    args_schema: Type[BaseModel] = GetRecommendationsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据推荐参数生成友好的提示消息"""
+        source = kwargs.get("source", "tmdb_trending")
+        media_type = kwargs.get("media_type", "all")
+        page = kwargs.get("page", 1)
+
+        source_map = {
+            "tmdb_trending": "TMDB流行趋势",
+            "tmdb_movies": "TMDB热门电影",
+            "tmdb_tvs": "TMDB热门电视剧",
+            "douban_hot": "豆瓣热门",
+            "douban_movie_hot": "豆瓣热门电影",
+            "douban_tv_hot": "豆瓣热门电视剧",
+            "douban_movie_showing": "豆瓣正在热映",
+            "douban_movies": "豆瓣最新电影",
+            "douban_tvs": "豆瓣最新电视剧",
+            "douban_movie_top250": "豆瓣电影TOP250",
+            "douban_tv_weekly_chinese": "豆瓣国产剧集榜",
+            "douban_tv_weekly_global": "豆瓣全球剧集榜",
+            "douban_tv_animation": "豆瓣热门动漫",
+            "bangumi_calendar": "番组计划",
+        }
+        source_desc = source_map.get(source, source)
+
+        message = f"正在获取推荐: {source_desc}"
+        if media_type != "all":
+            message += f" [{media_type}]"
+        message += f" (第{page}页)"
+
+        return message
+
+    async def run(
+        self,
+        source: Optional[str] = "tmdb_trending",
+        media_type: Optional[str] = "all",
+        page: Optional[int] = 1,
+        **kwargs,
+    ) -> str:
+        page = max(1, page or 1)
+        page_size = 20
+        logger.info(
+            f"执行工具: {self.name}, 参数: source={source}, media_type={media_type}, page={page}"
+        )
+        try:
+            if media_type != "all":
+                media_type_enum = MediaType.from_agent(media_type)
+                if not media_type_enum:
+                    return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv', 'all'"
+                media_type = media_type_enum.to_agent()  # 归一化为 "movie"/"tv"
+
+            recommend_chain = RecommendChain()
+            results = []
+            if source == "tmdb_trending":
+                results = await recommend_chain.async_tmdb_trending(page=page)
+            elif source == "tmdb_movies":
+                results = await recommend_chain.async_tmdb_movies(page=page)
+            elif source == "tmdb_tvs":
+                results = await recommend_chain.async_tmdb_tvs(page=page)
+            elif source == "douban_hot":
+                if media_type == "movie":
+                    results = await recommend_chain.async_douban_movie_hot(
+                        page=page, count=page_size
+                    )
+                elif media_type == "tv":
+                    results = await recommend_chain.async_douban_tv_hot(
+                        page=page, count=page_size
+                    )
+                else:  # all
+                    results.extend(
+                        await recommend_chain.async_douban_movie_hot(
+                            page=page, count=page_size
+                        )
+                    )
+                    results.extend(
+                        await recommend_chain.async_douban_tv_hot(
+                            page=page, count=page_size
+                        )
+                    )
+            elif source == "douban_movie_hot":
+                results = await recommend_chain.async_douban_movie_hot(
+                    page=page, count=page_size
+                )
+            elif source == "douban_tv_hot":
+                results = await recommend_chain.async_douban_tv_hot(
+                    page=page, count=page_size
+                )
+            elif source == "douban_movie_showing":
+                results = await recommend_chain.async_douban_movie_showing(
+                    page=page, count=page_size
+                )
+            elif source == "douban_movies":
+                results = await recommend_chain.async_douban_movies(
+                    page=page, count=page_size
+                )
+            elif source == "douban_tvs":
+                results = await recommend_chain.async_douban_tvs(
+                    page=page, count=page_size
+                )
+            elif source == "douban_movie_top250":
+                results = await recommend_chain.async_douban_movie_top250(
+                    page=page, count=page_size
+                )
+            elif source == "douban_tv_weekly_chinese":
+                results = await recommend_chain.async_douban_tv_weekly_chinese(
+                    page=page, count=page_size
+                )
+            elif source == "douban_tv_weekly_global":
+                results = await recommend_chain.async_douban_tv_weekly_global(
+                    page=page, count=page_size
+                )
+            elif source == "douban_tv_animation":
+                results = await recommend_chain.async_douban_tv_animation(
+                    page=page, count=page_size
+                )
+            elif source == "bangumi_calendar":
+                results = await recommend_chain.async_bangumi_calendar(
+                    page=page, count=page_size
+                )
+            else:
+                # 不支持的推荐来源
+                supported_sources = [
+                    "tmdb_trending",
+                    "tmdb_movies",
+                    "tmdb_tvs",
+                    "douban_hot",
+                    "douban_movie_hot",
+                    "douban_tv_hot",
+                    "douban_movie_showing",
+                    "douban_movies",
+                    "douban_tvs",
+                    "douban_movie_top250",
+                    "douban_tv_weekly_chinese",
+                    "douban_tv_weekly_global",
+                    "douban_tv_animation",
+                    "bangumi_calendar",
+                ]
+                return f"不支持的推荐来源: {source}。支持的来源包括: {', '.join(supported_sources)}"
+
+            if results:
+                # 对于TMDB来源，API自身按页返回，取前page_size条
+                total_count = len(results)
+                page_results = results[:page_size]
+                # 精简字段，只保留关键信息
+                simplified_results = []
+                for r in page_results:
+                    # r 应该是字典格式（to_dict的结果），但为了安全起见进行检查
+                    if not isinstance(r, dict):
+                        logger.warning(f"推荐结果格式异常，跳过: {type(r)}")
+                        continue
+
+                    simplified = {
+                        "title": r.get("title"),
+                        "en_title": r.get("en_title"),
+                        "year": r.get("year"),
+                        "type": media_type_to_agent(r.get("type")),
+                        "season": r.get("season"),
+                        "tmdb_id": r.get("tmdb_id"),
+                        "imdb_id": r.get("imdb_id"),
+                        "douban_id": r.get("douban_id"),
+                        "vote_average": r.get("vote_average"),
+                        "poster_path": r.get("poster_path"),
+                        "detail_link": r.get("detail_link"),
+                    }
+                    simplified_results.append(simplified)
+                result_json = json.dumps(
+                    simplified_results, ensure_ascii=False, indent=2
+                )
+                has_more = total_count > page_size
+                payload_msg = f"第 {page} 页，当前页 {len(simplified_results)} 条结果。"
+                if has_more:
+                    payload_msg += (
+                        f" 可能有更多数据，可使用 page={page + 1} 获取下一页。"
+                    )
+                return f"{payload_msg}\n\n{result_json}"
+            return "未找到推荐内容。"
+        except Exception as e:
+            logger.error(f"获取推荐失败: {e}", exc_info=True)
+            return f"获取推荐时发生错误: {str(e)}"

app/agent/tools/impl/get_search_results.py

@@ -0,0 +1,155 @@
+"""获取搜索结果工具"""
+
+import json
+import re
+from typing import List, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.search import SearchChain
+from app.log import logger
+from ._torrent_search_utils import (
+    TORRENT_RESULT_LIMIT,
+    build_filter_options,
+    filter_contexts,
+    simplify_search_result,
+)
+
+
+class GetSearchResultsInput(BaseModel):
+    """获取搜索结果工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    site: Optional[List[str]] = Field(None, description="Site name filters")
+    season: Optional[List[str]] = Field(None, description="Season or episode filters")
+    free_state: Optional[List[str]] = Field(None, description="Promotion state filters")
+    video_code: Optional[List[str]] = Field(None, description="Video codec filters")
+    edition: Optional[List[str]] = Field(None, description="Edition filters")
+    resolution: Optional[List[str]] = Field(None, description="Resolution filters")
+    release_group: Optional[List[str]] = Field(
+        None, description="Release group filters"
+    )
+    title_pattern: Optional[str] = Field(
+        None,
+        description="Regular expression pattern to filter torrent titles (e.g., '4K|2160p|UHD', '1080p.*BluRay')",
+    )
+    show_filter_options: Optional[bool] = Field(
+        False,
+        description="Whether to return only optional filter options for re-checking available conditions",
+    )
+    page: Optional[int] = Field(
+        1,
+        description="Page number for pagination (default: 1, each page returns up to 50 results)",
+    )
+
+
+class GetSearchResultsTool(MoviePilotTool):
+    name: str = "get_search_results"
+    description: str = "Get cached torrent search results from search_torrents with optional filters. Supports pagination with up to 50 results per page."
+    args_schema: Type[BaseModel] = GetSearchResultsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        return "正在获取搜索结果"
+
+    async def run(
+        self,
+        site: Optional[List[str]] = None,
+        season: Optional[List[str]] = None,
+        free_state: Optional[List[str]] = None,
+        video_code: Optional[List[str]] = None,
+        edition: Optional[List[str]] = None,
+        resolution: Optional[List[str]] = None,
+        release_group: Optional[List[str]] = None,
+        title_pattern: Optional[str] = None,
+        show_filter_options: bool = False,
+        page: Optional[int] = 1,
+        **kwargs,
+    ) -> str:
+        page = max(1, page or 1)
+        logger.info(
+            f"执行工具: {self.name}, 参数: site={site}, season={season}, free_state={free_state}, video_code={video_code}, edition={edition}, resolution={resolution}, release_group={release_group}, title_pattern={title_pattern}, show_filter_options={show_filter_options}, page={page}"
+        )
+
+        try:
+            items = await SearchChain().async_last_search_results() or []
+            if not items:
+                return "没有可用的搜索结果，请先使用 search_torrents 搜索"
+
+            if show_filter_options:
+                payload = {
+                    "total_count": len(items),
+                    "filter_options": build_filter_options(items),
+                }
+                return json.dumps(payload, ensure_ascii=False, indent=2)
+
+            regex_pattern = None
+            if title_pattern:
+                try:
+                    regex_pattern = re.compile(title_pattern, re.IGNORECASE)
+                except re.error as e:
+                    logger.warning(f"正则表达式编译失败: {title_pattern}, 错误: {e}")
+                    return f"正则表达式格式错误: {str(e)}"
+
+            filtered_items = filter_contexts(
+                items=items,
+                site=site,
+                season=season,
+                free_state=free_state,
+                video_code=video_code,
+                edition=edition,
+                resolution=resolution,
+                release_group=release_group,
+            )
+            if regex_pattern:
+                filtered_items = [
+                    item
+                    for item in filtered_items
+                    if item.torrent_info
+                    and item.torrent_info.title
+                    and regex_pattern.search(item.torrent_info.title)
+                ]
+            if not filtered_items:
+                return "没有符合筛选条件的搜索结果，请调整筛选条件"
+
+            total_count = len(filtered_items)
+            filtered_ids = {id(item) for item in filtered_items}
+            matched_indices = [
+                index
+                for index, item in enumerate(items, start=1)
+                if id(item) in filtered_ids
+            ]
+
+            # 分页
+            page_size = TORRENT_RESULT_LIMIT
+            start = (page - 1) * page_size
+            end = start + page_size
+            page_items = filtered_items[start:end]
+            page_indices = matched_indices[start:end]
+
+            if not page_items:
+                return f"第 {page} 页没有数据，共 {total_count} 条结果，共 {(total_count + page_size - 1) // page_size} 页。"
+
+            results = [
+                simplify_search_result(item, index)
+                for item, index in zip(page_items, page_indices)
+            ]
+            total_pages = (total_count + page_size - 1) // page_size
+            payload = {
+                "total_count": total_count,
+                "page": page,
+                "total_pages": total_pages,
+                "results": results,
+            }
+            if page < total_pages:
+                payload["message"] = (
+                    f"搜索结果共 {total_count} 条，当前第 {page}/{total_pages} 页，可使用 page={page + 1} 获取下一页。"
+                )
+            return json.dumps(payload, ensure_ascii=False, indent=2)
+        except Exception as e:
+            error_message = f"获取搜索结果失败: {str(e)}"
+            logger.error(f"获取搜索结果失败: {e}", exc_info=True)
+            return error_message

app/agent/tools/impl/list_directory.py

@@ -0,0 +1,130 @@
+"""查询文件系统目录内容工具"""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.storage import StorageChain
+from app.log import logger
+from app.schemas.file import FileItem
+from app.utils.string import StringUtils
+
+
+class ListDirectoryInput(BaseModel):
+    """查询文件系统目录内容工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    path: str = Field(..., description="Directory path to list contents (e.g., '/home/user/downloads' or 'C:/Downloads')")
+    storage: Optional[str] = Field("local", description="Storage type (default: 'local' for local file system, can be 'smb', 'alist', etc.)")
+    sort_by: Optional[str] = Field("name", description="Sort order: 'name' for alphabetical sorting, 'time' for modification time sorting (default: 'name')")
+
+
+class ListDirectoryTool(MoviePilotTool):
+    name: str = "list_directory"
+    description: str = "List actual files and folders in a file system directory (NOT configuration). Shows files and subdirectories with their names, types, sizes, and modification times. Returns up to 20 items and the total count if there are more items. Use 'query_directory_settings' to query directory configuration settings."
+    args_schema: Type[BaseModel] = ListDirectoryInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据目录参数生成友好的提示消息"""
+        path = kwargs.get("path", "")
+        storage = kwargs.get("storage", "local")
+        
+        message = f"正在查询目录: {path}"
+        if storage != "local":
+            message += f" [存储: {storage}]"
+        
+        return message
+
+    async def run(self, path: str, storage: Optional[str] = "local",
+                  sort_by: Optional[str] = "name", **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: path={path}, storage={storage}, sort_by={sort_by}")
+
+        try:
+            # 规范化路径
+            if not path:
+                return "错误：路径不能为空"
+            
+            # 确保路径格式正确
+            if storage == "local":
+                # 本地路径处理
+                if not path.startswith("/") and not (len(path) > 1 and path[1] == ":"):
+                    # 相对路径，尝试转换为绝对路径
+                    path = str(Path(path).resolve())
+            else:
+                # 远程存储路径，确保以/开头
+                if not path.startswith("/"):
+                    path = "/" + path
+            
+            # 创建FileItem
+            fileitem = FileItem(
+                storage=storage or "local",
+                path=path,
+                type="dir"
+            )
+            
+            # 查询目录内容
+            storage_chain = StorageChain()
+            file_list = storage_chain.list_files(fileitem, recursion=False)
+            
+            if file_list is None:
+                return f"无法访问目录：{path}，请检查路径是否正确或存储是否可用"
+            
+            if not file_list:
+                return f"目录 {path} 为空"
+            
+            # 排序
+            if sort_by == "time":
+                file_list.sort(key=lambda x: x.modify_time or 0, reverse=True)
+            else:
+                # 默认按名称排序（目录优先，然后按名称）
+                file_list.sort(key=lambda x: (
+                    0 if x.type == "dir" else 1,
+                    StringUtils.natural_sort_key(x.name or "")
+                ))
+            
+            # 限制返回数量
+            total_count = len(file_list)
+            limited_list = file_list[:20]
+            
+            # 转换为字典格式
+            simplified_items = []
+            for item in limited_list:
+                # 格式化文件大小
+                size_str = None
+                if item.size:
+                    size_str = StringUtils.str_filesize(item.size)
+                
+                # 格式化修改时间
+                modify_time_str = None
+                if item.modify_time:
+                    try:
+                        modify_time_str = datetime.fromtimestamp(item.modify_time).strftime("%Y-%m-%d %H:%M:%S")
+                    except (ValueError, OSError):
+                        modify_time_str = str(item.modify_time)
+                
+                simplified = {
+                    "name": item.name,
+                    "type": item.type,
+                    "path": item.path,
+                    "size": size_str,
+                    "modify_time": modify_time_str
+                }
+                # 如果是文件，添加扩展名
+                if item.type == "file" and item.extension:
+                    simplified["extension"] = item.extension
+                simplified_items.append(simplified)
+            
+            result_json = json.dumps(simplified_items, ensure_ascii=False, indent=2)
+            
+            # 如果结果被裁剪，添加提示信息
+            if total_count > 100:
+                return f"注意：目录中共有 {total_count} 个项目，为节省上下文空间，仅显示前 100 个项目。\n\n{result_json}"
+            else:
+                return result_json
+        except Exception as e:
+            logger.error(f"查询目录内容失败: {e}", exc_info=True)
+            return f"查询目录内容时发生错误: {str(e)}"
+

app/agent/tools/impl/list_slash_commands.py

@@ -0,0 +1,79 @@
+"""查询所有可用斜杠命令工具（系统命令 + 插件命令）"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.log import logger
+
+
+class ListSlashCommandsInput(BaseModel):
+    """查询所有可用斜杠命令工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+
+
+class ListSlashCommandsTool(MoviePilotTool):
+    name: str = "list_slash_commands"
+    description: str = (
+        "List all available slash commands in the system, including system preset commands "
+        "(e.g. /cookiecloud, /sites, /subscribes, /downloading, /transfer, /restart, etc.) "
+        "and plugin-registered commands. "
+        "Use this tool to discover what slash commands are available before executing them with run_slash_command. "
+        "This is especially useful when the user describes an action in natural language and you need to "
+        "find the matching command to fulfill their request."
+    )
+    args_schema: Type[BaseModel] = ListSlashCommandsInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """生成友好的提示消息"""
+        return "正在查询所有可用命令"
+
+    async def run(self, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}")
+
+        try:
+            from app.command import Command
+
+            command_obj = Command()
+            all_commands = command_obj.get_commands()
+
+            if not all_commands:
+                return "当前没有可用的命令"
+
+            commands_list = []
+            for cmd, info in all_commands.items():
+                cmd_info = {
+                    "command": cmd,
+                    "description": info.get("description", ""),
+                }
+                if info.get("category"):
+                    cmd_info["category"] = info["category"]
+                # 标识命令类型
+                if info.get("type") == "scheduler":
+                    cmd_info["type"] = "scheduler"
+                elif info.get("pid"):
+                    cmd_info["type"] = "plugin"
+                    cmd_info["plugin_id"] = info["pid"]
+                else:
+                    cmd_info["type"] = "system"
+                commands_list.append(cmd_info)
+
+            result = {
+                "total": len(commands_list),
+                "commands": commands_list,
+            }
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            logger.error(f"查询可用命令失败: {e}", exc_info=True)
+            return json.dumps(
+                {"success": False, "message": f"查询可用命令时发生错误: {str(e)}"},
+                ensure_ascii=False,
+            )

app/agent/tools/impl/modify_download.py

@@ -0,0 +1,124 @@
+"""修改下载任务工具"""
+
+from typing import Optional, Type, List
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.download import DownloadChain
+from app.log import logger
+
+
+class ModifyDownloadInput(BaseModel):
+    """修改下载任务工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    hash: str = Field(
+        ..., description="Task hash (can be obtained from query_download_tasks tool)"
+    )
+    action: Optional[str] = Field(
+        None,
+        description="Action to perform on the task: 'start' to resume downloading, 'stop' to pause downloading. "
+        "If not provided, no start/stop action will be performed.",
+    )
+    tags: Optional[List[str]] = Field(
+        None,
+        description="List of tags to set on the download task. If provided, these tags will be added to the task. "
+        "Example: ['movie', 'hd']",
+    )
+    downloader: Optional[str] = Field(
+        None,
+        description="Name of specific downloader (optional, if not provided will search all downloaders)",
+    )
+
+
+class ModifyDownloadTool(MoviePilotTool):
+    """修改下载任务工具"""
+
+    name: str = "modify_download"
+    description: str = (
+        "Modify a download task in the downloader by task hash. "
+        "Supports: 1) Setting tags on a download task, "
+        "2) Starting (resuming) a paused download task, "
+        "3) Stopping (pausing) a downloading task. "
+        "Multiple operations can be performed in a single call."
+    )
+    args_schema: Type[BaseModel] = ModifyDownloadInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        hash_value = kwargs.get("hash", "")
+        action = kwargs.get("action")
+        tags = kwargs.get("tags")
+        downloader = kwargs.get("downloader")
+
+        parts = [f"正在修改下载任务: {hash_value}"]
+        if action == "start":
+            parts.append("操作: 开始下载")
+        elif action == "stop":
+            parts.append("操作: 暂停下载")
+        if tags:
+            parts.append(f"标签: {', '.join(tags)}")
+        if downloader:
+            parts.append(f"下载器: {downloader}")
+        return " | ".join(parts)
+
+    async def run(
+        self,
+        hash: str,
+        action: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        downloader: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: hash={hash}, action={action}, tags={tags}, downloader={downloader}"
+        )
+
+        try:
+            # 校验 hash 格式
+            if len(hash) != 40 or not all(c in "0123456789abcdefABCDEF" for c in hash):
+                return "参数错误：hash 格式无效，请先使用 query_download_tasks 工具获取正确的 hash。"
+
+            # 校验参数：至少需要一个操作
+            if not action and not tags:
+                return "参数错误：至少需要指定 action（start/stop）或 tags 中的一个。"
+
+            # 校验 action 参数
+            if action and action not in ("start", "stop"):
+                return f"参数错误：action 只支持 'start'（开始下载）或 'stop'（暂停下载），收到: '{action}'。"
+
+            download_chain = DownloadChain()
+            results = []
+
+            # 设置标签
+            if tags:
+                tag_result = download_chain.set_torrents_tag(
+                    hashs=[hash], tags=tags, downloader=downloader
+                )
+                if tag_result:
+                    results.append(f"成功设置标签：{', '.join(tags)}")
+                else:
+                    results.append(f"设置标签失败，请检查任务是否存在或下载器是否可用")
+
+            # 执行开始/暂停操作
+            if action:
+                action_result = download_chain.set_downloading(
+                    hash_str=hash, oper=action, name=downloader
+                )
+                action_desc = "开始" if action == "start" else "暂停"
+                if action_result:
+                    results.append(f"成功{action_desc}下载任务")
+                else:
+                    results.append(
+                        f"{action_desc}下载任务失败，请检查任务是否存在或下载器是否可用"
+                    )
+
+            return f"下载任务 {hash}：" + "；".join(results)
+
+        except Exception as e:
+            logger.error(f"修改下载任务失败: {e}", exc_info=True)
+            return f"修改下载任务时发生错误: {str(e)}"

app/agent/tools/impl/query_custom_identifiers.py

@@ -0,0 +1,66 @@
+"""查询自定义识别词工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db.systemconfig_oper import SystemConfigOper
+from app.log import logger
+from app.schemas.types import SystemConfigKey
+
+
+class QueryCustomIdentifiersInput(BaseModel):
+    """查询自定义识别词工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+
+
+class QueryCustomIdentifiersTool(MoviePilotTool):
+    name: str = "query_custom_identifiers"
+    description: str = (
+        "Query all currently configured custom identifiers (自定义识别词). "
+        "Returns the list of identifier rules used for preprocessing torrent/file names before media recognition. "
+        "Use this tool to check existing rules before adding new ones to avoid duplicates."
+    )
+    args_schema: Type[BaseModel] = QueryCustomIdentifiersInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """生成友好的提示消息"""
+        return "正在查询自定义识别词"
+
+    async def run(self, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}")
+        try:
+            system_config_oper = SystemConfigOper()
+            identifiers = system_config_oper.get(SystemConfigKey.CustomIdentifiers)
+            if identifiers:
+                return json.dumps(
+                    {
+                        "success": True,
+                        "count": len(identifiers),
+                        "identifiers": identifiers,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            return json.dumps(
+                {
+                    "success": True,
+                    "count": 0,
+                    "identifiers": [],
+                    "message": "当前没有配置自定义识别词",
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+        except Exception as e:
+            logger.error(f"查询自定义识别词失败: {e}")
+            return json.dumps(
+                {"success": False, "message": f"查询自定义识别词时发生错误: {str(e)}"},
+                ensure_ascii=False,
+            )

app/agent/tools/impl/query_directory_settings.py

@@ -0,0 +1,134 @@
+"""查询系统目录设置工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.helper.directory import DirectoryHelper
+from app.log import logger
+
+
+class QueryDirectorySettingsInput(BaseModel):
+    """查询系统目录设置工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    directory_type: Optional[str] = Field("all",
+                                          description="Filter directories by type: 'download' for download directories, 'library' for media library directories, 'all' for all directories")
+    storage_type: Optional[str] = Field("all",
+                                        description="Filter directories by storage type: 'local' for local storage, 'remote' for remote storage, 'all' for all storage types")
+    name: Optional[str] = Field(None,
+                               description="Filter directories by name (partial match, optional)")
+
+
+class QueryDirectorySettingsTool(MoviePilotTool):
+    name: str = "query_directory_settings"
+    description: str = "Query system directory configuration settings (NOT file listings). Returns configured directory paths, storage types, transfer modes, and other directory-related settings. Use 'list_directory' to list actual files and folders in a directory."
+    args_schema: Type[BaseModel] = QueryDirectorySettingsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        directory_type = kwargs.get("directory_type", "all")
+        storage_type = kwargs.get("storage_type", "all")
+        name = kwargs.get("name")
+        
+        parts = ["正在查询目录配置"]
+        
+        if directory_type != "all":
+            type_map = {"download": "下载目录", "library": "媒体库目录"}
+            parts.append(f"类型: {type_map.get(directory_type, directory_type)}")
+        
+        if storage_type != "all":
+            storage_map = {"local": "本地存储", "remote": "远程存储"}
+            parts.append(f"存储: {storage_map.get(storage_type, storage_type)}")
+        
+        if name:
+            parts.append(f"名称: {name}")
+        
+        return " | ".join(parts) if len(parts) > 1 else parts[0]
+
+    async def run(self, directory_type: Optional[str] = "all",
+                  storage_type: Optional[str] = "all",
+                  name: Optional[str] = None, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: directory_type={directory_type}, storage_type={storage_type}, name={name}")
+
+        try:
+            directory_helper = DirectoryHelper()
+            
+            # 根据目录类型获取目录列表
+            if directory_type == "download":
+                dirs = directory_helper.get_download_dirs()
+            elif directory_type == "library":
+                dirs = directory_helper.get_library_dirs()
+            else:
+                dirs = directory_helper.get_dirs()
+            
+            # 按存储类型过滤
+            filtered_dirs = []
+            for d in dirs:
+                # 按存储类型过滤
+                if storage_type == "local":
+                    # 对于下载目录，检查 storage；对于媒体库目录，检查 library_storage
+                    if directory_type == "download" and d.storage != "local":
+                        continue
+                    elif directory_type == "library" and d.library_storage != "local":
+                        continue
+                    elif directory_type == "all":
+                        # 检查是否有本地存储配置
+                        if d.download_path and d.storage != "local":
+                            continue
+                        if d.library_path and d.library_storage != "local":
+                            continue
+                elif storage_type == "remote":
+                    # 对于下载目录，检查 storage；对于媒体库目录，检查 library_storage
+                    if directory_type == "download" and d.storage == "local":
+                        continue
+                    elif directory_type == "library" and d.library_storage == "local":
+                        continue
+                    elif directory_type == "all":
+                        # 检查是否有远程存储配置
+                        if d.download_path and d.storage == "local":
+                            continue
+                        if d.library_path and d.library_storage == "local":
+                            continue
+                
+                # 按名称过滤（部分匹配）
+                if name and d.name and name.lower() not in d.name.lower():
+                    continue
+                
+                filtered_dirs.append(d)
+            
+            if filtered_dirs:
+                # 转换为字典格式，只保留关键信息
+                simplified_dirs = []
+                for d in filtered_dirs:
+                    simplified = {
+                        "name": d.name,
+                        "priority": d.priority,
+                        "storage": d.storage,
+                        "download_path": d.download_path,
+                        "library_path": d.library_path,
+                        "library_storage": d.library_storage,
+                        "media_type": d.media_type,
+                        "media_category": d.media_category,
+                        "monitor_type": d.monitor_type,
+                        "monitor_mode": d.monitor_mode,
+                        "transfer_type": d.transfer_type,
+                        "overwrite_mode": d.overwrite_mode,
+                        "renaming": d.renaming,
+                        "scraping": d.scraping,
+                        "notify": d.notify,
+                        "download_type_folder": d.download_type_folder,
+                        "download_category_folder": d.download_category_folder,
+                        "library_type_folder": d.library_type_folder,
+                        "library_category_folder": d.library_category_folder
+                    }
+                    simplified_dirs.append(simplified)
+                
+                result_json = json.dumps(simplified_dirs, ensure_ascii=False, indent=2)
+                return result_json
+            return "未找到相关目录配置"
+        except Exception as e:
+            logger.error(f"查询系统目录设置失败: {e}", exc_info=True)
+            return f"查询系统目录设置时发生错误: {str(e)}"
+

app/agent/tools/impl/query_download_tasks.py

@@ -0,0 +1,267 @@
+"""查询下载工具"""
+
+import json
+from typing import Optional, Type, List, Union
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.download import DownloadChain
+from app.db.downloadhistory_oper import DownloadHistoryOper
+from app.log import logger
+from app.schemas import TransferTorrent, DownloadingTorrent
+from app.schemas.types import TorrentStatus, media_type_to_agent
+
+
+class QueryDownloadTasksInput(BaseModel):
+    """查询下载工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    downloader: Optional[str] = Field(None,
+                                      description="Name of specific downloader to query (optional, if not provided queries all configured downloaders)")
+    status: Optional[str] = Field("all",
+                                  description="Filter downloads by status: 'downloading' for active downloads, 'completed' for finished downloads, 'paused' for paused downloads, 'all' for all downloads")
+    hash: Optional[str] = Field(None, description="Query specific download task by hash (optional, if provided will search for this specific task regardless of status)")
+    title: Optional[str] = Field(None, description="Query download tasks by title/name (optional, supports partial match, searches all tasks if provided)")
+    tag: Optional[str] = Field(None, description="Filter download tasks by tag (optional, supports partial match, e.g. 'movie' will match tasks with tag 'movie' or 'movie_2024')")
+
+
+class QueryDownloadTasksTool(MoviePilotTool):
+    name: str = "query_download_tasks"
+    description: str = "Query download status and list download tasks. Can query all active downloads, or search for specific tasks by hash, title, or tag. Shows download progress, completion status, tags, and task details from configured downloaders."
+    args_schema: Type[BaseModel] = QueryDownloadTasksInput
+
+    @staticmethod
+    def _get_all_torrents(download_chain: DownloadChain, downloader: Optional[str] = None) -> List[Union[TransferTorrent, DownloadingTorrent]]:
+        """
+        查询所有状态的任务（包括下载中和已完成的任务）
+        """
+        all_torrents = []
+        # 查询正在下载的任务
+        downloading_torrents = download_chain.list_torrents(
+            downloader=downloader, 
+            status=TorrentStatus.DOWNLOADING
+        ) or []
+        all_torrents.extend(downloading_torrents)
+        
+        # 查询已完成的任务（可转移状态）
+        transfer_torrents = download_chain.list_torrents(
+            downloader=downloader,
+            status=TorrentStatus.TRANSFER
+        ) or []
+        all_torrents.extend(transfer_torrents)
+        
+        return all_torrents
+
+    @staticmethod
+    def _format_progress(progress: Optional[float]) -> Optional[str]:
+        """
+        将下载进度格式化为保留一位小数的百分比字符串
+        """
+        try:
+            if progress is None:
+                return None
+            return f"{float(progress):.1f}%"
+        except (TypeError, ValueError):
+            return None
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        downloader = kwargs.get("downloader")
+        status = kwargs.get("status", "all")
+        hash_value = kwargs.get("hash")
+        title = kwargs.get("title")
+        
+        parts = ["正在查询下载任务"]
+        
+        if downloader:
+            parts.append(f"下载器: {downloader}")
+        
+        if status != "all":
+            status_map = {"downloading": "下载中", "completed": "已完成", "paused": "已暂停"}
+            parts.append(f"状态: {status_map.get(status, status)}")
+        
+        if hash_value:
+            parts.append(f"Hash: {hash_value[:8]}...")
+        elif title:
+            parts.append(f"标题: {title}")
+
+        tag = kwargs.get("tag")
+        if tag:
+            parts.append(f"标签: {tag}")
+        
+        return " | ".join(parts) if len(parts) > 1 else parts[0]
+
+    async def run(self, downloader: Optional[str] = None,
+                  status: Optional[str] = "all",
+                  hash: Optional[str] = None,
+                  title: Optional[str] = None,
+                  tag: Optional[str] = None, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: downloader={downloader}, status={status}, hash={hash}, title={title}, tag={tag}")
+        try:
+            download_chain = DownloadChain()
+            
+            # 如果提供了hash，直接查询该hash的任务（不限制状态）
+            if hash:
+                torrents = download_chain.list_torrents(downloader=downloader, hashs=[hash]) or []
+                if not torrents:
+                    return f"未找到hash为 {hash} 的下载任务（该任务可能已完成、已删除或不存在）"
+                # 转换为DownloadingTorrent格式
+                downloads = []
+                for torrent in torrents:
+                    # 获取下载历史信息
+                    history = DownloadHistoryOper().get_by_hash(torrent.hash)
+                    if history:
+                        if hasattr(torrent, "media"):
+                            torrent.media = {
+                                "tmdbid": history.tmdbid,
+                                "type": history.type,
+                                "title": history.title,
+                                "season": history.seasons,
+                                "episode": history.episodes,
+                                "image": history.image,
+                            }
+                        if hasattr(torrent, "username"):
+                            torrent.username = history.username
+                        torrent.userid = history.userid
+                    downloads.append(torrent)
+                filtered_downloads = downloads
+            elif title:
+                # 如果提供了title，查询所有任务并搜索匹配的标题
+                # 查询所有状态的任务
+                all_torrents = self._get_all_torrents(download_chain, downloader)
+                filtered_downloads = []
+                title_lower = title.lower()
+                for torrent in all_torrents:
+                    # 获取下载历史信息
+                    history = DownloadHistoryOper().get_by_hash(torrent.hash)
+                    
+                    # 检查标题或名称是否匹配（包括下载历史中的标题）
+                    matched = False
+                    # 检查torrent的title和name字段
+                    if (title_lower in (torrent.title or "").lower()) or \
+                       (title_lower in (getattr(torrent, "name", None) or "").lower()):
+                        matched = True
+                    # 检查下载历史中的标题
+                    if history and history.title:
+                        if title_lower in history.title.lower():
+                            matched = True
+                    
+                    if matched:
+                        if history:
+                            if hasattr(torrent, "media"):
+                                torrent.media = {
+                                    "tmdbid": history.tmdbid,
+                                    "type": history.type,
+                                    "title": history.title,
+                                    "season": history.seasons,
+                                    "episode": history.episodes,
+                                    "image": history.image,
+                                }
+                            if hasattr(torrent, "username"):
+                                torrent.username = history.username
+                            torrent.userid = history.userid
+                        filtered_downloads.append(torrent)
+                if not filtered_downloads:
+                    return f"未找到标题包含 '{title}' 的下载任务"
+            else:
+                # 根据status决定查询方式
+                if status == "downloading":
+                    # 如果status为下载中，使用downloading方法
+                    downloads = download_chain.downloading(name=downloader) or []
+                    filtered_downloads = []
+                    for dl in downloads:
+                        if downloader and dl.downloader != downloader:
+                            continue
+                        filtered_downloads.append(dl)
+                else:
+                    # 其他状态（completed、paused、all），使用list_torrents查询所有任务
+                    # 查询所有状态的任务
+                    all_torrents = self._get_all_torrents(download_chain, downloader)
+                    filtered_downloads = []
+                    for torrent in all_torrents:
+                        if downloader and torrent.downloader != downloader:
+                            continue
+                        # 根据status过滤
+                        if status == "completed":
+                            # 已完成的任务（state为seeding或completed）
+                            if torrent.state not in ["seeding", "completed"]:
+                                continue
+                        elif status == "paused":
+                            # 已暂停的任务
+                            if torrent.state != "paused":
+                                continue
+                        # status == "all" 时不过滤
+                        # 获取下载历史信息
+                        history = DownloadHistoryOper().get_by_hash(torrent.hash)
+                        if history:
+                            if hasattr(torrent, "media"):
+                                torrent.media = {
+                                    "tmdbid": history.tmdbid,
+                                    "type": history.type,
+                                    "title": history.title,
+                                    "season": history.seasons,
+                                    "episode": history.episodes,
+                                    "image": history.image,
+                                }
+                            if hasattr(torrent, "username"):
+                                torrent.username = history.username
+                            torrent.userid = history.userid
+                        filtered_downloads.append(torrent)
+            # 按tag过滤
+            if tag and filtered_downloads:
+                tag_lower = tag.lower()
+                filtered_downloads = [
+                    d for d in filtered_downloads
+                    if d.tags and tag_lower in d.tags.lower()
+                ]
+                if not filtered_downloads:
+                    return f"未找到标签包含 '{tag}' 的下载任务"
+            if filtered_downloads:
+                # 限制最多20条结果
+                total_count = len(filtered_downloads)
+                limited_downloads = filtered_downloads[:20]
+                # 精简字段，只保留关键信息
+                simplified_downloads = []
+                for d in limited_downloads:
+                    simplified = {
+                        "downloader": d.downloader,
+                        "hash": d.hash,
+                        "title": d.title,
+                        "name": getattr(d, "name", None),
+                        "year": getattr(d, "year", None),
+                        "season_episode": getattr(d, "season_episode", None),
+                        "size": d.size,
+                        "progress": self._format_progress(d.progress),
+                        "state": d.state,
+                        "upspeed": getattr(d, "upspeed", None),
+                        "dlspeed": getattr(d, "dlspeed", None),
+                        "tags": d.tags,
+                        "left_time": getattr(d, "left_time", None)
+                    }
+                    # 精简 media 字段
+                    media = getattr(d, "media", None)
+                    if media:
+                        simplified["media"] = {
+                            "tmdbid": media.get("tmdbid"),
+                            "type": media_type_to_agent(media.get("type")),
+                            "title": media.get("title"),
+                            "season": media.get("season"),
+                            "episode": media.get("episode")
+                        }
+                    simplified_downloads.append(simplified)
+                result_json = json.dumps(simplified_downloads, ensure_ascii=False, indent=2)
+                # 如果结果被裁剪，添加提示信息
+                if total_count > 20:
+                    return f"注意：查询结果共找到 {total_count} 条，为节省上下文空间，仅显示前 20 条结果。\n\n{result_json}"
+                
+                # 如果查询的是特定hash或title，添加明确的状态信息
+                if hash:
+                    return f"找到hash为 {hash} 的下载任务：\n\n{result_json}"
+                elif title:
+                    return f"找到 {total_count} 个标题包含 '{title}' 的下载任务：\n\n{result_json}"
+                
+                return result_json
+            return "未找到相关下载任务"
+        except Exception as e:
+            logger.error(f"查询下载失败: {e}", exc_info=True)
+            return f"查询下载时发生错误: {str(e)}"

app/agent/tools/impl/query_downloaders.py

@@ -0,0 +1,38 @@
+"""查询下载器工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db.systemconfig_oper import SystemConfigOper
+from app.log import logger
+from app.schemas.types import SystemConfigKey
+
+
+class QueryDownloadersInput(BaseModel):
+    """查询下载器工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+
+
+class QueryDownloadersTool(MoviePilotTool):
+    name: str = "query_downloaders"
+    description: str = "Query downloader configuration and list all available downloaders. Shows downloader status, connection details, and configuration settings."
+    args_schema: Type[BaseModel] = QueryDownloadersInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """生成友好的提示消息"""
+        return "正在查询下载器配置"
+
+    async def run(self, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}")
+        try:
+            system_config_oper = SystemConfigOper()
+            downloaders_config = system_config_oper.get(SystemConfigKey.Downloaders)
+            if downloaders_config:
+                return json.dumps(downloaders_config, ensure_ascii=False, indent=2)
+            return "未配置下载器。"
+        except Exception as e:
+            logger.error(f"查询下载器失败: {e}")
+            return f"查询下载器时发生错误: {str(e)}"

app/agent/tools/impl/query_episode_schedule.py

@@ -0,0 +1,103 @@
+"""查询剧集上映时间工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.tmdb import TmdbChain
+from app.log import logger
+
+
+class QueryEpisodeScheduleInput(BaseModel):
+    """查询剧集上映时间工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    tmdb_id: int = Field(..., description="TMDB ID of the TV series (can be obtained from search_media tool)")
+    season: int = Field(..., description="Season number to query")
+    episode_group: Optional[str] = Field(None, description="Episode group ID (optional)")
+
+
+class QueryEpisodeScheduleTool(MoviePilotTool):
+    name: str = "query_episode_schedule"
+    description: str = "Query TV series episode air dates and schedule. Returns non-duplicated schedule fields, including episode list, air-date statistics, and per-episode metadata. Filters out episodes without air dates."
+    args_schema: Type[BaseModel] = QueryEpisodeScheduleInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        tmdb_id = kwargs.get("tmdb_id")
+        season = kwargs.get("season")
+        episode_group = kwargs.get("episode_group")
+
+        message = f"正在查询剧集上映时间: TMDB ID {tmdb_id} 第{season}季"
+        if episode_group:
+            message += f" (剧集组: {episode_group})"
+
+        return message
+
+    async def run(self, tmdb_id: int, season: int, episode_group: Optional[str] = None, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: tmdb_id={tmdb_id}, season={season}, episode_group={episode_group}")
+
+        try:
+            # 获取集列表
+            tmdb_chain = TmdbChain()
+            episodes = await tmdb_chain.async_tmdb_episodes(
+                tmdbid=tmdb_id,
+                season=season,
+                episode_group=episode_group
+            )
+
+            if not episodes:
+                return json.dumps({
+                    "success": False,
+                    "message": f"未找到 TMDB ID {tmdb_id} 第{season}季的集信息"
+                }, ensure_ascii=False)
+
+            # 过滤掉没有上映日期的集，并构建每集的详细信息
+            episode_list = []
+            for episode in episodes:
+                air_date = episode.air_date
+                
+                # 过滤掉没有上映日期的数据
+                if not air_date:
+                    continue
+                
+                episode_info = {
+                    "episode_number": episode.episode_number,
+                    "name": episode.name,
+                    "air_date": air_date,
+                    "runtime": episode.runtime,
+                    "vote_average": episode.vote_average,
+                    "still_path": episode.still_path,
+                    "episode_type": episode.episode_type,
+                    "season_number": episode.season_number
+                }
+                episode_list.append(episode_info)
+
+            if not episode_list:
+                return json.dumps({
+                    "success": False,
+                    "message": f"未找到 TMDB ID {tmdb_id} 第{season}季的播出时间信息（所有集都没有播出日期）"
+                }, ensure_ascii=False)
+
+            # 按播出日期排序
+            episode_list.sort(key=lambda x: (x["air_date"] or "", x["episode_number"] or 0))
+
+            result = {
+                "season": season,
+                "total_episodes": len(episodes),
+                "episodes_with_air_date": len(episode_list),
+                "episodes": episode_list
+            }
+
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            error_message = f"查询剧集上映时间失败: {str(e)}"
+            logger.error(f"查询剧集上映时间失败: {e}", exc_info=True)
+            return json.dumps({
+                "success": False,
+                "message": error_message,
+                "tmdb_id": tmdb_id,
+                "season": season
+            }, ensure_ascii=False)

app/agent/tools/impl/query_installed_plugins.py

@@ -0,0 +1,65 @@
+"""查询已安装插件工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.plugin import PluginManager
+from app.log import logger
+
+
+class QueryInstalledPluginsInput(BaseModel):
+    """查询已安装插件工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+
+
+class QueryInstalledPluginsTool(MoviePilotTool):
+    name: str = "query_installed_plugins"
+    description: str = (
+        "Query all installed plugins in MoviePilot. Returns a list of installed plugins with their ID, name, "
+        "description, version, author, running state, and other information. "
+        "Use this tool to discover what plugins are available before querying plugin capabilities or running plugin commands."
+    )
+    require_admin: bool = True
+    args_schema: Type[BaseModel] = QueryInstalledPluginsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """生成友好的提示消息"""
+        return "正在查询已安装插件"
+
+    async def run(self, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}")
+        try:
+            plugin_manager = PluginManager()
+            local_plugins = plugin_manager.get_local_plugins()
+            # 仅返回已安装的插件
+            installed_plugins = [plugin for plugin in local_plugins if plugin.installed]
+
+            if not installed_plugins:
+                return "当前没有已安装的插件"
+
+            plugins_list = []
+            for plugin in installed_plugins:
+                plugins_list.append(
+                    {
+                        "id": plugin.id,
+                        "plugin_name": plugin.plugin_name,
+                        "plugin_desc": plugin.plugin_desc,
+                        "plugin_version": plugin.plugin_version,
+                        "plugin_author": plugin.plugin_author,
+                        "state": plugin.state,
+                        "has_page": plugin.has_page,
+                    }
+                )
+
+            result_json = json.dumps(plugins_list, ensure_ascii=False, indent=2)
+            return result_json
+        except Exception as e:
+            logger.error(f"查询已安装插件失败: {e}", exc_info=True)
+            return f"查询已安装插件时发生错误: {str(e)}"

app/agent/tools/impl/query_library_exists.py

@@ -0,0 +1,177 @@
+"""查询媒体库工具"""
+
+import json
+from collections import OrderedDict
+from typing import Optional, Type, Any
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.mediaserver import MediaServerChain
+from app.helper.mediaserver import MediaServerHelper
+from app.log import logger
+from app.schemas.types import MediaType, media_type_to_agent
+
+
+def _sort_seasons(seasons: Optional[dict]) -> dict:
+    """按季号、集号升序整理季集信息，保证输出稳定。"""
+    if not seasons:
+        return {}
+
+    def _sort_key(value):
+        try:
+            return int(value)
+        except (TypeError, ValueError):
+            return str(value)
+
+    return OrderedDict(
+        (season, sorted(episodes, key=_sort_key))
+        for season, episodes in sorted(seasons.items(), key=lambda item: _sort_key(item[0]))
+    )
+
+
+def _filter_regular_seasons(seasons: Optional[dict]) -> OrderedDict:
+    """仅保留正片季，忽略 season 0 等特殊季。"""
+    sorted_seasons = _sort_seasons(seasons)
+    regular_seasons = OrderedDict()
+    for season, episodes in sorted_seasons.items():
+        try:
+            season_number = int(season)
+        except (TypeError, ValueError):
+            continue
+        if season_number > 0:
+            regular_seasons[season_number] = episodes
+    return regular_seasons
+
+
+def _build_tv_server_result(existing_seasons: OrderedDict, total_seasons: OrderedDict) -> dict[str, Any]:
+    """构建单个服务器的电视剧存在性结果。"""
+    seasons_result = OrderedDict()
+    missing_seasons = []
+    all_seasons = sorted(set(total_seasons.keys()) | set(existing_seasons.keys()))
+
+    for season in all_seasons:
+        existing_episodes = existing_seasons.get(season, [])
+        total_episodes = total_seasons.get(season)
+        if total_episodes is not None:
+            missing_episodes = [episode for episode in total_episodes if episode not in existing_episodes]
+            total_episode_count = len(total_episodes)
+        else:
+            missing_episodes = None
+            total_episode_count = None
+        seasons_result[str(season)] = {
+            "existing_episodes": existing_episodes,
+            "total_episodes": total_episode_count,
+            "missing_episodes": missing_episodes
+        }
+        if total_episodes is not None and not existing_episodes:
+            missing_seasons.append(season)
+
+    return {
+        "seasons": seasons_result,
+        "missing_seasons": missing_seasons
+    }
+
+
+class QueryLibraryExistsInput(BaseModel):
+    """查询媒体库工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    tmdb_id: Optional[int] = Field(None, description="TMDB ID (can be obtained from search_media tool). Either tmdb_id or douban_id must be provided.")
+    douban_id: Optional[str] = Field(None, description="Douban ID (can be obtained from search_media tool). Either tmdb_id or douban_id must be provided.")
+    media_type: Optional[str] = Field(None, description="Allowed values: movie, tv")
+
+
+class QueryLibraryExistsTool(MoviePilotTool):
+    name: str = "query_library_exists"
+    description: str = "Check whether media already exists in Plex, Emby, or Jellyfin by media ID. Results are grouped by media server; TV results include existing episodes, total episodes, and missing episodes/seasons. Requires tmdb_id or douban_id from search_media."
+    args_schema: Type[BaseModel] = QueryLibraryExistsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        tmdb_id = kwargs.get("tmdb_id")
+        douban_id = kwargs.get("douban_id")
+        media_type = kwargs.get("media_type")
+
+        if tmdb_id:
+            message = f"正在查询媒体库: TMDB={tmdb_id}"
+        elif douban_id:
+            message = f"正在查询媒体库: 豆瓣={douban_id}"
+        else:
+            message = "正在查询媒体库"
+        if media_type:
+            message += f" [{media_type}]"
+        return message
+
+    async def run(self, tmdb_id: Optional[int] = None, douban_id: Optional[str] = None,
+                  media_type: Optional[str] = None, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: tmdb_id={tmdb_id}, douban_id={douban_id}, media_type={media_type}")
+        try:
+            if not tmdb_id and not douban_id:
+                return "参数错误：tmdb_id 和 douban_id 至少需要提供一个，请先使用 search_media 工具获取媒体 ID。"
+
+            media_type_enum = None
+            if media_type:
+                media_type_enum = MediaType.from_agent(media_type)
+                if not media_type_enum:
+                    return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv'"
+
+            media_chain = MediaServerChain()
+            mediainfo = media_chain.recognize_media(
+                tmdbid=tmdb_id,
+                doubanid=douban_id,
+                mtype=media_type_enum,
+            )
+            if not mediainfo:
+                media_id = f"TMDB={tmdb_id}" if tmdb_id else f"豆瓣={douban_id}"
+                return f"未识别到媒体信息: {media_id}"
+
+            # 2. 遍历所有媒体服务器，分别查询存在性信息
+            server_results = OrderedDict()
+            media_server_helper = MediaServerHelper()
+            total_seasons = _filter_regular_seasons(mediainfo.seasons)
+            global_existsinfo = media_chain.media_exists(mediainfo=mediainfo)
+
+            for service_name in sorted(media_server_helper.get_services().keys()):
+                existsinfo = media_chain.media_exists(mediainfo=mediainfo, server=service_name)
+                if not existsinfo:
+                    continue
+
+                if existsinfo.type == MediaType.TV:
+                    existing_seasons = _filter_regular_seasons(existsinfo.seasons)
+                    server_results[service_name] = _build_tv_server_result(
+                        existing_seasons=existing_seasons,
+                        total_seasons=total_seasons
+                    )
+                else:
+                    server_results[service_name] = {
+                        "exists": True
+                    }
+
+            if global_existsinfo:
+                fallback_server_name = global_existsinfo.server or "local"
+                if fallback_server_name not in server_results:
+                    if global_existsinfo.type == MediaType.TV:
+                        server_results[fallback_server_name] = _build_tv_server_result(
+                            existing_seasons=_filter_regular_seasons(global_existsinfo.seasons),
+                            total_seasons=total_seasons
+                        )
+                    else:
+                        server_results[fallback_server_name] = {
+                            "exists": True
+                        }
+
+            if not server_results:
+                return "媒体库中未找到相关媒体"
+
+            # 3. 组装统一的存在性结果，不查询媒体服务器详情
+            result_dict = {
+                "title": mediainfo.title,
+                "year": mediainfo.year,
+                "type": media_type_to_agent(mediainfo.type),
+                "servers": server_results
+            }
+
+            return json.dumps([result_dict], ensure_ascii=False)
+        except Exception as e:
+            logger.error(f"查询媒体库失败: {e}", exc_info=True)
+            return f"查询媒体库时发生错误: {str(e)}"

app/agent/tools/impl/query_library_latest.py

@@ -0,0 +1,117 @@
+"""查询媒体服务器最近入库影片工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.mediaserver import MediaServerChain
+from app.helper.service import ServiceConfigHelper
+from app.log import logger
+
+PAGE_SIZE = 20
+
+
+class QueryLibraryLatestInput(BaseModel):
+    """查询媒体服务器最近入库影片工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    server: Optional[str] = Field(
+        None,
+        description="Media server name (optional, if not specified queries all enabled media servers)",
+    )
+    page: Optional[int] = Field(
+        1, description="Page number for pagination (default: 1, 20 items per page)"
+    )
+
+
+class QueryLibraryLatestTool(MoviePilotTool):
+    name: str = "query_library_latest"
+    description: str = "Query the latest media items added to the media server (Plex, Emby, Jellyfin). Returns recently added movies and TV series with their titles, images, links, and other metadata. Supports pagination with 20 items per page."
+    args_schema: Type[BaseModel] = QueryLibraryLatestInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        server = kwargs.get("server")
+        page = kwargs.get("page", 1)
+
+        parts = ["正在查询媒体服务器最近入库影片"]
+
+        if server:
+            parts.append(f"服务器: {server}")
+        else:
+            parts.append("所有服务器")
+
+        parts.append(f"第{page}页")
+
+        return " | ".join(parts)
+
+    async def run(
+        self, server: Optional[str] = None, page: Optional[int] = 1, **kwargs
+    ) -> str:
+        page = max(1, page or 1)
+        # 为了支持分页，需要获取足够多的数据再切片
+        fetch_count = page * PAGE_SIZE
+        logger.info(f"执行工具: {self.name}, 参数: server={server}, page={page}")
+        try:
+            media_chain = MediaServerChain()
+            results = []
+
+            # 如果没有指定服务器，获取所有启用的媒体服务器
+            if not server:
+                mediaservers = ServiceConfigHelper.get_mediaserver_configs()
+                enabled_servers = [ms.name for ms in mediaservers if ms.enabled]
+
+                if not enabled_servers:
+                    return "未找到启用的媒体服务器"
+
+                # 遍历所有启用的服务器
+                for server_name in enabled_servers:
+                    latest_items = media_chain.latest(
+                        server=server_name, count=fetch_count, username=self._username
+                    )
+                    if latest_items:
+                        for item in latest_items:
+                            item_dict = item.model_dump(exclude_none=True)
+                            item_dict["server"] = server_name
+                            results.append(item_dict)
+            else:
+                # 查询指定服务器
+                latest_items = media_chain.latest(
+                    server=server, count=fetch_count, username=self._username
+                )
+                if latest_items:
+                    for item in latest_items:
+                        item_dict = item.model_dump(exclude_none=True)
+                        item_dict["server"] = server
+                        results.append(item_dict)
+
+            if not results:
+                server_info = f"服务器 {server}" if server else "所有服务器"
+                return f"未找到 {server_info} 的最近入库影片"
+
+            # 分页
+            total_count = len(results)
+            start = (page - 1) * PAGE_SIZE
+            end = start + PAGE_SIZE
+            page_results = results[start:end]
+
+            if not page_results:
+                total_pages = (total_count + PAGE_SIZE - 1) // PAGE_SIZE
+                return f"第 {page} 页没有数据，共 {total_count} 条结果，共 {total_pages} 页。"
+
+            total_pages = (total_count + PAGE_SIZE - 1) // PAGE_SIZE
+            payload_msg = f"第 {page}/{total_pages} 页，当前页 {len(page_results)} 条结果，共 {total_count} 条。"
+            if page < total_pages:
+                payload_msg += f" 可使用 page={page + 1} 获取下一页。"
+
+            result_json = json.dumps(page_results, ensure_ascii=False, indent=2)
+            return f"{payload_msg}\n\n{result_json}"
+
+        except Exception as e:
+            logger.error(f"查询媒体服务器最近入库影片失败: {e}", exc_info=True)
+            return f"查询媒体服务器最近入库影片时发生错误: {str(e)}"

app/agent/tools/impl/query_media_detail.py

@@ -0,0 +1,126 @@
+"""查询媒体详情工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.media import MediaChain
+from app.log import logger
+from app.schemas.types import MediaType
+
+
+class QueryMediaDetailInput(BaseModel):
+    """查询媒体详情工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    tmdb_id: Optional[int] = Field(None, description="TMDB ID of the media (movie or TV series, can be obtained from search_media tool)")
+    douban_id: Optional[str] = Field(None, description="Douban ID of the media (alternative to tmdb_id)")
+    media_type: str = Field(..., description="Allowed values: movie, tv")
+
+
+class QueryMediaDetailTool(MoviePilotTool):
+    name: str = "query_media_detail"
+    description: str = "Query supplementary media details from TMDB by ID and media_type. Accepts tmdb_id or douban_id (at least one required). media_type accepts 'movie' or 'tv'. Returns non-duplicated detail fields such as status, genres, directors, actors, and season info for TV series."
+    args_schema: Type[BaseModel] = QueryMediaDetailInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        tmdb_id = kwargs.get("tmdb_id")
+        douban_id = kwargs.get("douban_id")
+        if tmdb_id:
+            return f"正在查询媒体详情: TMDB ID {tmdb_id}"
+        return f"正在查询媒体详情: 豆瓣 ID {douban_id}"
+
+    async def run(self, media_type: str, tmdb_id: Optional[int] = None, douban_id: Optional[str] = None, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: tmdb_id={tmdb_id}, douban_id={douban_id}, media_type={media_type}")
+
+        if tmdb_id is None and douban_id is None:
+            return json.dumps({
+                "success": False,
+                "message": "必须提供 tmdb_id 或 douban_id 之一"
+            }, ensure_ascii=False)
+
+        try:
+            media_chain = MediaChain()
+
+            media_type_enum = MediaType.from_agent(media_type)
+            if not media_type_enum:
+                return json.dumps({
+                    "success": False,
+                    "message": f"无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv'"
+                }, ensure_ascii=False)
+
+            mediainfo = await media_chain.async_recognize_media(tmdbid=tmdb_id, doubanid=douban_id, mtype=media_type_enum)
+
+            if not mediainfo:
+                id_info = f"TMDB ID {tmdb_id}" if tmdb_id else f"豆瓣 ID {douban_id}"
+                return json.dumps({
+                    "success": False,
+                    "message": f"未找到 {id_info} 的媒体信息"
+                }, ensure_ascii=False)
+
+            # 精简 genres - 只保留名称
+            genres = [g.get("name") for g in (mediainfo.genres or []) if g.get("name")]
+
+            # 精简 directors - 只保留姓名和职位
+            directors = [
+                {
+                    "name": d.get("name"),
+                    "job": d.get("job")
+                }
+                for d in (mediainfo.directors or [])
+                if d.get("name")
+            ]
+
+            # 精简 actors - 只保留姓名和角色
+            actors = [
+                {
+                    "name": a.get("name"),
+                    "character": a.get("character")
+                }
+                for a in (mediainfo.actors or [])
+                if a.get("name")
+            ]
+
+            # 构建基础媒体详情信息
+            result = {
+                "status": mediainfo.status,
+                "genres": genres,
+                "directors": directors,
+                "actors": actors
+            }
+
+            # 如果是电视剧，添加电视剧特有信息
+            if mediainfo.type == MediaType.TV:
+                # 精简 season_info - 只保留基础摘要
+                season_info = [
+                    {
+                        "season_number": s.get("season_number"),
+                        "name": s.get("name"),
+                        "episode_count": s.get("episode_count"),
+                        "air_date": s.get("air_date")
+                    }
+                    for s in (mediainfo.season_info or [])
+                    if s.get("season_number") is not None
+                ]
+
+                result.update({
+                    "number_of_seasons": mediainfo.number_of_seasons,
+                    "number_of_episodes": mediainfo.number_of_episodes,
+                    "first_air_date": mediainfo.first_air_date,
+                    "last_air_date": mediainfo.last_air_date,
+                    "season_info": season_info
+                })
+
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            error_message = f"查询媒体详情失败: {str(e)}"
+            logger.error(f"查询媒体详情失败: {e}", exc_info=True)
+            return json.dumps({
+                "success": False,
+                "message": error_message,
+                "tmdb_id": tmdb_id,
+                "douban_id": douban_id
+            }, ensure_ascii=False)

app/agent/tools/impl/query_plugin_capabilities.py

@@ -0,0 +1,118 @@
+"""查询插件能力工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.plugin import PluginManager
+from app.log import logger
+
+
+class QueryPluginCapabilitiesInput(BaseModel):
+    """查询插件能力工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    plugin_id: Optional[str] = Field(
+        None,
+        description="Optional plugin ID to query capabilities for a specific plugin. "
+        "If not provided, returns capabilities of all running plugins. "
+        "Use query_installed_plugins tool to get the plugin IDs first.",
+    )
+
+
+class QueryPluginCapabilitiesTool(MoviePilotTool):
+    name: str = "query_plugin_capabilities"
+    description: str = (
+        "Query the capabilities of installed plugins, including supported commands and scheduled services. "
+        "Commands are slash-commands (e.g. /xxx) that can be executed via the run_slash_command tool. "
+        "Scheduled services are periodic tasks that can be triggered via the run_scheduler tool. "
+        "Optionally specify a plugin_id to query a specific plugin, or omit to query all running plugins."
+    )
+    require_admin: bool = True
+    args_schema: Type[BaseModel] = QueryPluginCapabilitiesInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """生成友好的提示消息"""
+        plugin_id = kwargs.get("plugin_id")
+        if plugin_id:
+            return f"正在查询插件 {plugin_id} 的能力"
+        return "正在查询所有插件的能力"
+
+    async def run(self, plugin_id: Optional[str] = None, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: plugin_id={plugin_id}")
+        try:
+            plugin_manager = PluginManager()
+            result = {}
+
+            # 获取插件命令
+            commands = plugin_manager.get_plugin_commands(pid=plugin_id)
+            if commands:
+                commands_list = []
+                for cmd in commands:
+                    cmd_info = {
+                        "cmd": cmd.get("cmd"),
+                        "desc": cmd.get("desc"),
+                        "plugin_id": cmd.get("pid"),
+                    }
+                    # data 字段可能包含额外参数信息
+                    if cmd.get("data"):
+                        cmd_info["data"] = cmd.get("data")
+                    commands_list.append(cmd_info)
+                result["commands"] = commands_list
+
+            # 获取插件动作
+            actions = plugin_manager.get_plugin_actions(pid=plugin_id)
+            if actions:
+                actions_list = []
+                for action_group in actions:
+                    plugin_actions = {
+                        "plugin_id": action_group.get("plugin_id"),
+                        "plugin_name": action_group.get("plugin_name"),
+                        "actions": [],
+                    }
+                    for action in action_group.get("actions", []):
+                        plugin_actions["actions"].append(
+                            {
+                                "id": action.get("id"),
+                                "name": action.get("name"),
+                            }
+                        )
+                    actions_list.append(plugin_actions)
+                result["actions"] = actions_list
+
+            # 获取插件定时服务
+            services = plugin_manager.get_plugin_services(pid=plugin_id)
+            if services:
+                services_list = []
+                for svc in services:
+                    svc_info = {
+                        "id": svc.get("id"),
+                        "name": svc.get("name"),
+                    }
+                    # 包含触发器信息
+                    trigger = svc.get("trigger")
+                    if trigger:
+                        svc_info["trigger"] = str(trigger)
+                    # 包含定时器参数
+                    svc_kwargs = svc.get("kwargs")
+                    if svc_kwargs:
+                        svc_info["trigger_kwargs"] = {
+                            k: str(v) for k, v in svc_kwargs.items()
+                        }
+                    services_list.append(svc_info)
+                result["services"] = services_list
+
+            if not result:
+                if plugin_id:
+                    return f"插件 {plugin_id} 没有注册任何命令、动作或定时服务"
+                return "当前没有运行中的插件注册了命令、动作或定时服务"
+
+            return json.dumps(result, ensure_ascii=False, indent=2)
+        except Exception as e:
+            logger.error(f"查询插件能力失败: {e}", exc_info=True)
+            return f"查询插件能力时发生错误: {str(e)}"

app/agent/tools/impl/query_popular_subscribes.py

@@ -0,0 +1,162 @@
+"""查询热门订阅工具"""
+
+import json
+from typing import Optional, Type
+
+import cn2an
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.context import MediaInfo
+from app.helper.subscribe import SubscribeHelper
+from app.log import logger
+from app.schemas.types import MediaType, media_type_to_agent
+
+
+class QueryPopularSubscribesInput(BaseModel):
+    """查询热门订阅工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    media_type: str = Field(..., description="Allowed values: movie, tv")
+    page: Optional[int] = Field(1, description="Page number for pagination (default: 1)")
+    count: Optional[int] = Field(30, description="Number of items per page (default: 30)")
+    min_sub: Optional[int] = Field(None, description="Minimum number of subscribers filter (optional, e.g., 5)")
+    genre_id: Optional[int] = Field(None, description="Filter by genre ID (optional)")
+    min_rating: Optional[float] = Field(None, description="Minimum rating filter (optional, e.g., 7.5)")
+    max_rating: Optional[float] = Field(None, description="Maximum rating filter (optional, e.g., 10.0)")
+    sort_type: Optional[str] = Field(None, description="Sort type (optional, e.g., 'count', 'rating')")
+
+
+class QueryPopularSubscribesTool(MoviePilotTool):
+    name: str = "query_popular_subscribes"
+    description: str = "Query popular subscriptions based on user shared data. Shows media with the most subscribers, supports filtering by genre, rating, minimum subscribers, and pagination."
+    args_schema: Type[BaseModel] = QueryPopularSubscribesInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        media_type = kwargs.get("media_type", "")
+        page = kwargs.get("page", 1)
+        min_sub = kwargs.get("min_sub")
+        min_rating = kwargs.get("min_rating")
+        max_rating = kwargs.get("max_rating")
+        
+        parts = [f"正在查询热门订阅 [{media_type}]"]
+        
+        if min_sub:
+            parts.append(f"最少订阅: {min_sub}")
+        if min_rating:
+            parts.append(f"最低评分: {min_rating}")
+        if max_rating:
+            parts.append(f"最高评分: {max_rating}")
+        if page > 1:
+            parts.append(f"第{page}页")
+        
+        return " | ".join(parts) if len(parts) > 1 else parts[0]
+
+    async def run(self, media_type: str,
+                  page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  min_sub: Optional[int] = None,
+                  genre_id: Optional[int] = None,
+                  min_rating: Optional[float] = None,
+                  max_rating: Optional[float] = None,
+                  sort_type: Optional[str] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: media_type={media_type}, page={page}, count={count}, min_sub={min_sub}, "
+            f"genre_id={genre_id}, min_rating={min_rating}, max_rating={max_rating}, sort_type={sort_type}")
+
+        try:
+            if page is None or page < 1:
+                page = 1
+            if count is None or count < 1:
+                count = 30
+            media_type_enum = MediaType.from_agent(media_type)
+            if not media_type_enum:
+                return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv'"
+
+            subscribe_helper = SubscribeHelper()
+            subscribes = await subscribe_helper.async_get_statistic(
+                stype=media_type_enum.to_agent(),
+                page=page,
+                count=count,
+                genre_id=genre_id,
+                min_rating=min_rating,
+                max_rating=max_rating,
+                sort_type=sort_type
+            )
+
+            if not subscribes:
+                return "未找到热门订阅数据（可能订阅统计功能未启用）"
+
+            # 转换为MediaInfo格式并过滤
+            ret_medias = []
+            for sub in subscribes:
+                # 订阅人数
+                subscriber_count = sub.get("count", 0)
+                # 如果设置了最小订阅人数，进行过滤
+                if min_sub and subscriber_count < min_sub:
+                    continue
+
+                media = MediaInfo()
+                raw_type = str(sub.get("type") or "").strip().lower()
+                if raw_type in ["movie", "电影"]:
+                    media.type = MediaType.MOVIE
+                elif raw_type in ["tv", "电视剧"]:
+                    media.type = MediaType.TV
+                else:
+                    # 跳过无法识别类型的数据，避免单条脏数据导致整批失败
+                    logger.warning(f"跳过未知媒体类型: {sub.get('type')}")
+                    continue
+                media.tmdb_id = sub.get("tmdbid")
+                # 处理标题
+                title = sub.get("name")
+                season = sub.get("season")
+                if season and int(season) > 1 and media.tmdb_id:
+                    # 小写数据转大写
+                    season_str = cn2an.an2cn(season, "low")
+                    title = f"{title} 第{season_str}季"
+                media.title = title
+                media.year = sub.get("year")
+                media.douban_id = sub.get("doubanid")
+                media.bangumi_id = sub.get("bangumiid")
+                media.tvdb_id = sub.get("tvdbid")
+                media.imdb_id = sub.get("imdbid")
+                media.season = sub.get("season")
+                media.vote_average = sub.get("vote")
+                media.poster_path = sub.get("poster")
+                media.backdrop_path = sub.get("backdrop")
+                media.popularity = subscriber_count
+                ret_medias.append(media)
+
+            if not ret_medias:
+                return "未找到符合条件的热门订阅"
+
+            # 转换为字典格式，只保留关键信息
+            simplified_medias = []
+            for media in ret_medias:
+                media_dict = media.to_dict()
+                simplified = {
+                    "type": media_type_to_agent(media_dict.get("type")),
+                    "title": media_dict.get("title"),
+                    "year": media_dict.get("year"),
+                    "tmdb_id": media_dict.get("tmdb_id"),
+                    "douban_id": media_dict.get("douban_id"),
+                    "bangumi_id": media_dict.get("bangumi_id"),
+                    "tvdb_id": media_dict.get("tvdb_id"),
+                    "imdb_id": media_dict.get("imdb_id"),
+                    "season": media_dict.get("season"),
+                    "vote_average": media_dict.get("vote_average"),
+                    "poster_path": media_dict.get("poster_path"),
+                    "backdrop_path": media_dict.get("backdrop_path"),
+                    "popularity": media_dict.get("popularity"),  # 订阅人数
+                    "subscriber_count": media_dict.get("popularity")  # 明确标注为订阅人数
+                }
+                simplified_medias.append(simplified)
+
+            result_json = json.dumps(simplified_medias, ensure_ascii=False, indent=2)
+
+            pagination_info = f"第 {page} 页，每页 {count} 条，共 {len(simplified_medias)} 条结果"
+
+            return f"{pagination_info}\n\n{result_json}"
+        except Exception as e:
+            logger.error(f"查询热门订阅失败: {e}", exc_info=True)
+            return f"查询热门订阅时发生错误: {str(e)}"

app/agent/tools/impl/query_rule_groups.py

@@ -0,0 +1,64 @@
+"""查询规则组工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.helper.rule import RuleHelper
+from app.log import logger
+
+
+class QueryRuleGroupsInput(BaseModel):
+    """查询规则组工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+
+
+class QueryRuleGroupsTool(MoviePilotTool):
+    name: str = "query_rule_groups"
+    description: str = "Query all filter rule groups available in the system. Rule groups are used to filter torrents when searching or subscribing. Returns rule group names, media types, and categories, but excludes rule_string to keep results concise."
+    args_schema: Type[BaseModel] = QueryRuleGroupsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        return "正在查询所有规则组"
+
+    async def run(self, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}")
+        
+        try:
+            rule_helper = RuleHelper()
+            rule_groups = rule_helper.get_rule_groups()
+            
+            if not rule_groups:
+                return json.dumps({
+                    "message": "未找到任何规则组",
+                    "rule_groups": []
+                }, ensure_ascii=False, indent=2)
+            
+            # 精简字段，过滤掉 rule_string 避免结果过大
+            simplified_groups = []
+            for group in rule_groups:
+                simplified = {
+                    "name": group.name,
+                    "media_type": group.media_type,
+                    "category": group.category
+                }
+                simplified_groups.append(simplified)
+            
+            result = {
+                "message": f"找到 {len(simplified_groups)} 个规则组",
+                "rule_groups": simplified_groups
+            }
+            
+            return json.dumps(result, ensure_ascii=False, indent=2)
+            
+        except Exception as e:
+            error_message = f"查询规则组失败: {str(e)}"
+            logger.error(f"查询规则组失败: {e}", exc_info=True)
+            return json.dumps({
+                "success": False,
+                "message": error_message,
+                "rule_groups": []
+            }, ensure_ascii=False)

app/agent/tools/impl/query_schedulers.py

@@ -0,0 +1,54 @@
+"""查询定时服务工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.log import logger
+from app.scheduler import Scheduler
+
+
+class QuerySchedulersInput(BaseModel):
+    """查询定时服务工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+
+
+class QuerySchedulersTool(MoviePilotTool):
+    name: str = "query_schedulers"
+    description: str = "Query scheduled tasks and list all available scheduler jobs. Shows job status, next run time, and provider information."
+    args_schema: Type[BaseModel] = QuerySchedulersInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """生成友好的提示消息"""
+        return "正在查询定时服务"
+
+    async def run(self, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}")
+        try:
+            scheduler = Scheduler()
+            schedulers = scheduler.list()
+            if schedulers:
+                # 转换为字典列表以便JSON序列化
+                schedulers_list = []
+                for s in schedulers:
+                    schedulers_list.append({
+                        "id": s.id,
+                        "name": s.name,
+                        "provider": s.provider,
+                        "status": s.status,
+                        "next_run": s.next_run
+                    })
+                result_json = json.dumps(schedulers_list, ensure_ascii=False, indent=2)
+                # 限制最多30条结果
+                total_count = len(schedulers_list)
+                if total_count > 30:
+                    limited_schedulers = schedulers_list[:30]
+                    limited_json = json.dumps(limited_schedulers, ensure_ascii=False, indent=2)
+                    return f"注意：查询结果共找到 {total_count} 条，为节省上下文空间，仅显示前 30 条结果。\n\n{limited_json}"
+                return result_json
+            return "未找到定时服务"
+        except Exception as e:
+            logger.error(f"查询定时服务失败: {e}", exc_info=True)
+            return f"查询定时服务时发生错误: {str(e)}"

app/agent/tools/impl/query_site_userdata.py

@@ -0,0 +1,169 @@
+"""查询站点用户数据工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db import AsyncSessionFactory
+from app.db.models.site import Site
+from app.db.models.siteuserdata import SiteUserData
+from app.log import logger
+
+
+class QuerySiteUserdataInput(BaseModel):
+    """查询站点用户数据工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    site_id: int = Field(
+        ...,
+        description="The ID of the site to query user data for (can be obtained from query_sites tool)",
+    )
+    workdate: Optional[str] = Field(
+        None,
+        description="Work date to query (optional, format: 'YYYY-MM-DD', if not specified returns latest data)",
+    )
+
+
+class QuerySiteUserdataTool(MoviePilotTool):
+    name: str = "query_site_userdata"
+    description: str = "Query user data for a specific site including username, user level, upload/download statistics, seeding information, bonus points, and other account details. Supports querying data for a specific date or latest data."
+    require_admin: bool = True
+    args_schema: Type[BaseModel] = QuerySiteUserdataInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        site_id = kwargs.get("site_id")
+        workdate = kwargs.get("workdate")
+
+        message = f"正在查询站点 #{site_id} 的用户数据"
+        if workdate:
+            message += f" (日期: {workdate})"
+        else:
+            message += " (最新数据)"
+
+        return message
+
+    async def run(self, site_id: int, workdate: Optional[str] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: site_id={site_id}, workdate={workdate}"
+        )
+
+        try:
+            # 获取数据库会话
+            async with AsyncSessionFactory() as db:
+                # 获取站点
+                site = await Site.async_get(db, site_id)
+                if not site:
+                    return json.dumps(
+                        {"success": False, "message": f"站点不存在: {site_id}"},
+                        ensure_ascii=False,
+                    )
+
+                # 获取站点用户数据
+                user_data_list = await SiteUserData.async_get_by_domain(
+                    db, domain=site.domain, workdate=workdate
+                )
+
+                if not user_data_list:
+                    return json.dumps(
+                        {
+                            "success": False,
+                            "message": f"站点 {site.name} ({site.domain}) 暂无用户数据",
+                            "site_id": site_id,
+                            "site_name": site.name,
+                            "site_domain": site.domain,
+                            "workdate": workdate,
+                        },
+                        ensure_ascii=False,
+                    )
+
+                # 格式化用户数据
+                result = {
+                    "success": True,
+                    "site_id": site_id,
+                    "site_name": site.name,
+                    "site_domain": site.domain,
+                    "workdate": workdate,
+                    "data_count": len(user_data_list),
+                    "user_data": [],
+                }
+
+                for user_data in user_data_list:
+                    # 格式化上传/下载量（转换为可读格式）
+                    upload_gb = user_data.upload / (1024**3) if user_data.upload else 0
+                    download_gb = (
+                        user_data.download / (1024**3) if user_data.download else 0
+                    )
+                    seeding_size_gb = (
+                        user_data.seeding_size / (1024**3)
+                        if user_data.seeding_size
+                        else 0
+                    )
+                    leeching_size_gb = (
+                        user_data.leeching_size / (1024**3)
+                        if user_data.leeching_size
+                        else 0
+                    )
+
+                    user_data_dict = {
+                        "domain": user_data.domain,
+                        "name": user_data.name,
+                        "username": user_data.username,
+                        "userid": user_data.userid,
+                        "user_level": user_data.user_level,
+                        "join_at": user_data.join_at,
+                        "bonus": user_data.bonus,
+                        "upload": user_data.upload,
+                        "upload_gb": round(upload_gb, 2),
+                        "download": user_data.download,
+                        "download_gb": round(download_gb, 2),
+                        "ratio": round(user_data.ratio, 2) if user_data.ratio else 0,
+                        "seeding": int(user_data.seeding) if user_data.seeding else 0,
+                        "leeching": int(user_data.leeching)
+                        if user_data.leeching
+                        else 0,
+                        "seeding_size": user_data.seeding_size,
+                        "seeding_size_gb": round(seeding_size_gb, 2),
+                        "leeching_size": user_data.leeching_size,
+                        "leeching_size_gb": round(leeching_size_gb, 2),
+                        "seeding_info": user_data.seeding_info
+                        if user_data.seeding_info
+                        else [],
+                        "message_unread": user_data.message_unread,
+                        "message_unread_contents": user_data.message_unread_contents
+                        if user_data.message_unread_contents
+                        else [],
+                        "err_msg": user_data.err_msg,
+                        "updated_day": user_data.updated_day,
+                        "updated_time": user_data.updated_time,
+                    }
+                    result["user_data"].append(user_data_dict)
+
+                # 如果有多条数据，只返回最新的（按更新时间排序）
+                if len(result["user_data"]) > 1:
+                    result["user_data"].sort(
+                        key=lambda x: (
+                            x.get("updated_day", ""),
+                            x.get("updated_time", ""),
+                        ),
+                        reverse=True,
+                    )
+                    result["message"] = (
+                        f"找到 {len(result['user_data'])} 条数据，显示最新的一条"
+                    )
+                    result["user_data"] = [result["user_data"][0]]
+
+                return json.dumps(result, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            error_message = f"查询站点用户数据失败: {str(e)}"
+            logger.error(f"查询站点用户数据失败: {e}", exc_info=True)
+            return json.dumps(
+                {"success": False, "message": error_message, "site_id": site_id},
+                ensure_ascii=False,
+            )

app/agent/tools/impl/query_sites.py

@@ -0,0 +1,92 @@
+"""查询站点工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db.site_oper import SiteOper
+from app.log import logger
+
+
+class QuerySitesInput(BaseModel):
+    """查询站点工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    status: Optional[str] = Field(
+        "all",
+        description="Filter sites by status: 'active' for enabled sites, 'inactive' for disabled sites, 'all' for all sites",
+    )
+    name: Optional[str] = Field(
+        None, description="Filter sites by name (partial match, optional)"
+    )
+
+
+class QuerySitesTool(MoviePilotTool):
+    name: str = "query_sites"
+    description: str = "Query site status and list all configured sites. Shows site name, domain, status, priority, and basic configuration. Site priority (pri): smaller values have higher priority (e.g., pri=1 has higher priority than pri=10)."
+    require_admin: bool = True
+    args_schema: Type[BaseModel] = QuerySitesInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        status = kwargs.get("status", "all")
+        name = kwargs.get("name")
+
+        parts = ["正在查询站点"]
+
+        if status != "all":
+            status_map = {"active": "已启用", "inactive": "已禁用"}
+            parts.append(f"状态: {status_map.get(status, status)}")
+
+        if name:
+            parts.append(f"名称: {name}")
+
+        return " | ".join(parts) if len(parts) > 1 else parts[0]
+
+    async def run(
+        self, status: Optional[str] = "all", name: Optional[str] = None, **kwargs
+    ) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: status={status}, name={name}")
+        try:
+            site_oper = SiteOper()
+            # 获取所有站点（按优先级排序）
+            sites = await site_oper.async_list()
+            filtered_sites = []
+            for site in sites:
+                # 按状态过滤
+                if status == "active" and not site.is_active:
+                    continue
+                if status == "inactive" and site.is_active:
+                    continue
+                # 按名称过滤（部分匹配）
+                if name and name.lower() not in (site.name or "").lower():
+                    continue
+                filtered_sites.append(site)
+            if filtered_sites:
+                # 精简字段，只保留关键信息
+                simplified_sites = []
+                for s in filtered_sites:
+                    simplified = {
+                        "id": s.id,
+                        "name": s.name,
+                        "domain": s.domain,
+                        "url": s.url,
+                        "pri": s.pri,
+                        "is_active": s.is_active,
+                        "cookie": s.cookie,
+                        "downloader": s.downloader,
+                        "proxy": s.proxy,
+                        "timeout": s.timeout,
+                    }
+                    simplified_sites.append(simplified)
+                result_json = json.dumps(simplified_sites, ensure_ascii=False, indent=2)
+                return result_json
+            return "未找到相关站点"
+        except Exception as e:
+            logger.error(f"查询站点失败: {e}", exc_info=True)
+            return f"查询站点时发生错误: {str(e)}"

app/agent/tools/impl/query_subscribe_history.py

@@ -0,0 +1,187 @@
+"""查询订阅历史工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db import AsyncSessionFactory
+from app.db.models.subscribehistory import SubscribeHistory
+from app.log import logger
+from app.schemas.types import media_type_to_agent
+
+PAGE_SIZE = 20
+
+
+class QuerySubscribeHistoryInput(BaseModel):
+    """查询订阅历史工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    media_type: Optional[str] = Field(
+        "all", description="Allowed values: movie, tv, all"
+    )
+    name: Optional[str] = Field(
+        None, description="Filter by media name (partial match, optional)"
+    )
+    page: Optional[int] = Field(
+        1,
+        description="Page number for pagination (default: 1, 20 items per page). Ignored when name filter is provided.",
+    )
+
+
+class QuerySubscribeHistoryTool(MoviePilotTool):
+    name: str = "query_subscribe_history"
+    description: str = "Query subscription history records. Shows completed subscriptions with their details including name, type, rating, completion date, and other subscription information. Supports filtering by media type and name. Supports pagination with 20 records per page."
+    args_schema: Type[BaseModel] = QuerySubscribeHistoryInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        media_type = kwargs.get("media_type", "all")
+        name = kwargs.get("name")
+        page = kwargs.get("page", 1)
+
+        parts = ["正在查询订阅历史"]
+
+        if media_type != "all":
+            parts.append(f"类型: {media_type}")
+        if name:
+            parts.append(f"名称: {name}")
+        else:
+            parts.append(f"第{page}页")
+
+        return " | ".join(parts)
+
+    async def run(
+        self,
+        media_type: Optional[str] = "all",
+        name: Optional[str] = None,
+        page: Optional[int] = 1,
+        **kwargs,
+    ) -> str:
+        page = max(1, page or 1)
+        logger.info(
+            f"执行工具: {self.name}, 参数: media_type={media_type}, name={name}, page={page}"
+        )
+
+        try:
+            if media_type not in ["all", "movie", "tv"]:
+                return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv', 'all'"
+
+            # 获取数据库会话
+            async with AsyncSessionFactory() as db:
+                if name:
+                    # 有名称过滤时，获取足够多的记录在内存中过滤，不分页
+                    fetch_count = 500
+                    if media_type == "all":
+                        movie_history = await SubscribeHistory.async_list_by_type(
+                            db, mtype="movie", page=1, count=fetch_count
+                        )
+                        tv_history = await SubscribeHistory.async_list_by_type(
+                            db, mtype="tv", page=1, count=fetch_count
+                        )
+                        all_history = list(movie_history) + list(tv_history)
+                        all_history.sort(key=lambda x: x.date or "", reverse=True)
+                    else:
+                        all_history = list(
+                            await SubscribeHistory.async_list_by_type(
+                                db, mtype=media_type, page=1, count=fetch_count
+                            )
+                        )
+
+                    # 按名称过滤
+                    name_lower = name.lower()
+                    filtered_history = [
+                        record
+                        for record in all_history
+                        if record.name and name_lower in record.name.lower()
+                    ]
+
+                    if not filtered_history:
+                        return "未找到相关订阅历史记录"
+
+                    # 名称过滤时直接返回所有匹配结果，不分页
+                    simplified_records = self._simplify_records(filtered_history)
+                    result_json = json.dumps(
+                        simplified_records, ensure_ascii=False, indent=2
+                    )
+                    return result_json
+                else:
+                    # 无名称过滤时，直接利用数据库分页
+                    if media_type == "all":
+                        movie_history = await SubscribeHistory.async_list_by_type(
+                            db, mtype="movie", page=1, count=page * PAGE_SIZE
+                        )
+                        tv_history = await SubscribeHistory.async_list_by_type(
+                            db, mtype="tv", page=1, count=page * PAGE_SIZE
+                        )
+                        all_history = list(movie_history) + list(tv_history)
+                        all_history.sort(key=lambda x: x.date or "", reverse=True)
+                        filtered_history = all_history
+                    else:
+                        filtered_history = list(
+                            await SubscribeHistory.async_list_by_type(
+                                db, mtype=media_type, page=1, count=page * PAGE_SIZE
+                            )
+                        )
+
+                if not filtered_history:
+                    return "未找到相关订阅历史记录"
+
+                # 分页切片
+                total_count = len(filtered_history)
+                start = (page - 1) * PAGE_SIZE
+                end = start + PAGE_SIZE
+                page_records = filtered_history[start:end]
+
+                if not page_records:
+                    return f"第 {page} 页没有数据。"
+
+                simplified_records = self._simplify_records(page_records)
+                result_json = json.dumps(
+                    simplified_records, ensure_ascii=False, indent=2
+                )
+
+                has_more = total_count > end
+                payload_msg = f"第 {page} 页，当前页 {len(simplified_records)} 条结果。"
+                if has_more:
+                    payload_msg += (
+                        f" 可能有更多数据，可使用 page={page + 1} 获取下一页。"
+                    )
+
+                return f"{payload_msg}\n\n{result_json}"
+        except Exception as e:
+            logger.error(f"查询订阅历史失败: {e}", exc_info=True)
+            return f"查询订阅历史时发生错误: {str(e)}"
+
+    @staticmethod
+    def _simplify_records(records) -> list:
+        """转换为字典格式，只保留关键信息"""
+        simplified_records = []
+        for record in records:
+            simplified = {
+                "id": record.id,
+                "name": record.name,
+                "year": record.year,
+                "type": media_type_to_agent(record.type),
+                "season": record.season,
+                "tmdbid": record.tmdbid,
+                "doubanid": record.doubanid,
+                "bangumiid": record.bangumiid,
+                "poster": record.poster,
+                "vote": record.vote,
+                "total_episode": record.total_episode,
+                "date": record.date,
+                "username": record.username,
+            }
+            if record.filter:
+                simplified["filter"] = record.filter
+            if record.quality:
+                simplified["quality"] = record.quality
+            if record.resolution:
+                simplified["resolution"] = record.resolution
+            simplified_records.append(simplified)
+        return simplified_records

app/agent/tools/impl/query_subscribe_shares.py

@@ -0,0 +1,112 @@
+"""查询订阅分享工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.helper.subscribe import SubscribeHelper
+from app.log import logger
+
+
+class QuerySubscribeSharesInput(BaseModel):
+    """查询订阅分享工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    name: Optional[str] = Field(None, description="Filter shares by media name (partial match, optional)")
+    page: Optional[int] = Field(1, description="Page number for pagination (default: 1)")
+    count: Optional[int] = Field(30, description="Number of items per page (default: 30)")
+    genre_id: Optional[int] = Field(None, description="Filter by genre ID (optional)")
+    min_rating: Optional[float] = Field(None, description="Minimum rating filter (optional, e.g., 7.5)")
+    max_rating: Optional[float] = Field(None, description="Maximum rating filter (optional, e.g., 10.0)")
+    sort_type: Optional[str] = Field(None, description="Sort type (optional, e.g., 'count', 'rating')")
+
+
+class QuerySubscribeSharesTool(MoviePilotTool):
+    name: str = "query_subscribe_shares"
+    description: str = "Query shared subscriptions from other users. Shows popular subscriptions shared by the community with filtering and pagination support."
+    args_schema: Type[BaseModel] = QuerySubscribeSharesInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        name = kwargs.get("name")
+        page = kwargs.get("page", 1)
+        min_rating = kwargs.get("min_rating")
+        max_rating = kwargs.get("max_rating")
+        
+        parts = ["正在查询订阅分享"]
+        
+        if name:
+            parts.append(f"名称: {name}")
+        if min_rating:
+            parts.append(f"最低评分: {min_rating}")
+        if max_rating:
+            parts.append(f"最高评分: {max_rating}")
+        if page > 1:
+            parts.append(f"第{page}页")
+        
+        return " | ".join(parts) if len(parts) > 1 else parts[0]
+
+    async def run(self, name: Optional[str] = None,
+                  page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  genre_id: Optional[int] = None,
+                  min_rating: Optional[float] = None,
+                  max_rating: Optional[float] = None,
+                  sort_type: Optional[str] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: name={name}, page={page}, count={count}, genre_id={genre_id}, "
+            f"min_rating={min_rating}, max_rating={max_rating}, sort_type={sort_type}")
+
+        try:
+            if page is None or page < 1:
+                page = 1
+            if count is None or count < 1:
+                count = 30
+
+            subscribe_helper = SubscribeHelper()
+            shares = await subscribe_helper.async_get_shares(
+                name=name,
+                page=page,
+                count=count,
+                genre_id=genre_id,
+                min_rating=min_rating,
+                max_rating=max_rating,
+                sort_type=sort_type
+            )
+
+            if not shares:
+                return "未找到订阅分享数据（可能订阅分享功能未启用）"
+
+            # 简化字段，只保留关键信息
+            simplified_shares = []
+            for share in shares:
+                simplified = {
+                    "id": share.get("id"),
+                    "name": share.get("name"),
+                    "year": share.get("year"),
+                    "type": share.get("type"),
+                    "season": share.get("season"),
+                    "tmdbid": share.get("tmdbid"),
+                    "doubanid": share.get("doubanid"),
+                    "bangumiid": share.get("bangumiid"),
+                    "poster": share.get("poster"),
+                    "vote": share.get("vote"),
+                    "share_title": share.get("share_title"),
+                    "share_comment": share.get("share_comment"),
+                    "share_user": share.get("share_user"),
+                    "fork_count": share.get("fork_count", 0)
+                }
+                # 截断过长的描述
+                if simplified.get("description") and len(simplified["description"]) > 200:
+                    simplified["description"] = simplified["description"][:200] + "..."
+                simplified_shares.append(simplified)
+
+            result_json = json.dumps(simplified_shares, ensure_ascii=False, indent=2)
+
+            pagination_info = f"第 {page} 页，每页 {count} 条，共 {len(simplified_shares)} 条结果"
+
+            return f"{pagination_info}\n\n{result_json}"
+        except Exception as e:
+            logger.error(f"查询订阅分享失败: {e}", exc_info=True)
+            return f"查询订阅分享时发生错误: {str(e)}"

app/agent/tools/impl/query_subscribes.py

@@ -0,0 +1,158 @@
+"""查询订阅工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db.subscribe_oper import SubscribeOper
+from app.log import logger
+from app.schemas.subscribe import Subscribe as SubscribeSchema
+from app.schemas.types import MediaType
+
+PAGE_SIZE = 100
+
+QUERY_SUBSCRIBE_OUTPUT_FIELDS = [
+    "id",
+    "name",
+    "year",
+    "type",
+    "season",
+    "total_episode",
+    "start_episode",
+    "lack_episode",
+    "filter",
+    "include",
+    "exclude",
+    "quality",
+    "resolution",
+    "effect",
+    "state",
+    "last_update",
+    "sites",
+    "downloader",
+    "best_version",
+    "save_path",
+    "custom_words",
+    "media_category",
+    "filter_groups",
+    "episode_group",
+]
+
+
+class QuerySubscribesInput(BaseModel):
+    """查询订阅工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    status: Optional[str] = Field(
+        "all",
+        description="Filter subscriptions by status: 'R' for enabled subscriptions, 'S' for paused ones, 'all' for all subscriptions",
+    )
+    media_type: Optional[str] = Field(
+        "all", description="Allowed values: movie, tv, all"
+    )
+    tmdb_id: Optional[int] = Field(
+        None,
+        description="Filter by TMDB ID to check if a specific media is already subscribed",
+    )
+    douban_id: Optional[str] = Field(
+        None,
+        description="Filter by Douban ID to check if a specific media is already subscribed",
+    )
+    page: Optional[int] = Field(
+        1, description="Page number for pagination (default: 1, 100 items per page)"
+    )
+
+
+class QuerySubscribesTool(MoviePilotTool):
+    name: str = "query_subscribes"
+    description: str = "Query subscription status and list user subscriptions. Returns full subscription parameters for each matched subscription. Supports pagination with 100 items per page."
+    args_schema: Type[BaseModel] = QuerySubscribesInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        status = kwargs.get("status", "all")
+        media_type = kwargs.get("media_type", "all")
+        page = kwargs.get("page", 1)
+
+        parts = ["正在查询订阅"]
+
+        # 根据状态过滤条件生成提示
+        if status != "all":
+            status_map = {"R": "已启用", "S": "已暂停"}
+            parts.append(f"状态: {status_map.get(status, status)}")
+
+        # 根据媒体类型过滤条件生成提示
+        if media_type != "all":
+            parts.append(f"类型: {media_type}")
+
+        parts.append(f"第{page}页")
+
+        return " | ".join(parts)
+
+    async def run(
+        self,
+        status: Optional[str] = "all",
+        media_type: Optional[str] = "all",
+        tmdb_id: Optional[int] = None,
+        douban_id: Optional[str] = None,
+        page: Optional[int] = 1,
+        **kwargs,
+    ) -> str:
+        page = max(1, page or 1)
+        logger.info(
+            f"执行工具: {self.name}, 参数: status={status}, media_type={media_type}, tmdb_id={tmdb_id}, douban_id={douban_id}, page={page}"
+        )
+        try:
+            if media_type != "all" and not MediaType.from_agent(media_type):
+                return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv', 'all'"
+
+            subscribe_oper = SubscribeOper()
+            subscribes = await subscribe_oper.async_list()
+            filtered_subscribes = []
+            for sub in subscribes:
+                if status != "all" and sub.state != status:
+                    continue
+                if (
+                    media_type != "all"
+                    and sub.type != MediaType.from_agent(media_type).value
+                ):
+                    continue
+                if tmdb_id is not None and sub.tmdbid != tmdb_id:
+                    continue
+                if douban_id is not None and sub.doubanid != douban_id:
+                    continue
+                filtered_subscribes.append(sub)
+            if filtered_subscribes:
+                total_count = len(filtered_subscribes)
+                # 分页
+                start = (page - 1) * PAGE_SIZE
+                end = start + PAGE_SIZE
+                page_subscribes = filtered_subscribes[start:end]
+
+                if not page_subscribes:
+                    total_pages = (total_count + PAGE_SIZE - 1) // PAGE_SIZE
+                    return f"第 {page} 页没有数据，共 {total_count} 条结果，共 {total_pages} 页。"
+
+                full_subscribes = [
+                    SubscribeSchema.model_validate(s, from_attributes=True).model_dump(
+                        include=set(QUERY_SUBSCRIBE_OUTPUT_FIELDS), exclude_none=True
+                    )
+                    for s in page_subscribes
+                ]
+                result_json = json.dumps(full_subscribes, ensure_ascii=False, indent=2)
+
+                total_pages = (total_count + PAGE_SIZE - 1) // PAGE_SIZE
+                payload_msg = f"第 {page}/{total_pages} 页，当前页 {len(page_subscribes)} 条结果，共 {total_count} 条。"
+                if page < total_pages:
+                    payload_msg += f" 可使用 page={page + 1} 获取下一页。"
+
+                return f"{payload_msg}\n\n{result_json}"
+            return "未找到相关订阅"
+        except Exception as e:
+            logger.error(f"查询订阅失败: {e}", exc_info=True)
+            return f"查询订阅时发生错误: {str(e)}"

app/agent/tools/impl/query_transfer_history.py

@@ -0,0 +1,134 @@
+"""查询整理历史记录工具"""
+
+import json
+from typing import Optional, Type
+
+import jieba
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db import AsyncSessionFactory
+from app.db.models.transferhistory import TransferHistory
+from app.log import logger
+from app.schemas.types import media_type_to_agent
+
+
+class QueryTransferHistoryInput(BaseModel):
+    """查询整理历史记录工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    title: Optional[str] = Field(None, description="Search by title (optional, supports partial match)")
+    status: Optional[str] = Field("all",
+                                  description="Filter by status: 'success' for successful transfers, 'failed' for failed transfers, 'all' for all records (default: 'all')")
+    page: Optional[int] = Field(1, description="Page number for pagination (default: 1, each page contains 30 records)")
+
+
+class QueryTransferHistoryTool(MoviePilotTool):
+    name: str = "query_transfer_history"
+    description: str = "Query file transfer history records. Shows transfer status, source and destination paths, media information, and transfer details. Supports filtering by title and status."
+    args_schema: Type[BaseModel] = QueryTransferHistoryInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        title = kwargs.get("title")
+        status = kwargs.get("status", "all")
+        page = kwargs.get("page", 1)
+
+        parts = ["正在查询整理历史"]
+
+        if title:
+            parts.append(f"标题: {title}")
+        if status != "all":
+            status_map = {"success": "成功", "failed": "失败"}
+            parts.append(f"状态: {status_map.get(status, status)}")
+        if page > 1:
+            parts.append(f"第{page}页")
+
+        return " | ".join(parts) if len(parts) > 1 else parts[0]
+
+    async def run(self, title: Optional[str] = None,
+                  status: Optional[str] = "all",
+                  page: Optional[int] = 1, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: title={title}, status={status}, page={page}")
+
+        try:
+            # 处理状态参数
+            status_bool = None
+            if status == "success":
+                status_bool = True
+            elif status == "failed":
+                status_bool = False
+
+            # 处理页码参数
+            if page is None or page < 1:
+                page = 1
+
+            # 每页记录数
+            count = 50
+
+            # 获取数据库会话
+            async with AsyncSessionFactory() as db:
+                # 处理标题搜索
+                if title:
+                    # 使用 jieba 分词处理标题
+                    words = jieba.cut(title, HMM=False)
+                    title_search = "%".join(words)
+                    # 查询记录
+                    result = await TransferHistory.async_list_by_title(
+                        db, title=title_search, page=page, count=count, status=status_bool
+                    )
+                    total = await TransferHistory.async_count_by_title(
+                        db, title=title_search, status=status_bool
+                    )
+                else:
+                    # 查询所有记录
+                    result = await TransferHistory.async_list_by_page(
+                        db, page=page, count=count, status=status_bool
+                    )
+                    total = await TransferHistory.async_count(db, status=status_bool)
+
+                if not result:
+                    return "未找到相关整理历史记录"
+
+                # 转换为字典格式，只保留关键信息
+                simplified_records = []
+                for record in result:
+                    simplified = {
+                        "id": record.id,
+                        "title": record.title,
+                        "year": record.year,
+                        "type": media_type_to_agent(record.type),
+                        "category": record.category,
+                        "seasons": record.seasons,
+                        "episodes": record.episodes,
+                        "src": record.src,
+                        "dest": record.dest,
+                        "mode": record.mode,
+                        "status": "成功" if record.status else "失败",
+                        "date": record.date,
+                        "downloader": record.downloader,
+                        "download_hash": record.download_hash
+                    }
+                    # 如果失败，添加错误信息
+                    if not record.status and record.errmsg:
+                        simplified["errmsg"] = record.errmsg
+                    # 添加媒体ID信息（如果有）
+                    if record.tmdbid:
+                        simplified["tmdbid"] = record.tmdbid
+                    if record.imdbid:
+                        simplified["imdbid"] = record.imdbid
+                    if record.doubanid:
+                        simplified["doubanid"] = record.doubanid
+                    simplified_records.append(simplified)
+
+                result_json = json.dumps(simplified_records, ensure_ascii=False, indent=2)
+
+                # 计算总页数
+                total_pages = (total + count - 1) // count if total > 0 else 1
+
+                # 构建分页信息
+                pagination_info = f"第 {page}/{total_pages} 页，共 {total} 条记录（每页 {count} 条）"
+
+                return f"{pagination_info}\n\n{result_json}"
+        except Exception as e:
+            logger.error(f"查询整理历史记录失败: {e}", exc_info=True)
+            return f"查询整理历史记录时发生错误: {str(e)}"

app/agent/tools/impl/query_workflows.py

@@ -0,0 +1,127 @@
+"""查询工作流工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db import AsyncSessionFactory
+from app.db.workflow_oper import WorkflowOper
+from app.log import logger
+
+
+class QueryWorkflowsInput(BaseModel):
+    """查询工作流工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    state: Optional[str] = Field("all", description="Filter workflows by state: 'W' for waiting, 'R' for running, 'P' for paused, 'S' for success, 'F' for failed, 'all' for all workflows (default: 'all')")
+    name: Optional[str] = Field(None, description="Filter workflows by name (partial match, optional)")
+    trigger_type: Optional[str] = Field("all", description="Filter workflows by trigger type: 'timer' for scheduled, 'event' for event-triggered, 'manual' for manual, 'all' for all types (default: 'all')")
+
+
+class QueryWorkflowsTool(MoviePilotTool):
+    name: str = "query_workflows"
+    description: str = "Query workflow list and status. Shows workflow name, description, trigger type, state, execution count, and other workflow details. Supports filtering by state, name, and trigger type."
+    args_schema: Type[BaseModel] = QueryWorkflowsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据查询参数生成友好的提示消息"""
+        state = kwargs.get("state", "all")
+        name = kwargs.get("name")
+        trigger_type = kwargs.get("trigger_type", "all")
+        
+        parts = ["正在查询工作流"]
+        
+        if state != "all":
+            state_map = {"W": "等待", "R": "运行中", "P": "暂停", "S": "成功", "F": "失败"}
+            parts.append(f"状态: {state_map.get(state, state)}")
+        
+        if trigger_type != "all":
+            trigger_map = {"timer": "定时触发", "event": "事件触发", "manual": "手动触发"}
+            parts.append(f"触发类型: {trigger_map.get(trigger_type, trigger_type)}")
+        
+        if name:
+            parts.append(f"名称: {name}")
+        
+        return " | ".join(parts) if len(parts) > 1 else parts[0]
+
+    async def run(self, state: Optional[str] = "all",
+                  name: Optional[str] = None,
+                  trigger_type: Optional[str] = "all", **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: state={state}, name={name}, trigger_type={trigger_type}")
+
+        try:
+            # 获取数据库会话
+            async with AsyncSessionFactory() as db:
+                workflow_oper = WorkflowOper(db)
+                workflows = await workflow_oper.async_list()
+                
+                # 过滤工作流
+                filtered_workflows = []
+                for wf in workflows:
+                    # 按状态过滤
+                    if state != "all" and wf.state != state:
+                        continue
+                    
+                    # 按触发类型过滤
+                    if trigger_type != "all":
+                        if trigger_type == "timer" and wf.trigger_type not in ["timer", None]:
+                            continue
+                        elif trigger_type == "event" and wf.trigger_type != "event":
+                            continue
+                        elif trigger_type == "manual" and wf.trigger_type != "manual":
+                            continue
+                    
+                    # 按名称过滤（部分匹配）
+                    if name and wf.name and name.lower() not in wf.name.lower():
+                        continue
+                    
+                    filtered_workflows.append(wf)
+                
+                if not filtered_workflows:
+                    return "未找到相关工作流"
+                
+                # 转换为字典格式，只保留关键信息
+                simplified_workflows = []
+                for wf in filtered_workflows:
+                    # 状态说明
+                    state_map = {
+                        "W": "等待",
+                        "R": "运行中",
+                        "P": "暂停",
+                        "S": "成功",
+                        "F": "失败"
+                    }
+                    state_desc = state_map.get(wf.state, wf.state)
+                    
+                    # 触发类型说明
+                    trigger_type_map = {
+                        "timer": "定时触发",
+                        "event": "事件触发",
+                        "manual": "手动触发"
+                    }
+                    trigger_type_desc = trigger_type_map.get(wf.trigger_type, wf.trigger_type or "定时触发")
+                    
+                    simplified = {
+                        "id": wf.id,
+                        "name": wf.name,
+                        "description": wf.description,
+                        "trigger_type": trigger_type_desc,
+                        "state": state_desc,
+                        "run_count": wf.run_count,
+                        "timer": wf.timer,
+                        "event_type": wf.event_type,
+                        "add_time": wf.add_time,
+                        "last_time": wf.last_time,
+                        "current_action": wf.current_action
+                    }
+                    # 如果有结果，添加结果信息
+                    if wf.result:
+                        simplified["result"] = wf.result
+                    simplified_workflows.append(simplified)
+                
+                result_json = json.dumps(simplified_workflows, ensure_ascii=False, indent=2)
+                return result_json
+        except Exception as e:
+            logger.error(f"查询工作流失败: {e}", exc_info=True)
+            return f"查询工作流时发生错误: {str(e)}"

app/agent/tools/impl/read_file.py

@@ -0,0 +1,81 @@
+"""文件读取工具"""
+
+from pathlib import Path
+from typing import Optional, Type
+
+from anyio import Path as AsyncPath
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.log import logger
+
+# 最大读取大小 50KB
+MAX_READ_SIZE = 50 * 1024
+
+
+class ReadFileInput(BaseModel):
+    """Input parameters for read file tool"""
+    file_path: str = Field(..., description="The absolute path of the file to read")
+    start_line: Optional[int] = Field(None, description="The starting line number (1-based, inclusive). If not provided, reading starts from the beginning of the file.")
+    end_line: Optional[int] = Field(None, description="The ending line number (1-based, inclusive). If not provided, reading goes until the end of the file.")
+
+
+class ReadFileTool(MoviePilotTool):
+    name: str = "read_file"
+    description: str = "Read the content of a text file. Supports reading by line range. Each read is limited to 50KB; content exceeding this limit will be truncated."
+    args_schema: Type[BaseModel] = ReadFileInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据参数生成友好的提示消息"""
+        file_path = kwargs.get("file_path", "")
+        file_name = Path(file_path).name if file_path else "未知文件"
+        return f"正在读取文件: {file_name}"
+
+    async def run(self, file_path: str, start_line: Optional[int] = None,
+                  end_line: Optional[int] = None, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: file_path={file_path}, start_line={start_line}, end_line={end_line}")
+
+        try:
+            path = AsyncPath(file_path)
+
+            if not await path.exists():
+                return f"错误：文件 {file_path} 不存在"
+
+            if not await path.is_file():
+                return f"错误：{file_path} 不是一个文件"
+
+            content = await path.read_text(encoding="utf-8")
+            truncated = False
+
+            if start_line is not None or end_line is not None:
+                lines = content.splitlines(keepends=True)
+                total_lines = len(lines)
+
+                # 将行号转换为索引（1-based -> 0-based）
+                s = (start_line - 1) if start_line and start_line >= 1 else 0
+                e = end_line if end_line and end_line >= 1 else total_lines
+
+                # 确保范围有效
+                s = max(0, min(s, total_lines))
+                e = max(s, min(e, total_lines))
+
+                content = "".join(lines[s:e])
+
+            # 检查大小限制
+            content_bytes = content.encode("utf-8")
+            if len(content_bytes) > MAX_READ_SIZE:
+                content = content_bytes[:MAX_READ_SIZE].decode("utf-8", errors="ignore")
+                truncated = True
+
+            if truncated:
+                return f"{content}\n\n[警告：文件内容已超过50KB限制，以上内容已被截断。请使用 start_line/end_line 参数分段读取。]"
+
+            return content
+
+        except PermissionError:
+            return f"错误：没有权限读取 {file_path}"
+        except UnicodeDecodeError:
+            return f"错误：{file_path} 不是文本文件，无法读取"
+        except Exception as e:
+            logger.error(f"读取文件 {file_path} 时发生错误: {str(e)}", exc_info=True)
+            return f"操作失败: {str(e)}"

app/agent/tools/impl/recognize_media.py

@@ -0,0 +1,163 @@
+"""识别媒体信息工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.media import MediaChain
+from app.core.context import Context
+from app.core.metainfo import MetaInfo
+from app.log import logger
+from app.schemas.types import media_type_to_agent
+
+
+class RecognizeMediaInput(BaseModel):
+    """识别媒体信息工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    title: Optional[str] = Field(None, description="The title of the torrent/media to recognize (required for torrent recognition)")
+    subtitle: Optional[str] = Field(None, description="The subtitle or description of the torrent (optional, helps improve recognition accuracy)")
+    path: Optional[str] = Field(None, description="The file path to recognize (required for file recognition, mutually exclusive with title)")
+
+
+class RecognizeMediaTool(MoviePilotTool):
+    name: str = "recognize_media"
+    description: str = "Extract/identify media information from torrent titles or file paths (NOT database search). Supports two modes: 1) Extract from torrent title and optional subtitle, 2) Extract from file path. Returns detailed media information. Use 'search_media' to search TMDB database, or 'scrape_metadata' to generate metadata files for existing files."
+    args_schema: Type[BaseModel] = RecognizeMediaInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据识别参数生成友好的提示消息"""
+        title = kwargs.get("title")
+        subtitle = kwargs.get("subtitle")
+        path = kwargs.get("path")
+        
+        if path:
+            message = f"正在识别文件媒体信息: {path}"
+        elif title:
+            message = f"正在识别种子媒体信息: {title}"
+            if subtitle:
+                message += f" ({subtitle})"
+        else:
+            message = "正在识别媒体信息"
+        
+        return message
+
+    async def run(self, title: Optional[str] = None, subtitle: Optional[str] = None,
+                  path: Optional[str] = None, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: title={title}, subtitle={subtitle}, path={path}")
+        
+        try:
+            media_chain = MediaChain()
+            context = None
+            
+            # 根据提供的参数选择识别方式
+            if path:
+                # 文件路径识别
+                if not path:
+                    return json.dumps({
+                        "success": False,
+                        "message": "文件路径不能为空"
+                    }, ensure_ascii=False)
+                
+                context = await media_chain.async_recognize_by_path(path)
+                if context:
+                    return self._format_context_result(context, "文件")
+                else:
+                    return json.dumps({
+                        "success": False,
+                        "message": f"无法识别文件媒体信息: {path}",
+                        "path": path
+                    }, ensure_ascii=False)
+            
+            elif title:
+                # 种子标题识别
+                metainfo = MetaInfo(title, subtitle)
+                mediainfo = await media_chain.async_recognize_by_meta(metainfo)
+                if mediainfo:
+                    context = Context(meta_info=metainfo, media_info=mediainfo)
+                    return self._format_context_result(context, "种子")
+                else:
+                    return json.dumps({
+                        "success": False,
+                        "message": f"无法识别种子媒体信息: {title}",
+                        "title": title,
+                        "subtitle": subtitle
+                    }, ensure_ascii=False)
+            
+            else:
+                return json.dumps({
+                    "success": False,
+                    "message": "必须提供 title（标题）或 path（文件路径）参数之一"
+                }, ensure_ascii=False)
+        
+        except Exception as e:
+            error_message = f"识别媒体信息失败: {str(e)}"
+            logger.error(f"识别媒体信息失败: {e}", exc_info=True)
+            return json.dumps({
+                "success": False,
+                "message": error_message
+            }, ensure_ascii=False)
+
+    @staticmethod
+    def _format_context_result(context: Context, source_type: str) -> str:
+        """格式化识别结果为JSON字符串"""
+        if not context:
+            return json.dumps({
+                "success": False,
+                "message": "识别结果为空"
+            }, ensure_ascii=False)
+        
+        context_dict = context.to_dict()
+        media_info = context_dict.get("media_info")
+        meta_info = context_dict.get("meta_info")
+        
+        # 构建简化的结果
+        result = {
+            "success": True,
+            "source_type": source_type,
+            "media_info": None,
+            "meta_info": None
+        }
+        
+        # 处理媒体信息
+        if media_info:
+            result["media_info"] = {
+                "title": media_info.get("title"),
+                "en_title": media_info.get("en_title"),
+                "year": media_info.get("year"),
+                "type": media_type_to_agent(media_info.get("type")),
+                "season": media_info.get("season"),
+                "tmdb_id": media_info.get("tmdb_id"),
+                "imdb_id": media_info.get("imdb_id"),
+                "douban_id": media_info.get("douban_id"),
+                "bangumi_id": media_info.get("bangumi_id"),
+                "overview": media_info.get("overview"),
+                "vote_average": media_info.get("vote_average"),
+                "poster_path": media_info.get("poster_path"),
+                "backdrop_path": media_info.get("backdrop_path"),
+                "detail_link": media_info.get("detail_link"),
+                "title_year": media_info.get("title_year"),
+                "source": media_info.get("source")
+            }
+        
+        # 处理元数据信息
+        if meta_info:
+            result["meta_info"] = {
+                "name": meta_info.get("name"),
+                "title": meta_info.get("title"),
+                "year": meta_info.get("year"),
+                "type": media_type_to_agent(meta_info.get("type")),
+                "begin_season": meta_info.get("begin_season"),
+                "end_season": meta_info.get("end_season"),
+                "begin_episode": meta_info.get("begin_episode"),
+                "end_episode": meta_info.get("end_episode"),
+                "total_episode": meta_info.get("total_episode"),
+                "part": meta_info.get("part"),
+                "season_episode": meta_info.get("season_episode"),
+                "episode_list": meta_info.get("episode_list"),
+                "tmdbid": meta_info.get("tmdbid"),
+                "doubanid": meta_info.get("doubanid")
+            }
+        
+        return json.dumps(result, ensure_ascii=False, indent=2)

app/agent/tools/impl/run_scheduler.py

@@ -0,0 +1,60 @@
+"""运行定时服务工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.log import logger
+from app.scheduler import Scheduler
+
+
+class RunSchedulerInput(BaseModel):
+    """运行定时服务工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    job_id: str = Field(
+        ...,
+        description="The ID of the scheduled job to run (can be obtained from query_schedulers tool)",
+    )
+
+
+class RunSchedulerTool(MoviePilotTool):
+    name: str = "run_scheduler"
+    description: str = "Manually trigger a scheduled task to run immediately. This will execute the specified scheduler job by its ID."
+    args_schema: Type[BaseModel] = RunSchedulerInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据运行参数生成友好的提示消息"""
+        job_id = kwargs.get("job_id", "")
+        return f"正在运行定时服务 (ID: {job_id})"
+
+    async def run(self, job_id: str, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: job_id={job_id}")
+
+        try:
+            scheduler = Scheduler()
+            # 检查定时服务是否存在
+            schedulers = scheduler.list()
+            job_exists = False
+            job_name = None
+            for s in schedulers:
+                if s.id == job_id:
+                    job_exists = True
+                    job_name = s.name
+                    break
+
+            if not job_exists:
+                return f"定时服务 ID {job_id} 不存在，请使用 query_schedulers 工具查询可用的定时服务"
+
+            # 运行定时服务
+            scheduler.start(job_id)
+
+            return f"成功触发定时服务：{job_name} (ID: {job_id})"
+        except Exception as e:
+            logger.error(f"运行定时服务失败: {e}", exc_info=True)
+            return f"运行定时服务时发生错误: {str(e)}"

app/agent/tools/impl/run_slash_command.py

@@ -0,0 +1,115 @@
+"""运行斜杠命令工具（系统命令 + 插件命令）"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.event import eventmanager
+from app.log import logger
+from app.schemas.types import EventType, MessageChannel
+
+
+class RunSlashCommandInput(BaseModel):
+    """运行斜杠命令工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    command: str = Field(
+        ...,
+        description="The slash command to execute, e.g. '/cookiecloud'. "
+        "Must start with '/'. Can include arguments after the command, e.g. '/command arg1 arg2'. "
+        "Use query_plugin_capabilities tool to discover available plugin commands, "
+        "or list_slash_commands tool to discover all available commands (including system commands).",
+    )
+
+
+class RunSlashCommandTool(MoviePilotTool):
+    name: str = "run_slash_command"
+    description: str = (
+        "Execute a slash command (system or plugin) by sending a CommandExcute event. "
+        "This tool supports ALL registered slash commands, including: "
+        "1) System preset commands (e.g. /cookiecloud, /sites, /subscribes, /downloading, /transfer, /restart, etc.) "
+        "2) Plugin commands registered by installed plugins. "
+        "Use the query_plugin_capabilities tool to discover plugin commands, "
+        "or the list_slash_commands tool to discover all available commands. "
+        "The command will be executed asynchronously. "
+        "Note: This tool triggers the command execution but the actual processing happens in the background."
+    )
+    args_schema: Type[BaseModel] = RunSlashCommandInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """生成友好的提示消息"""
+        command = kwargs.get("command", "")
+        return f"正在执行命令: {command}"
+
+    async def run(self, command: str, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: command={command}")
+
+        try:
+            # 确保命令以 / 开头
+            if not command.startswith("/"):
+                command = f"/{command}"
+
+            # 从全局 Command 单例中验证命令是否存在（包含系统预设命令 + 插件命令 + 其他命令）
+            from app.command import Command
+
+            cmd_name = command.split()[0]
+            command_obj = Command()
+            matched_command = command_obj.get(cmd_name)
+
+            if not matched_command:
+                # 列出所有可用命令帮助用户
+                all_commands = command_obj.get_commands()
+                available_cmds = [
+                    f"{cmd} - {info.get('description', '无描述')}"
+                    for cmd, info in all_commands.items()
+                ]
+                result = {
+                    "success": False,
+                    "message": f"命令 {cmd_name} 不存在",
+                }
+                if available_cmds:
+                    result["available_commands"] = available_cmds
+                return json.dumps(result, ensure_ascii=False, indent=2)
+
+            # 构建消息渠道，优先使用当前会话的渠道信息
+            channel = None
+            if self._channel:
+                try:
+                    channel = MessageChannel(self._channel)
+                except (ValueError, KeyError):
+                    channel = None
+
+            # 发送命令执行事件，与 message.py 中的方式一致
+            eventmanager.send_event(
+                EventType.CommandExcute,
+                {
+                    "cmd": command,
+                    "user": self._user_id,
+                    "channel": channel,
+                    "source": self._source,
+                },
+            )
+
+            result = {
+                "success": True,
+                "message": f"命令 {cmd_name} 已触发执行",
+                "command": command,
+                "command_desc": matched_command.get("description", ""),
+            }
+            # 如果是插件命令，附加插件ID
+            if matched_command.get("pid"):
+                result["plugin_id"] = matched_command["pid"]
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            logger.error(f"执行命令失败: {e}", exc_info=True)
+            return json.dumps(
+                {"success": False, "message": f"执行命令时发生错误: {str(e)}"},
+                ensure_ascii=False,
+            )

app/agent/tools/impl/run_workflow.py

@@ -0,0 +1,77 @@
+"""执行工作流工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.workflow import WorkflowChain
+from app.db import AsyncSessionFactory
+from app.db.workflow_oper import WorkflowOper
+from app.log import logger
+
+
+class RunWorkflowInput(BaseModel):
+    """执行工作流工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    workflow_id: int = Field(
+        ..., description="Workflow ID (can be obtained from query_workflows tool)"
+    )
+    from_begin: Optional[bool] = Field(
+        True,
+        description="Whether to run workflow from the beginning (default: True, if False will continue from last executed action)",
+    )
+
+
+class RunWorkflowTool(MoviePilotTool):
+    name: str = "run_workflow"
+    description: str = "Execute a specific workflow manually by workflow ID. Supports running from the beginning or continuing from the last executed action."
+    args_schema: Type[BaseModel] = RunWorkflowInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据工作流参数生成友好的提示消息"""
+        workflow_id = kwargs.get("workflow_id")
+        from_begin = kwargs.get("from_begin", True)
+
+        message = f"正在执行工作流: {workflow_id}"
+        if not from_begin:
+            message += " (从上次位置继续)"
+        else:
+            message += " (从头开始)"
+
+        return message
+
+    async def run(
+        self, workflow_id: int, from_begin: Optional[bool] = True, **kwargs
+    ) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: workflow_id={workflow_id}, from_begin={from_begin}"
+        )
+
+        try:
+            # 获取数据库会话
+            async with AsyncSessionFactory() as db:
+                workflow_oper = WorkflowOper(db)
+                workflow = await workflow_oper.async_get(workflow_id)
+
+                if not workflow:
+                    return f"未找到工作流：{workflow_id}，请使用 query_workflows 工具查询可用的工作流"
+
+                # 执行工作流
+                workflow_chain = WorkflowChain()
+                state, errmsg = workflow_chain.process(
+                    workflow.id, from_begin=from_begin
+                )
+
+                if not state:
+                    return f"执行工作流失败：{workflow.name} (ID: {workflow.id})\n错误原因：{errmsg}"
+                else:
+                    return f"工作流执行成功：{workflow.name} (ID: {workflow.id})"
+        except Exception as e:
+            logger.error(f"执行工作流失败: {e}", exc_info=True)
+            return f"执行工作流时发生错误: {str(e)}"

app/agent/tools/impl/scrape_metadata.py

@@ -0,0 +1,141 @@
+"""刮削媒体元数据工具"""
+
+import json
+from pathlib import Path
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.media import MediaChain
+from app.core.config import global_vars
+from app.core.metainfo import MetaInfoPath
+from app.log import logger
+from app.schemas import FileItem
+
+
+class ScrapeMetadataInput(BaseModel):
+    """刮削媒体元数据工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    path: str = Field(
+        ...,
+        description="Path to the file or directory to scrape metadata for (e.g., '/path/to/file.mkv' or '/path/to/directory')",
+    )
+    storage: Optional[str] = Field(
+        "local",
+        description="Storage type: 'local' for local storage, 'smb', 'alist', etc. for remote storage (default: 'local')",
+    )
+    overwrite: Optional[bool] = Field(
+        False,
+        description="Whether to overwrite existing metadata files (default: False)",
+    )
+
+
+class ScrapeMetadataTool(MoviePilotTool):
+    name: str = "scrape_metadata"
+    description: str = "Generate metadata files (NFO files, posters, backgrounds, etc.) for existing media files or directories. Automatically recognizes media information from the file path and creates metadata files. Supports both local and remote storage. Use 'search_media' to search TMDB database, or 'recognize_media' to extract info from torrent titles/file paths without generating files."
+    require_admin: bool = True
+    args_schema: Type[BaseModel] = ScrapeMetadataInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据刮削参数生成友好的提示消息"""
+        path = kwargs.get("path", "")
+        storage = kwargs.get("storage", "local")
+        overwrite = kwargs.get("overwrite", False)
+
+        message = f"正在刮削媒体元数据: {path}"
+        if storage != "local":
+            message += f" [存储: {storage}]"
+        if overwrite:
+            message += " [覆盖模式]"
+
+        return message
+
+    async def run(
+        self,
+        path: str,
+        storage: Optional[str] = "local",
+        overwrite: Optional[bool] = False,
+        **kwargs,
+    ) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: path={path}, storage={storage}, overwrite={overwrite}"
+        )
+
+        try:
+            # 验证路径
+            if not path:
+                return json.dumps(
+                    {"success": False, "message": "刮削路径不能为空"},
+                    ensure_ascii=False,
+                )
+
+            # 创建 FileItem
+            fileitem = FileItem(
+                storage=storage, path=path, type="file" if Path(path).suffix else "dir"
+            )
+
+            # 检查本地存储路径是否存在
+            if storage == "local":
+                scrape_path = Path(path)
+                if not scrape_path.exists():
+                    return json.dumps(
+                        {"success": False, "message": f"刮削路径不存在: {path}"},
+                        ensure_ascii=False,
+                    )
+
+            # 识别媒体信息
+            media_chain = MediaChain()
+            scrape_path = Path(path)
+            meta = MetaInfoPath(scrape_path)
+            mediainfo = await media_chain.async_recognize_by_meta(meta)
+
+            if not mediainfo:
+                return json.dumps(
+                    {
+                        "success": False,
+                        "message": f"刮削失败，无法识别媒体信息: {path}",
+                        "path": path,
+                    },
+                    ensure_ascii=False,
+                )
+
+            # 在线程池中执行同步的刮削操作
+            await global_vars.loop.run_in_executor(
+                None,
+                lambda: media_chain.scrape_metadata(
+                    fileitem=fileitem,
+                    meta=meta,
+                    mediainfo=mediainfo,
+                    overwrite=overwrite,
+                ),
+            )
+
+            return json.dumps(
+                {
+                    "success": True,
+                    "message": f"{path} 刮削完成",
+                    "path": path,
+                    "media_info": {
+                        "title": mediainfo.title,
+                        "year": mediainfo.year,
+                        "type": mediainfo.type.value if mediainfo.type else None,
+                        "tmdb_id": mediainfo.tmdb_id,
+                        "season": mediainfo.season,
+                    },
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+
+        except Exception as e:
+            error_message = f"刮削媒体元数据失败: {str(e)}"
+            logger.error(f"刮削媒体元数据失败: {e}", exc_info=True)
+            return json.dumps(
+                {"success": False, "message": error_message, "path": path},
+                ensure_ascii=False,
+            )

app/agent/tools/impl/search_media.py

@@ -0,0 +1,109 @@
+"""搜索媒体工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.media import MediaChain
+from app.log import logger
+from app.schemas.types import MediaType, media_type_to_agent
+
+
+class SearchMediaInput(BaseModel):
+    """搜索媒体工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    title: str = Field(..., description="The title of the media to search for (e.g., 'The Matrix', 'Breaking Bad')")
+    year: Optional[str] = Field(None, description="Release year of the media (optional, helps narrow down results)")
+    media_type: Optional[str] = Field(None,
+                                      description="Allowed values: movie, tv")
+    season: Optional[int] = Field(None,
+                                  description="Season number for TV shows and anime (optional, only applicable for series)")
+
+
+class SearchMediaTool(MoviePilotTool):
+    name: str = "search_media"
+    description: str = "Search TMDB database for media resources (movies, TV shows, anime, etc.) by title, year, type, and other criteria. Returns detailed media information from TMDB. Use 'recognize_media' to extract info from torrent titles/file paths, or 'scrape_metadata' to generate metadata files."
+    args_schema: Type[BaseModel] = SearchMediaInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据搜索参数生成友好的提示消息"""
+        title = kwargs.get("title", "")
+        year = kwargs.get("year")
+        media_type = kwargs.get("media_type")
+        season = kwargs.get("season")
+        
+        message = f"正在搜索媒体: {title}"
+        if year:
+            message += f" ({year})"
+        if media_type:
+            message += f" [{media_type}]"
+        if season:
+            message += f" 第{season}季"
+        
+        return message
+
+    async def run(self, title: str, year: Optional[str] = None,
+                  media_type: Optional[str] = None, season: Optional[int] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: title={title}, year={year}, media_type={media_type}, season={season}")
+
+        try:
+            media_chain = MediaChain()
+            # 使用 MediaChain.search 方法
+            meta, results = await media_chain.async_search(title=title)
+
+            # 过滤结果
+            if results:
+                media_type_enum = None
+                if media_type:
+                    media_type_enum = MediaType.from_agent(media_type)
+                    if not media_type_enum:
+                        return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv'"
+
+                filtered_results = []
+                for result in results:
+                    if year and result.year != year:
+                        continue
+                    if media_type_enum and result.type != media_type_enum:
+                        continue
+                    if season is not None and result.season != season:
+                        continue
+                    filtered_results.append(result)
+
+                if filtered_results:
+                    # 限制最多30条结果
+                    total_count = len(filtered_results)
+                    limited_results = filtered_results[:30]
+                    # 精简字段，只保留关键信息
+                    simplified_results = []
+                    for r in limited_results:
+                        simplified = {
+                            "title": r.title,
+                            "en_title": r.en_title,
+                            "year": r.year,
+                            "type": media_type_to_agent(r.type),
+                            "season": r.season,
+                            "tmdb_id": r.tmdb_id,
+                            "imdb_id": r.imdb_id,
+                            "douban_id": r.douban_id,
+                            "overview": r.overview[:200] + "..." if r.overview and len(r.overview) > 200 else r.overview,
+                            "vote_average": r.vote_average,
+                            "poster_path": r.poster_path,
+                            "detail_link": r.detail_link
+                        }
+                        simplified_results.append(simplified)
+                    result_json = json.dumps(simplified_results, ensure_ascii=False, indent=2)
+                    # 如果结果被裁剪，添加提示信息
+                    if total_count > 100:
+                        return f"注意：搜索结果共找到 {total_count} 条，为节省上下文空间，仅显示前 100 条结果。\n\n{result_json}"
+                    return result_json
+                else:
+                    return f"未找到符合条件的媒体资源: {title}"
+            else:
+                return f"未找到相关媒体资源: {title}"
+        except Exception as e:
+            error_message = f"搜索媒体失败: {str(e)}"
+            logger.error(f"搜索媒体失败: {e}", exc_info=True)
+            return error_message

app/agent/tools/impl/search_person.py

@@ -0,0 +1,83 @@
+"""搜索人物工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.media import MediaChain
+from app.log import logger
+
+
+class SearchPersonInput(BaseModel):
+    """搜索人物工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    name: str = Field(..., description="The name of the person to search for (e.g., 'Tom Hanks', '周杰伦')")
+
+
+class SearchPersonTool(MoviePilotTool):
+    name: str = "search_person"
+    description: str = "Search for person information including actors, directors, etc. Supports searching by name. Returns detailed person information from TMDB, Douban, or Bangumi database."
+    args_schema: Type[BaseModel] = SearchPersonInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据搜索参数生成友好的提示消息"""
+        name = kwargs.get("name", "")
+        return f"正在搜索人物: {name}"
+
+    async def run(self, name: str, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: name={name}")
+
+        try:
+            media_chain = MediaChain()
+            # 使用 MediaChain.async_search_persons 方法搜索人物
+            persons = await media_chain.async_search_persons(name=name)
+
+            if persons:
+                # 限制最多30条结果
+                total_count = len(persons)
+                limited_persons = persons[:30]
+                # 精简字段，只保留关键信息
+                simplified_results = []
+                for person in limited_persons:
+                    simplified = {
+                        "name": person.name,
+                        "id": person.id,
+                        "source": person.source,
+                        "profile_path": person.profile_path,
+                        "original_name": person.original_name,
+                        "known_for_department": person.known_for_department,
+                        "popularity": person.popularity,
+                        "biography": person.biography[:200] + "..." if person.biography and len(person.biography) > 200 else person.biography,
+                        "birthday": person.birthday,
+                        "deathday": person.deathday,
+                        "place_of_birth": person.place_of_birth,
+                        "gender": person.gender,
+                        "imdb_id": person.imdb_id,
+                        "also_known_as": person.also_known_as[:5] if person.also_known_as else [],  # 限制别名数量
+                    }
+                    # 添加豆瓣特有字段
+                    if person.source == "douban":
+                        simplified["url"] = person.url
+                        simplified["avatar"] = person.avatar
+                        simplified["latin_name"] = person.latin_name
+                        simplified["roles"] = person.roles[:5] if person.roles else []  # 限制角色数量
+                    # 添加Bangumi特有字段
+                    if person.source == "bangumi":
+                        simplified["career"] = person.career
+                        simplified["relation"] = person.relation
+                    
+                    simplified_results.append(simplified)
+                
+                result_json = json.dumps(simplified_results, ensure_ascii=False, indent=2)
+                # 如果结果被裁剪，添加提示信息
+                if total_count > 50:
+                    return f"注意：搜索结果共找到 {total_count} 条，为节省上下文空间，仅显示前 50 条结果。\n\n{result_json}"
+                return result_json
+            else:
+                return f"未找到相关人物信息: {name}"
+        except Exception as e:
+            error_message = f"搜索人物失败: {str(e)}"
+            logger.error(f"搜索人物失败: {e}", exc_info=True)
+            return error_message

app/agent/tools/impl/search_person_credits.py

@@ -0,0 +1,85 @@
+"""搜索演员参演作品工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.douban import DoubanChain
+from app.chain.tmdb import TmdbChain
+from app.chain.bangumi import BangumiChain
+from app.log import logger
+
+
+class SearchPersonCreditsInput(BaseModel):
+    """搜索演员参演作品工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    person_id: int = Field(..., description="The ID of the person/actor to search for credits (e.g., 31 for Tom Hanks in TMDB)")
+    source: str = Field(..., description="The data source: 'tmdb' for TheMovieDB, 'douban' for Douban, 'bangumi' for Bangumi")
+    page: Optional[int] = Field(1, description="Page number for pagination (default: 1)")
+
+
+class SearchPersonCreditsTool(MoviePilotTool):
+    name: str = "search_person_credits"
+    description: str = "Search for films and TV shows that a person/actor has appeared in (filmography). Supports searching by person ID from TMDB, Douban, or Bangumi database. Returns a list of media works the person has participated in."
+    args_schema: Type[BaseModel] = SearchPersonCreditsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据搜索参数生成友好的提示消息"""
+        person_id = kwargs.get("person_id", "")
+        source = kwargs.get("source", "")
+        return f"正在搜索人物参演作品: {source} ID {person_id}"
+
+    async def run(self, person_id: int, source: str, page: Optional[int] = 1, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: person_id={person_id}, source={source}, page={page}")
+
+        try:
+            # 根据source选择相应的chain
+            if source.lower() == "tmdb":
+                tmdb_chain = TmdbChain()
+                medias = await tmdb_chain.async_person_credits(person_id=person_id, page=page)
+            elif source.lower() == "douban":
+                douban_chain = DoubanChain()
+                medias = await douban_chain.async_person_credits(person_id=person_id, page=page)
+            elif source.lower() == "bangumi":
+                bangumi_chain = BangumiChain()
+                medias = await bangumi_chain.async_person_credits(person_id=person_id)
+            else:
+                return f"不支持的数据源: {source}。支持的数据源: tmdb, douban, bangumi"
+
+            if medias:
+                # 限制最多30条结果
+                total_count = len(medias)
+                limited_medias = medias[:30]
+                # 精简字段，只保留关键信息
+                simplified_results = []
+                for media in limited_medias:
+                    simplified = {
+                        "title": media.title,
+                        "en_title": media.en_title,
+                        "year": media.year,
+                        "type": media.type.value if media.type else None,
+                        "season": media.season,
+                        "tmdb_id": media.tmdb_id,
+                        "imdb_id": media.imdb_id,
+                        "douban_id": media.douban_id,
+                        "overview": media.overview[:200] + "..." if media.overview and len(media.overview) > 200 else media.overview,
+                        "vote_average": media.vote_average,
+                        "poster_path": media.poster_path,
+                        "backdrop_path": media.backdrop_path,
+                        "detail_link": media.detail_link
+                    }
+                    simplified_results.append(simplified)
+                
+                result_json = json.dumps(simplified_results, ensure_ascii=False, indent=2)
+                # 如果结果被裁剪，添加提示信息
+                if total_count > 30:
+                    return f"注意：搜索结果共找到 {total_count} 条，为节省上下文空间，仅显示前 30 条结果。\n\n{result_json}"
+                return result_json
+            else:
+                return f"未找到人物 ID {person_id} ({source}) 的参演作品"
+        except Exception as e:
+            error_message = f"搜索演员参演作品失败: {str(e)}"
+            logger.error(f"搜索演员参演作品失败: {e}", exc_info=True)
+            return error_message

app/agent/tools/impl/search_subscribe.py

@@ -0,0 +1,128 @@
+"""搜索订阅缺失剧集工具"""
+
+import json
+from typing import Optional, Type, List
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.subscribe import SubscribeChain
+from app.core.config import global_vars
+from app.db.subscribe_oper import SubscribeOper
+from app.log import logger
+from app.schemas.types import media_type_to_agent
+
+
+class SearchSubscribeInput(BaseModel):
+    """搜索订阅缺失剧集工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    subscribe_id: int = Field(..., description="The ID of the subscription to search for missing episodes (can be obtained from query_subscribes tool)")
+    manual: Optional[bool] = Field(False, description="Whether this is a manual search (default: False)")
+    filter_groups: Optional[List[str]] = Field(None,
+                                               description="List of filter rule group names to apply for this search (optional, can be obtained from query_rule_groups tool. If provided, will temporarily update the subscription's filter groups before searching)")
+
+
+class SearchSubscribeTool(MoviePilotTool):
+    name: str = "search_subscribe"
+    description: str = "Search for missing episodes/resources for a specific subscription. This tool will search torrent sites for the missing episodes of the subscription and automatically download matching resources. Use this when a user wants to search for missing episodes of a specific subscription."
+    args_schema: Type[BaseModel] = SearchSubscribeInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据搜索参数生成友好的提示消息"""
+        subscribe_id = kwargs.get("subscribe_id")
+        manual = kwargs.get("manual", False)
+
+        message = f"正在搜索订阅 #{subscribe_id} 的缺失剧集"
+        if manual:
+            message += "（手动搜索）"
+
+        return message
+
+    async def run(self, subscribe_id: int, manual: Optional[bool] = False,
+                  filter_groups: Optional[List[str]] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: subscribe_id={subscribe_id}, manual={manual}, filter_groups={filter_groups}")
+
+        try:
+            # 先验证订阅是否存在
+            subscribe_oper = SubscribeOper()
+            subscribe = subscribe_oper.get(subscribe_id)
+
+            if not subscribe:
+                return json.dumps({
+                    "success": False,
+                    "message": f"订阅不存在: {subscribe_id}"
+                }, ensure_ascii=False)
+
+            # 获取订阅信息用于返回
+            subscribe_info = {
+                "id": subscribe.id,
+                "name": subscribe.name,
+                "year": subscribe.year,
+                "type": media_type_to_agent(subscribe.type),
+                "season": subscribe.season,
+                "state": subscribe.state,
+                "total_episode": subscribe.total_episode,
+                "lack_episode": subscribe.lack_episode,
+                "tmdbid": subscribe.tmdbid,
+                "doubanid": subscribe.doubanid
+            }
+
+            # 检查订阅状态
+            if subscribe.state == "S":
+                return json.dumps({
+                    "success": False,
+                    "message": f"订阅 #{subscribe_id} ({subscribe.name}) 已暂停，无法搜索",
+                    "subscribe": subscribe_info
+                }, ensure_ascii=False)
+
+            # 如果提供了 filter_groups 参数，先更新订阅的规则组
+            if filter_groups is not None:
+                subscribe_oper.update(subscribe_id, {"filter_groups": filter_groups})
+                logger.info(f"更新订阅 #{subscribe_id} 的规则组为: {filter_groups}")
+
+            # 调用 SubscribeChain 的 search 方法
+            # search 方法是同步的，需要在异步环境中运行
+            subscribe_chain = SubscribeChain()
+
+            # 在线程池中执行同步的搜索操作
+            # 当 sid 有值时，state 参数会被忽略，直接处理该订阅
+            await global_vars.loop.run_in_executor(
+                None,
+                lambda: subscribe_chain.search(
+                    sid=subscribe_id,
+                    state='R',  # 默认状态，当 sid 有值时此参数会被忽略
+                    manual=manual
+                )
+            )
+
+            # 重新获取订阅信息以获取更新后的状态
+            updated_subscribe = subscribe_oper.get(subscribe_id)
+            if updated_subscribe:
+                subscribe_info.update({
+                    "state": updated_subscribe.state,
+                    "lack_episode": updated_subscribe.lack_episode,
+                    "last_update": updated_subscribe.last_update,
+                    "filter_groups": updated_subscribe.filter_groups
+                })
+
+            # 如果提供了规则组，会在返回信息中显示
+            result = {
+                "success": True,
+                "message": f"订阅 #{subscribe_id} ({subscribe.name}) 搜索完成",
+                "subscribe": subscribe_info
+            }
+
+            if filter_groups is not None:
+                result["message"] += f"（已应用规则组: {', '.join(filter_groups)}）"
+
+            return json.dumps(result, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            error_message = f"搜索订阅缺失剧集失败: {str(e)}"
+            logger.error(f"搜索订阅缺失剧集失败: {e}", exc_info=True)
+            return json.dumps({
+                "success": False,
+                "message": error_message,
+                "subscribe_id": subscribe_id
+            }, ensure_ascii=False)

app/agent/tools/impl/search_torrents.py

@@ -0,0 +1,110 @@
+"""搜索种子工具"""
+
+import json
+from typing import List, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.search import SearchChain
+from app.db.systemconfig_oper import SystemConfigOper
+from app.helper.sites import SitesHelper
+from app.log import logger
+from app.schemas.types import MediaType, SystemConfigKey
+from ._torrent_search_utils import (
+    SEARCH_RESULT_CACHE_FILE,
+    build_filter_options,
+)
+
+
+class SearchTorrentsInput(BaseModel):
+    """搜索种子工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    tmdb_id: Optional[int] = Field(None, description="TMDB ID (can be obtained from search_media tool). Either tmdb_id or douban_id must be provided.")
+    douban_id: Optional[str] = Field(None, description="Douban ID (can be obtained from search_media tool). Either tmdb_id or douban_id must be provided.")
+    media_type: Optional[str] = Field(None, description="Allowed values: movie, tv")
+    area: Optional[str] = Field(None, description="Search scope: 'title' (default) or 'imdbid'")
+    sites: Optional[List[int]] = Field(None,
+                                       description="Array of specific site IDs to search on (optional, if not provided searches all configured sites)")
+
+class SearchTorrentsTool(MoviePilotTool):
+    name: str = "search_torrents"
+    description: str = ("Search for torrent files by media ID across configured indexer sites, cache the matched results, "
+                        "and return available filter options for follow-up selection. "
+                        "Requires tmdb_id or douban_id (can be obtained from search_media tool) for accurate matching.")
+    args_schema: Type[BaseModel] = SearchTorrentsInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据搜索参数生成友好的提示消息"""
+        tmdb_id = kwargs.get("tmdb_id")
+        douban_id = kwargs.get("douban_id")
+        media_type = kwargs.get("media_type")
+
+        if tmdb_id:
+            message = f"正在搜索种子: TMDB={tmdb_id}"
+        elif douban_id:
+            message = f"正在搜索种子: 豆瓣={douban_id}"
+        else:
+            message = "正在搜索种子"
+        if media_type:
+            message += f" [{media_type}]"
+        return message
+
+    async def run(self, tmdb_id: Optional[int] = None, douban_id: Optional[str] = None,
+                  media_type: Optional[str] = None, area: Optional[str] = None,
+                  sites: Optional[List[int]] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: tmdb_id={tmdb_id}, douban_id={douban_id}, media_type={media_type}, area={area}, sites={sites}")
+
+        if not tmdb_id and not douban_id:
+            return "参数错误：tmdb_id 和 douban_id 至少需要提供一个，请先使用 search_media 工具获取媒体 ID。"
+
+        try:
+            search_chain = SearchChain()
+            media_type_enum = None
+            if media_type:
+                media_type_enum = MediaType.from_agent(media_type)
+                if not media_type_enum:
+                    return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv'"
+
+            filtered_torrents = await search_chain.async_search_by_id(
+                tmdbid=tmdb_id,
+                doubanid=douban_id,
+                mtype=media_type_enum,
+                area=area or "title",
+                sites=sites,
+                cache_local=False,
+            )
+
+            # 获取站点信息
+            all_indexers = await SitesHelper().async_get_indexers()
+            all_sites = [{"id": indexer.get("id"), "name": indexer.get("name")} for indexer in (all_indexers or [])]
+
+            if sites:
+                search_site_ids = sites
+            else:
+                configured_sites = SystemConfigOper().get(SystemConfigKey.IndexerSites)
+                search_site_ids = configured_sites if configured_sites else []
+
+            if filtered_torrents:
+                await search_chain.async_save_cache(filtered_torrents, SEARCH_RESULT_CACHE_FILE)
+                result_json = json.dumps({
+                    "total_count": len(filtered_torrents),
+                    "message": "搜索完成。请使用 get_search_results 工具获取搜索结果。",
+                    "all_sites": all_sites,
+                    "search_site_ids": search_site_ids,
+                    "filter_options": build_filter_options(filtered_torrents),
+                }, ensure_ascii=False, indent=2)
+                return result_json
+            else:
+                media_id = f"TMDB={tmdb_id}" if tmdb_id else f"豆瓣={douban_id}"
+                result_json = json.dumps({
+                    "message": f"未找到相关种子资源: {media_id}",
+                    "all_sites": all_sites,
+                    "search_site_ids": search_site_ids,
+                }, ensure_ascii=False, indent=2)
+                return result_json
+        except Exception as e:
+            error_message = f"搜索种子时发生错误: {str(e)}"
+            logger.error(f"搜索种子失败: {e}", exc_info=True)
+            return error_message

app/agent/tools/impl/search_web.py

@@ -0,0 +1,239 @@
+import asyncio
+import json
+import random
+import re
+from typing import Optional, Type, List, Dict
+
+import httpx
+from ddgs import DDGS
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.config import settings
+from app.log import logger
+
+# 搜索超时时间（秒）
+SEARCH_TIMEOUT = 20
+
+
+class SearchWebInput(BaseModel):
+    """搜索网络内容工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    query: str = Field(
+        ..., description="The search query string to search for on the web"
+    )
+    max_results: Optional[int] = Field(
+        20,
+        description="Maximum number of search results to return (default: 5, max: 10)",
+    )
+
+
+class SearchWebTool(MoviePilotTool):
+    name: str = "search_web"
+    description: str = "Search the web for information when you need to find current information, facts, or references that you're uncertain about. Returns search results with titles, snippets, and URLs. Use this tool to get up-to-date information from the internet."
+    args_schema: Type[BaseModel] = SearchWebInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据搜索参数生成友好的提示消息"""
+        query = kwargs.get("query", "")
+        max_results = kwargs.get("max_results", 20)
+        return f"正在搜索网络内容: {query} (最多返回 {max_results} 条结果)"
+
+    async def run(self, query: str, max_results: Optional[int] = 20, **kwargs) -> str:
+        """
+        执行网络搜索
+        """
+        logger.info(
+            f"执行工具: {self.name}, 参数: query={query}, max_results={max_results}"
+        )
+
+        try:
+            # 限制最大结果数
+            max_results = min(max(1, max_results or 20), 20)
+            results = []
+
+            # 1. 优先使用 Exa (如果配置了 API Key)
+            if settings.EXA_API_KEY:
+                logger.info("使用 Exa 进行搜索...")
+                results = await self._search_exa(query, max_results)
+
+            # 2. 如果没有结果或未配置 Exa，使用 Tavily (如果配置了 API Key)
+            if not results and settings.TAVILY_API_KEY:
+                logger.info("使用 Tavily 进行搜索...")
+                results = await self._search_tavily(query, max_results)
+
+            # 3. 如果没有结果或未配置 Tavily，使用 DuckDuckGo
+            if not results:
+                logger.info("使用 DuckDuckGo 进行搜索...")
+                results = await self._search_duckduckgo(query, max_results)
+
+            if not results:
+                return f"未找到与 '{query}' 相关的搜索结果"
+
+            # 格式化并裁剪结果
+            formatted_results = self._format_and_truncate_results(results, max_results)
+            return json.dumps(formatted_results, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            error_message = f"搜索网络内容失败: {str(e)}"
+            logger.error(f"搜索网络内容失败: {e}", exc_info=True)
+            return error_message
+
+    @staticmethod
+    async def _search_tavily(query: str, max_results: int) -> List[Dict]:
+        """使用 Tavily API 进行搜索"""
+        try:
+            async with httpx.AsyncClient(timeout=SEARCH_TIMEOUT) as client:
+                # 从设置中随机选择一个 API Key（如果有多个）
+                tavity_api_key = random.choice(settings.TAVILY_API_KEY)
+                response = await client.post(
+                    "https://api.tavily.com/search",
+                    json={
+                        "api_key": tavity_api_key,
+                        "query": query,
+                        "search_depth": "basic",
+                        "max_results": max_results,
+                        "include_answer": False,
+                        "include_images": False,
+                        "include_raw_content": False,
+                    },
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                results = []
+                for result in data.get("results", []):
+                    results.append(
+                        {
+                            "title": result.get("title", ""),
+                            "snippet": result.get("content", ""),
+                            "url": result.get("url", ""),
+                            "source": "Tavily",
+                        }
+                    )
+                return results
+        except Exception as e:
+            logger.warning(f"Tavily 搜索失败: {e}")
+            return []
+
+    @staticmethod
+    async def _search_exa(query: str, max_results: int) -> List[Dict]:
+        """使用 Exa API 进行搜索"""
+        try:
+            async with httpx.AsyncClient(timeout=SEARCH_TIMEOUT) as client:
+                response = await client.post(
+                    "https://api.exa.ai/search",
+                    headers={
+                        "x-api-key": settings.EXA_API_KEY,
+                        "Content-Type": "application/json",
+                    },
+                    json={
+                        "query": query,
+                        "numResults": max_results,
+                        "type": "auto",
+                        "contents": {"highlights": {"maxCharacters": 2000}},
+                    },
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                results = []
+                for result in data.get("results", []):
+                    highlights = result.get("highlights", [])
+                    snippet = (
+                        highlights[0] if highlights else result.get("text", "")[:500]
+                    )
+                    results.append(
+                        {
+                            "title": result.get("title", ""),
+                            "snippet": snippet,
+                            "url": result.get("url", ""),
+                            "source": "Exa",
+                        }
+                    )
+                return results
+        except Exception as e:
+            logger.warning(f"Exa 搜索失败: {e}")
+            return []
+
+    @staticmethod
+    def _get_proxy_url(proxy_setting) -> Optional[str]:
+        """从代理设置中提取代理URL"""
+        if not proxy_setting:
+            return None
+        if isinstance(proxy_setting, dict):
+            return proxy_setting.get("http") or proxy_setting.get("https")
+        return proxy_setting
+
+    async def _search_duckduckgo(self, query: str, max_results: int) -> List[Dict]:
+        """使用 duckduckgo-search (DDGS) 进行搜索"""
+        try:
+
+            def sync_search():
+                results = []
+                ddgs_kwargs = {"timeout": SEARCH_TIMEOUT}
+                proxy_url = self._get_proxy_url(settings.PROXY)
+                if proxy_url:
+                    ddgs_kwargs["proxy"] = proxy_url
+
+                try:
+                    with DDGS(**ddgs_kwargs) as ddgs:
+                        ddgs_gen = ddgs.text(query, max_results=max_results)
+                        if ddgs_gen:
+                            for result in ddgs_gen:
+                                results.append(
+                                    {
+                                        "title": result.get("title", ""),
+                                        "snippet": result.get("body", ""),
+                                        "url": result.get("href", ""),
+                                        "source": "DuckDuckGo",
+                                    }
+                                )
+                except Exception as err:
+                    logger.warning(f"DuckDuckGo search process failed: {err}")
+                return results
+
+            loop = asyncio.get_running_loop()
+            return await loop.run_in_executor(None, sync_search)
+
+        except Exception as e:
+            logger.warning(f"DuckDuckGo 搜索失败: {e}")
+            return []
+
+    @staticmethod
+    def _format_and_truncate_results(results: List[Dict], max_results: int) -> Dict:
+        """格式化并裁剪搜索结果"""
+        formatted = {"total_results": len(results), "results": []}
+
+        for idx, result in enumerate(results[:max_results], 1):
+            title = result.get("title", "")[:200]
+            snippet = result.get("snippet", "")
+            url = result.get("url", "")
+            source = result.get("source", "Unknown")
+
+            # 裁剪摘要
+            max_snippet_length = 1000  # 增加到1000字符，提供更多上下文
+            if len(snippet) > max_snippet_length:
+                snippet = snippet[:max_snippet_length] + "..."
+
+            # 清理文本
+            snippet = re.sub(r"\s+", " ", snippet).strip()
+
+            formatted["results"].append(
+                {
+                    "rank": idx,
+                    "title": title,
+                    "snippet": snippet,
+                    "url": url,
+                    "source": source,
+                }
+            )
+
+        if len(results) > max_results:
+            formatted["note"] = f"仅显示前 {max_results} 条结果。"
+
+        return formatted

app/agent/tools/impl/send_message.py

@@ -0,0 +1,79 @@
+"""发送消息工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field, model_validator
+
+from app.agent.tools.base import MoviePilotTool
+from app.log import logger
+
+
+class SendMessageInput(BaseModel):
+    """发送消息工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    message: Optional[str] = Field(
+        None,
+        description="The message content to send to the user (should be clear and informative)",
+    )
+    message_type: Optional[str] = Field(
+        None,
+        description="Title of the message, a short summary of the message content",
+    )
+    image_url: Optional[str] = Field(
+        None,
+        description="Optional image URL to send together with the message on channels that support images (such as Telegram and Slack)",
+    )
+
+    @model_validator(mode="after")
+    def validate_payload(self):
+        if not self.message and not self.message_type and not self.image_url:
+            raise ValueError("message、message_type、image_url 至少需要提供一个")
+        return self
+
+
+class SendMessageTool(MoviePilotTool):
+    name: str = "send_message"
+    description: str = "Send notification message to the user through configured notification channels (Telegram, Slack, WeChat, etc.). Supports optional image_url on channels that can send images. Used to inform users about operation results, errors, important updates, or proactively send a relevant image."
+    args_schema: Type[BaseModel] = SendMessageInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据消息参数生成友好的提示消息"""
+        message = kwargs.get("message", "") or ""
+        title = kwargs.get("message_type") or ""
+        image_url = kwargs.get("image_url")
+
+        # 截断过长的消息
+        if len(message) > 50:
+            message = message[:50] + "..."
+
+        if title and image_url:
+            return f"正在发送图文消息: [{title}] {message}"
+        if title:
+            return f"正在发送消息: [{title}] {message}"
+        if image_url:
+            return f"正在发送图片消息: {message}"
+        return f"正在发送消息: {message}"
+
+    async def run(
+        self,
+        message: Optional[str] = None,
+        message_type: Optional[str] = None,
+        image_url: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        title = message_type or ("图片" if image_url and not message else "")
+        text = message or ""
+        logger.info(
+            f"执行工具: {self.name}, 参数: title={title}, message={text}, image_url={image_url}"
+        )
+        try:
+            await self.send_tool_message(text, title=title, image=image_url)
+            return "消息已发送"
+        except Exception as e:
+            logger.error(f"发送消息失败: {e}")
+            return f"发送消息时发生错误: {str(e)}"

app/agent/tools/impl/test_site.py

@@ -0,0 +1,49 @@
+"""测试站点连通性工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.site import SiteChain
+from app.db.site_oper import SiteOper
+from app.log import logger
+
+
+class TestSiteInput(BaseModel):
+    """测试站点连通性工具的输入参数模型"""
+    explanation: str = Field(..., description="Clear explanation of why this tool is being used in the current context")
+    site_identifier: int = Field(..., description="Site ID to test (can be obtained from query_sites tool)")
+
+
+class TestSiteTool(MoviePilotTool):
+    name: str = "test_site"
+    description: str = "Test site connectivity and availability. This will check if a site is accessible and can be logged in. Accepts site ID only."
+    args_schema: Type[BaseModel] = TestSiteInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据测试参数生成友好的提示消息"""
+        site_identifier = kwargs.get("site_identifier")
+        return f"正在测试站点连通性: {site_identifier}"
+
+    async def run(self, site_identifier: int, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: site_identifier={site_identifier}")
+
+        try:
+            site_oper = SiteOper()
+            site_chain = SiteChain()
+            site = await site_oper.async_get(site_identifier)
+            
+            if not site:
+                return f"未找到站点：{site_identifier}，请使用 query_sites 工具查询可用的站点"
+            
+            # 测试站点连通性
+            status, message = site_chain.test(site.domain)
+            
+            if status:
+                return f"站点连通性测试成功：{site.name} ({site.domain})\n{message}"
+            else:
+                return f"站点连通性测试失败：{site.name} ({site.domain})\n{message}"
+        except Exception as e:
+            logger.error(f"测试站点连通性失败: {e}", exc_info=True)
+            return f"测试站点连通性时发生错误: {str(e)}"

app/agent/tools/impl/transfer_file.py

@@ -0,0 +1,177 @@
+"""整理文件或目录工具"""
+
+from pathlib import Path
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.transfer import TransferChain
+from app.log import logger
+from app.schemas import FileItem, MediaType
+
+
+class TransferFileInput(BaseModel):
+    """整理文件或目录工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    file_path: str = Field(
+        ...,
+        description="Path to the file or directory to transfer (e.g., '/path/to/file.mkv' or '/path/to/directory')",
+    )
+    storage: Optional[str] = Field(
+        "local",
+        description="Storage type of the source file (default: 'local', can be 'smb', 'alist', etc.)",
+    )
+    target_path: Optional[str] = Field(
+        None,
+        description="Target path for the transferred file/directory (optional, uses default library path if not specified)",
+    )
+    target_storage: Optional[str] = Field(
+        None,
+        description="Target storage type (optional, uses default storage if not specified)",
+    )
+    media_type: Optional[str] = Field(None, description="Allowed values: movie, tv")
+    tmdbid: Optional[int] = Field(
+        None,
+        description="TMDB ID for precise media identification (optional but recommended for accuracy)",
+    )
+    doubanid: Optional[str] = Field(
+        None, description="Douban ID for media identification (optional)"
+    )
+    season: Optional[int] = Field(
+        None, description="Season number for TV shows (optional)"
+    )
+    transfer_type: Optional[str] = Field(
+        None,
+        description="Transfer mode: 'move' to move files, 'copy' to copy files, 'link' for hard link, 'softlink' for symbolic link (optional, uses default mode if not specified)",
+    )
+    background: Optional[bool] = Field(
+        False,
+        description="Whether to run transfer in background (default: False, runs synchronously)",
+    )
+
+
+class TransferFileTool(MoviePilotTool):
+    name: str = "transfer_file"
+    description: str = "Transfer/organize a file or directory to the media library. Automatically recognizes media information and organizes files according to configured rules. Supports custom target paths, media identification, and transfer modes."
+    args_schema: Type[BaseModel] = TransferFileInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据整理参数生成友好的提示消息"""
+        file_path = kwargs.get("file_path", "")
+        media_type = kwargs.get("media_type")
+        transfer_type = kwargs.get("transfer_type")
+        background = kwargs.get("background", False)
+
+        message = f"正在整理文件: {file_path}"
+        if media_type:
+            message += f" [{media_type}]"
+        if transfer_type:
+            transfer_map = {
+                "move": "移动",
+                "copy": "复制",
+                "link": "硬链接",
+                "softlink": "软链接",
+            }
+            message += f" 模式: {transfer_map.get(transfer_type, transfer_type)}"
+        if background:
+            message += " [后台运行]"
+
+        return message
+
+    async def run(
+        self,
+        file_path: str,
+        storage: Optional[str] = "local",
+        target_path: Optional[str] = None,
+        target_storage: Optional[str] = None,
+        media_type: Optional[str] = None,
+        tmdbid: Optional[int] = None,
+        doubanid: Optional[str] = None,
+        season: Optional[int] = None,
+        transfer_type: Optional[str] = None,
+        background: Optional[bool] = False,
+        **kwargs,
+    ) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: file_path={file_path}, storage={storage}, target_path={target_path}, "
+            f"target_storage={target_storage}, media_type={media_type}, tmdbid={tmdbid}, doubanid={doubanid}, "
+            f"season={season}, transfer_type={transfer_type}, background={background}"
+        )
+
+        try:
+            if not file_path:
+                return "错误：必须提供文件或目录路径"
+
+            # 规范化路径
+            if storage == "local":
+                # 本地路径处理
+                if not file_path.startswith("/") and not (
+                    len(file_path) > 1 and file_path[1] == ":"
+                ):
+                    # 相对路径，尝试转换为绝对路径
+                    file_path = str(Path(file_path).resolve())
+            else:
+                # 远程存储路径，确保以/开头
+                if not file_path.startswith("/"):
+                    file_path = "/" + file_path
+
+            # 创建FileItem
+            fileitem = FileItem(
+                storage=storage or "local",
+                path=file_path,
+                type="dir" if file_path.endswith("/") else "file",
+            )
+
+            # 处理目标路径
+            target_path_obj = None
+            if target_path:
+                target_path_obj = Path(target_path)
+
+            # 处理媒体类型
+            media_type_enum = None
+            if media_type:
+                media_type_enum = MediaType.from_agent(media_type)
+                if not media_type_enum:
+                    return f"错误：无效的媒体类型 '{media_type}'，支持的类型：'movie', 'tv'"
+
+            # 调用整理方法
+            transfer_chain = TransferChain()
+            state, errormsg = transfer_chain.manual_transfer(
+                fileitem=fileitem,
+                target_storage=target_storage,
+                target_path=target_path_obj,
+                tmdbid=tmdbid,
+                doubanid=doubanid,
+                mtype=media_type_enum,
+                season=season,
+                transfer_type=transfer_type,
+                background=background,
+            )
+
+            if not state:
+                # 处理错误信息
+                if isinstance(errormsg, list):
+                    error_text = f"整理完成，{len(errormsg)} 个文件转移失败"
+                    if errormsg:
+                        error_text += f"：\n" + "\n".join(
+                            str(e) for e in errormsg[:5]
+                        )  # 只显示前5个错误
+                        if len(errormsg) > 5:
+                            error_text += f"\n... 还有 {len(errormsg) - 5} 个错误"
+                else:
+                    error_text = str(errormsg)
+                return f"整理失败：{error_text}"
+            else:
+                if background:
+                    return f"整理任务已提交到后台运行：{file_path}"
+                else:
+                    return f"整理成功：{file_path}"
+        except Exception as e:
+            logger.error(f"整理文件失败: {e}", exc_info=True)
+            return f"整理文件时发生错误: {str(e)}"

app/agent/tools/impl/update_custom_identifiers.py

@@ -0,0 +1,95 @@
+"""更新自定义识别词工具"""
+
+import json
+from typing import List, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.db.systemconfig_oper import SystemConfigOper
+from app.log import logger
+from app.schemas.types import SystemConfigKey
+
+
+class UpdateCustomIdentifiersInput(BaseModel):
+    """更新自定义识别词工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    identifiers: List[str] = Field(
+        ...,
+        description=(
+            "The complete list of custom identifier rules to save. "
+            "This REPLACES the entire existing list. "
+            "Always query existing identifiers first, merge new rules, then pass the full list."
+        ),
+    )
+
+
+class UpdateCustomIdentifiersTool(MoviePilotTool):
+    name: str = "update_custom_identifiers"
+    description: str = (
+        "Update the full list of custom identifiers (自定义识别词) used for preprocessing torrent/file names. "
+        "This tool REPLACES all existing identifier rules with the provided list. "
+        "IMPORTANT: Always use 'query_custom_identifiers' first to get existing rules, "
+        "then merge new rules into the list before calling this tool to avoid accidentally deleting existing rules. "
+        "Supported rule formats (spaces around operators are required): "
+        "1) Block word: just the word/regex to remove; "
+        "2) Replacement: '被替换词 => 替换词'; "
+        "3) Episode offset: '前定位词 <> 后定位词 >> EP±N'; "
+        "4) Combined: '被替换词 => 替换词 && 前定位词 <> 后定位词 >> EP±N'; "
+        "Lines starting with '#' are comments. "
+        "The replacement target supports: {[tmdbid=xxx;type=movie/tv;s=xxx;e=xxx]} for direct TMDB ID matching."
+    )
+    args_schema: Type[BaseModel] = UpdateCustomIdentifiersInput
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """生成友好的提示消息"""
+        identifiers = kwargs.get("identifiers", [])
+        return f"正在更新自定义识别词（共 {len(identifiers)} 条规则）"
+
+    async def run(self, identifiers: List[str] = None, **kwargs) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 规则数量: {len(identifiers) if identifiers else 0}"
+        )
+        try:
+            if identifiers is None:
+                return json.dumps(
+                    {"success": False, "message": "必须提供 identifiers 参数"},
+                    ensure_ascii=False,
+                )
+
+            # 过滤空字符串
+            identifiers = [i for i in identifiers if i is not None]
+
+            system_config_oper = SystemConfigOper()
+
+            # 保存
+            value = identifiers if identifiers else None
+            success = await system_config_oper.async_set(
+                SystemConfigKey.CustomIdentifiers, value
+            )
+            if success:
+                return json.dumps(
+                    {
+                        "success": True,
+                        "message": f"自定义识别词已更新，共 {len(identifiers)} 条规则",
+                        "count": len(identifiers),
+                        "identifiers": identifiers,
+                    },
+                    ensure_ascii=False,
+                    indent=2,
+                )
+            else:
+                return json.dumps(
+                    {"success": False, "message": "保存自定义识别词失败"},
+                    ensure_ascii=False,
+                )
+        except Exception as e:
+            logger.error(f"更新自定义识别词失败: {e}")
+            return json.dumps(
+                {"success": False, "message": f"更新自定义识别词时发生错误: {str(e)}"},
+                ensure_ascii=False,
+            )

app/agent/tools/impl/update_site.py

@@ -0,0 +1,235 @@
+"""更新站点工具"""
+
+import json
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.event import eventmanager
+from app.db import AsyncSessionFactory
+from app.db.models.site import Site
+from app.log import logger
+from app.schemas.types import EventType
+from app.utils.string import StringUtils
+
+
+class UpdateSiteInput(BaseModel):
+    """更新站点工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    site_id: int = Field(
+        ...,
+        description="The ID of the site to update (can be obtained from query_sites tool)",
+    )
+    name: Optional[str] = Field(None, description="Site name (optional)")
+    url: Optional[str] = Field(
+        None, description="Site URL (optional, will be automatically formatted)"
+    )
+    pri: Optional[int] = Field(
+        None,
+        description="Site priority (optional, smaller value = higher priority, e.g., pri=1 has higher priority than pri=10)",
+    )
+    rss: Optional[str] = Field(None, description="RSS feed URL (optional)")
+    cookie: Optional[str] = Field(None, description="Site cookie (optional)")
+    ua: Optional[str] = Field(None, description="User-Agent string (optional)")
+    apikey: Optional[str] = Field(None, description="API key (optional)")
+    token: Optional[str] = Field(None, description="API token (optional)")
+    proxy: Optional[int] = Field(
+        None, description="Whether to use proxy: 0 for no, 1 for yes (optional)"
+    )
+    filter: Optional[str] = Field(
+        None, description="Filter rule as regular expression (optional)"
+    )
+    note: Optional[str] = Field(None, description="Site notes/remarks (optional)")
+    timeout: Optional[int] = Field(
+        None, description="Request timeout in seconds (optional, default: 15)"
+    )
+    limit_interval: Optional[int] = Field(
+        None, description="Rate limit interval in seconds (optional)"
+    )
+    limit_count: Optional[int] = Field(
+        None, description="Rate limit count per interval (optional)"
+    )
+    limit_seconds: Optional[int] = Field(
+        None, description="Rate limit seconds between requests (optional)"
+    )
+    is_active: Optional[bool] = Field(
+        None,
+        description="Whether site is active: True for enabled, False for disabled (optional)",
+    )
+    downloader: Optional[str] = Field(
+        None, description="Downloader name for this site (optional)"
+    )
+
+
+class UpdateSiteTool(MoviePilotTool):
+    name: str = "update_site"
+    description: str = "Update site configuration including URL, priority, authentication credentials (cookie, UA, API key), proxy settings, rate limits, and other site properties. Supports updating multiple site attributes at once. Site priority (pri): smaller values have higher priority (e.g., pri=1 has higher priority than pri=10)."
+    args_schema: Type[BaseModel] = UpdateSiteInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据更新参数生成友好的提示消息"""
+        site_id = kwargs.get("site_id")
+        fields_updated = []
+
+        if kwargs.get("name"):
+            fields_updated.append("名称")
+        if kwargs.get("url"):
+            fields_updated.append("URL")
+        if kwargs.get("pri") is not None:
+            fields_updated.append("优先级")
+        if kwargs.get("cookie"):
+            fields_updated.append("Cookie")
+        if kwargs.get("ua"):
+            fields_updated.append("User-Agent")
+        if kwargs.get("proxy") is not None:
+            fields_updated.append("代理设置")
+        if kwargs.get("is_active") is not None:
+            fields_updated.append("启用状态")
+        if kwargs.get("downloader"):
+            fields_updated.append("下载器")
+
+        if fields_updated:
+            return f"正在更新站点 #{site_id}: {', '.join(fields_updated)}"
+        return f"正在更新站点 #{site_id}"
+
+    async def run(
+        self,
+        site_id: int,
+        name: Optional[str] = None,
+        url: Optional[str] = None,
+        pri: Optional[int] = None,
+        rss: Optional[str] = None,
+        cookie: Optional[str] = None,
+        ua: Optional[str] = None,
+        apikey: Optional[str] = None,
+        token: Optional[str] = None,
+        proxy: Optional[int] = None,
+        filter: Optional[str] = None,
+        note: Optional[str] = None,
+        timeout: Optional[int] = None,
+        limit_interval: Optional[int] = None,
+        limit_count: Optional[int] = None,
+        limit_seconds: Optional[int] = None,
+        is_active: Optional[bool] = None,
+        downloader: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: site_id={site_id}")
+
+        try:
+            # 获取数据库会话
+            async with AsyncSessionFactory() as db:
+                # 获取站点
+                site = await Site.async_get(db, site_id)
+                if not site:
+                    return json.dumps(
+                        {"success": False, "message": f"站点不存在: {site_id}"},
+                        ensure_ascii=False,
+                    )
+
+                # 构建更新字典
+                site_dict = {}
+
+                # 基本信息
+                if name is not None:
+                    site_dict["name"] = name
+
+                # URL处理（需要校正格式）
+                if url is not None:
+                    _scheme, _netloc = StringUtils.get_url_netloc(url)
+                    site_dict["url"] = f"{_scheme}://{_netloc}/"
+
+                if pri is not None:
+                    site_dict["pri"] = pri
+                if rss is not None:
+                    site_dict["rss"] = rss
+
+                # 认证信息
+                if cookie is not None:
+                    site_dict["cookie"] = cookie
+                if ua is not None:
+                    site_dict["ua"] = ua
+                if apikey is not None:
+                    site_dict["apikey"] = apikey
+                if token is not None:
+                    site_dict["token"] = token
+
+                # 配置选项
+                if proxy is not None:
+                    site_dict["proxy"] = proxy
+                if filter is not None:
+                    site_dict["filter"] = filter
+                if note is not None:
+                    site_dict["note"] = note
+                if timeout is not None:
+                    site_dict["timeout"] = timeout
+
+                # 流控设置
+                if limit_interval is not None:
+                    site_dict["limit_interval"] = limit_interval
+                if limit_count is not None:
+                    site_dict["limit_count"] = limit_count
+                if limit_seconds is not None:
+                    site_dict["limit_seconds"] = limit_seconds
+
+                # 状态和下载器
+                if is_active is not None:
+                    site_dict["is_active"] = is_active
+                if downloader is not None:
+                    site_dict["downloader"] = downloader
+
+                # 如果没有要更新的字段
+                if not site_dict:
+                    return json.dumps(
+                        {"success": False, "message": "没有提供要更新的字段"},
+                        ensure_ascii=False,
+                    )
+
+                # 更新站点
+                await site.async_update(db, site_dict)
+
+                # 重新获取更新后的站点数据
+                updated_site = await Site.async_get(db, site_id)
+
+                # 发送站点更新事件
+                await eventmanager.async_send_event(
+                    EventType.SiteUpdated,
+                    {"domain": updated_site.domain if updated_site else site.domain},
+                )
+
+                # 构建返回结果
+                result = {
+                    "success": True,
+                    "message": f"站点 #{site_id} 更新成功",
+                    "site_id": site_id,
+                    "updated_fields": list(site_dict.keys()),
+                }
+
+                if updated_site:
+                    result["site"] = {
+                        "id": updated_site.id,
+                        "name": updated_site.name,
+                        "domain": updated_site.domain,
+                        "url": updated_site.url,
+                        "pri": updated_site.pri,
+                        "is_active": updated_site.is_active,
+                        "downloader": updated_site.downloader,
+                        "proxy": updated_site.proxy,
+                        "timeout": updated_site.timeout,
+                    }
+
+                return json.dumps(result, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            error_message = f"更新站点失败: {str(e)}"
+            logger.error(f"更新站点失败: {e}", exc_info=True)
+            return json.dumps(
+                {"success": False, "message": error_message, "site_id": site_id},
+                ensure_ascii=False,
+            )

app/agent/tools/impl/update_site_cookie.py

@@ -0,0 +1,84 @@
+"""更新站点Cookie和UA工具"""
+
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.chain.site import SiteChain
+from app.db.site_oper import SiteOper
+from app.log import logger
+
+
+class UpdateSiteCookieInput(BaseModel):
+    """更新站点Cookie和UA工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    site_identifier: int = Field(
+        ...,
+        description="Site ID to update Cookie and User-Agent for (can be obtained from query_sites tool)",
+    )
+    username: str = Field(..., description="Site login username")
+    password: str = Field(..., description="Site login password")
+    two_step_code: Optional[str] = Field(
+        None,
+        description="Two-step verification code or secret key (optional, required for sites with 2FA enabled)",
+    )
+
+
+class UpdateSiteCookieTool(MoviePilotTool):
+    name: str = "update_site_cookie"
+    description: str = "Update site Cookie and User-Agent by logging in with username and password. This tool can automatically obtain and update the site's authentication credentials. Supports two-step verification for sites that require it. Accepts site ID only."
+    args_schema: Type[BaseModel] = UpdateSiteCookieInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据更新参数生成友好的提示消息"""
+        site_identifier = kwargs.get("site_identifier")
+        username = kwargs.get("username", "")
+        two_step_code = kwargs.get("two_step_code")
+
+        message = f"正在更新站点Cookie: {site_identifier} (用户: {username})"
+        if two_step_code:
+            message += " [需要两步验证]"
+
+        return message
+
+    async def run(
+        self,
+        site_identifier: int,
+        username: str,
+        password: str,
+        two_step_code: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        logger.info(
+            f"执行工具: {self.name}, 参数: site_identifier={site_identifier}, username={username}"
+        )
+
+        try:
+            site_oper = SiteOper()
+            site_chain = SiteChain()
+            site = await site_oper.async_get(site_identifier)
+
+            if not site:
+                return f"未找到站点：{site_identifier}，请使用 query_sites 工具查询可用的站点"
+
+            # 更新站点Cookie和UA
+            status, message = site_chain.update_cookie(
+                site_info=site,
+                username=username,
+                password=password,
+                two_step_code=two_step_code,
+            )
+
+            if status:
+                return f"站点【{site.name}】Cookie和UA更新成功\n{message}"
+            else:
+                return f"站点【{site.name}】Cookie和UA更新失败\n错误原因：{message}"
+        except Exception as e:
+            logger.error(f"更新站点Cookie和UA失败: {e}", exc_info=True)
+            return f"更新站点Cookie和UA时发生错误: {str(e)}"

app/agent/tools/impl/update_subscribe.py

@@ -0,0 +1,303 @@
+"""更新订阅工具"""
+
+import json
+from typing import Optional, Type, List
+
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.core.event import eventmanager
+from app.db import AsyncSessionFactory
+from app.db.models.subscribe import Subscribe
+from app.log import logger
+from app.schemas.types import EventType
+
+
+class UpdateSubscribeInput(BaseModel):
+    """更新订阅工具的输入参数模型"""
+
+    explanation: str = Field(
+        ...,
+        description="Clear explanation of why this tool is being used in the current context",
+    )
+    subscribe_id: int = Field(
+        ...,
+        description="The ID of the subscription to update (can be obtained from query_subscribes tool)",
+    )
+    name: Optional[str] = Field(None, description="Subscription name/title (optional)")
+    year: Optional[str] = Field(None, description="Release year (optional)")
+    season: Optional[int] = Field(
+        None, description="Season number for TV shows (optional)"
+    )
+    total_episode: Optional[int] = Field(
+        None, description="Total number of episodes (optional)"
+    )
+    lack_episode: Optional[int] = Field(
+        None, description="Number of missing episodes (optional)"
+    )
+    start_episode: Optional[int] = Field(
+        None, description="Starting episode number (optional)"
+    )
+    quality: Optional[str] = Field(
+        None,
+        description="Quality filter as regular expression (optional, e.g., 'BluRay|WEB-DL|HDTV')",
+    )
+    resolution: Optional[str] = Field(
+        None,
+        description="Resolution filter as regular expression (optional, e.g., '1080p|720p|2160p')",
+    )
+    effect: Optional[str] = Field(
+        None,
+        description="Effect filter as regular expression (optional, e.g., 'HDR|DV|SDR')",
+    )
+    include: Optional[str] = Field(
+        None, description="Include filter as regular expression (optional)"
+    )
+    exclude: Optional[str] = Field(
+        None, description="Exclude filter as regular expression (optional)"
+    )
+    filter: Optional[str] = Field(
+        None, description="Filter rule as regular expression (optional)"
+    )
+    state: Optional[str] = Field(
+        None,
+        description="Subscription state: 'R' for enabled, 'P' for pending, 'S' for paused (optional)",
+    )
+    sites: Optional[List[int]] = Field(
+        None, description="List of site IDs to search from (optional)"
+    )
+    downloader: Optional[str] = Field(None, description="Downloader name (optional)")
+    save_path: Optional[str] = Field(
+        None, description="Save path for downloaded files (optional)"
+    )
+    best_version: Optional[int] = Field(
+        None,
+        description="Whether to upgrade to best version: 0 for no, 1 for yes (optional)",
+    )
+    custom_words: Optional[str] = Field(
+        None, description="Custom recognition words (optional)"
+    )
+    media_category: Optional[str] = Field(
+        None, description="Custom media category (optional)"
+    )
+    episode_group: Optional[str] = Field(
+        None, description="Episode group ID (optional)"
+    )
+
+
+class UpdateSubscribeTool(MoviePilotTool):
+    name: str = "update_subscribe"
+    description: str = "Update subscription properties including filters, episode counts, state, and other settings. Supports updating quality/resolution filters, episode tracking, subscription state, and download configuration."
+    args_schema: Type[BaseModel] = UpdateSubscribeInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据更新参数生成友好的提示消息"""
+        subscribe_id = kwargs.get("subscribe_id")
+        fields_updated = []
+
+        if kwargs.get("name"):
+            fields_updated.append("名称")
+        if kwargs.get("total_episode") is not None:
+            fields_updated.append("总集数")
+        if kwargs.get("lack_episode") is not None:
+            fields_updated.append("缺失集数")
+        if kwargs.get("quality"):
+            fields_updated.append("质量过滤")
+        if kwargs.get("resolution"):
+            fields_updated.append("分辨率过滤")
+        if kwargs.get("state"):
+            state_map = {"R": "启用", "P": "禁用", "S": "暂停"}
+            fields_updated.append(
+                f"状态({state_map.get(kwargs.get('state'), kwargs.get('state'))})"
+            )
+        if kwargs.get("sites"):
+            fields_updated.append("站点")
+        if kwargs.get("downloader"):
+            fields_updated.append("下载器")
+
+        if fields_updated:
+            return f"正在更新订阅 #{subscribe_id}: {', '.join(fields_updated)}"
+        return f"正在更新订阅 #{subscribe_id}"
+
+    async def run(
+        self,
+        subscribe_id: int,
+        name: Optional[str] = None,
+        year: Optional[str] = None,
+        season: Optional[int] = None,
+        total_episode: Optional[int] = None,
+        lack_episode: Optional[int] = None,
+        start_episode: Optional[int] = None,
+        quality: Optional[str] = None,
+        resolution: Optional[str] = None,
+        effect: Optional[str] = None,
+        include: Optional[str] = None,
+        exclude: Optional[str] = None,
+        filter: Optional[str] = None,
+        state: Optional[str] = None,
+        sites: Optional[List[int]] = None,
+        downloader: Optional[str] = None,
+        save_path: Optional[str] = None,
+        best_version: Optional[int] = None,
+        custom_words: Optional[str] = None,
+        media_category: Optional[str] = None,
+        episode_group: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: subscribe_id={subscribe_id}")
+
+        try:
+            # 获取数据库会话
+            async with AsyncSessionFactory() as db:
+                # 获取订阅
+                subscribe = await Subscribe.async_get(db, subscribe_id)
+                if not subscribe:
+                    return json.dumps(
+                        {"success": False, "message": f"订阅不存在: {subscribe_id}"},
+                        ensure_ascii=False,
+                    )
+
+                # 保存旧数据用于事件
+                old_subscribe_dict = subscribe.to_dict()
+
+                # 构建更新字典
+                subscribe_dict = {}
+
+                # 基本信息
+                if name is not None:
+                    subscribe_dict["name"] = name
+                if year is not None:
+                    subscribe_dict["year"] = year
+                if season is not None:
+                    subscribe_dict["season"] = season
+
+                # 集数相关
+                if total_episode is not None:
+                    subscribe_dict["total_episode"] = total_episode
+                    # 如果总集数增加，缺失集数也要相应增加
+                    if total_episode > (subscribe.total_episode or 0):
+                        old_lack = subscribe.lack_episode or 0
+                        subscribe_dict["lack_episode"] = old_lack + (
+                            total_episode - (subscribe.total_episode or 0)
+                        )
+                    # 标记为手动修改过总集数
+                    subscribe_dict["manual_total_episode"] = 1
+
+                # 缺失集数处理（只有在没有提供总集数时才单独处理）
+                # 注意：如果 lack_episode 为 0，不更新（避免更新为0）
+                if lack_episode is not None and total_episode is None:
+                    if lack_episode > 0:
+                        subscribe_dict["lack_episode"] = lack_episode
+                    # 如果 lack_episode 为 0，不添加到更新字典中（保持原值或由总集数逻辑处理）
+
+                if start_episode is not None:
+                    subscribe_dict["start_episode"] = start_episode
+
+                # 过滤规则
+                if quality is not None:
+                    subscribe_dict["quality"] = quality
+                if resolution is not None:
+                    subscribe_dict["resolution"] = resolution
+                if effect is not None:
+                    subscribe_dict["effect"] = effect
+                if include is not None:
+                    subscribe_dict["include"] = include
+                if exclude is not None:
+                    subscribe_dict["exclude"] = exclude
+                if filter is not None:
+                    subscribe_dict["filter"] = filter
+
+                # 状态
+                if state is not None:
+                    valid_states = ["R", "P", "S", "N"]
+                    if state not in valid_states:
+                        return json.dumps(
+                            {
+                                "success": False,
+                                "message": f"无效的订阅状态: {state}，有效状态: {', '.join(valid_states)}",
+                            },
+                            ensure_ascii=False,
+                        )
+                    subscribe_dict["state"] = state
+
+                # 下载配置
+                if sites is not None:
+                    subscribe_dict["sites"] = sites
+                if downloader is not None:
+                    subscribe_dict["downloader"] = downloader
+                if save_path is not None:
+                    subscribe_dict["save_path"] = save_path
+                if best_version is not None:
+                    subscribe_dict["best_version"] = best_version
+
+                # 其他配置
+                if custom_words is not None:
+                    subscribe_dict["custom_words"] = custom_words
+                if media_category is not None:
+                    subscribe_dict["media_category"] = media_category
+                if episode_group is not None:
+                    subscribe_dict["episode_group"] = episode_group
+
+                # 如果没有要更新的字段
+                if not subscribe_dict:
+                    return json.dumps(
+                        {"success": False, "message": "没有提供要更新的字段"},
+                        ensure_ascii=False,
+                    )
+
+                # 更新订阅
+                await subscribe.async_update(db, subscribe_dict)
+
+                # 重新获取更新后的订阅数据
+                updated_subscribe = await Subscribe.async_get(db, subscribe_id)
+
+                # 发送订阅调整事件
+                await eventmanager.async_send_event(
+                    EventType.SubscribeModified,
+                    {
+                        "subscribe_id": subscribe_id,
+                        "old_subscribe_info": old_subscribe_dict,
+                        "subscribe_info": updated_subscribe.to_dict()
+                        if updated_subscribe
+                        else {},
+                    },
+                )
+
+                # 构建返回结果
+                result = {
+                    "success": True,
+                    "message": f"订阅 #{subscribe_id} 更新成功",
+                    "subscribe_id": subscribe_id,
+                    "updated_fields": list(subscribe_dict.keys()),
+                }
+
+                if updated_subscribe:
+                    result["subscribe"] = {
+                        "id": updated_subscribe.id,
+                        "name": updated_subscribe.name,
+                        "year": updated_subscribe.year,
+                        "type": updated_subscribe.type,
+                        "season": updated_subscribe.season,
+                        "state": updated_subscribe.state,
+                        "total_episode": updated_subscribe.total_episode,
+                        "lack_episode": updated_subscribe.lack_episode,
+                        "start_episode": updated_subscribe.start_episode,
+                        "quality": updated_subscribe.quality,
+                        "resolution": updated_subscribe.resolution,
+                        "effect": updated_subscribe.effect,
+                    }
+
+                return json.dumps(result, ensure_ascii=False, indent=2)
+
+        except Exception as e:
+            error_message = f"更新订阅失败: {str(e)}"
+            logger.error(f"更新订阅失败: {e}", exc_info=True)
+            return json.dumps(
+                {
+                    "success": False,
+                    "message": error_message,
+                    "subscribe_id": subscribe_id,
+                },
+                ensure_ascii=False,
+            )

app/agent/tools/impl/write_file.py

@@ -0,0 +1,54 @@
+"""文件写入工具"""
+
+from pathlib import Path
+from typing import Optional, Type
+
+from anyio import Path as AsyncPath
+from pydantic import BaseModel, Field
+
+from app.agent.tools.base import MoviePilotTool
+from app.log import logger
+
+
+class WriteFileInput(BaseModel):
+    """Input parameters for write file tool"""
+
+    file_path: str = Field(..., description="The absolute path of the file to write")
+    content: str = Field(..., description="The content to write into the file")
+
+
+class WriteFileTool(MoviePilotTool):
+    name: str = "write_file"
+    description: str = "Write full content to a file. If the file already exists, it will be overwritten. Automatically creates parent directories if they don't exist."
+    args_schema: Type[BaseModel] = WriteFileInput
+    require_admin: bool = True
+
+    def get_tool_message(self, **kwargs) -> Optional[str]:
+        """根据参数生成友好的提示消息"""
+        file_path = kwargs.get("file_path", "")
+        file_name = Path(file_path).name if file_path else "未知文件"
+        return f"正在写入文件: {file_name}"
+
+    async def run(self, file_path: str, content: str, **kwargs) -> str:
+        logger.info(f"执行工具: {self.name}, 参数: file_path={file_path}")
+
+        try:
+            path = AsyncPath(file_path)
+
+            if await path.exists() and not await path.is_file():
+                return f"错误：{file_path} 路径已存在但不是一个文件"
+
+            # 自动创建父目录
+            await path.parent.mkdir(parents=True, exist_ok=True)
+
+            # 写入文件
+            await path.write_text(content, encoding="utf-8")
+
+            logger.info(f"成功写入文件 {file_path}")
+            return f"成功写入文件 {file_path}"
+
+        except PermissionError:
+            return f"错误：没有权限写入 {file_path}"
+        except Exception as e:
+            logger.error(f"写入文件 {file_path} 时发生错误: {str(e)}", exc_info=True)
+            return f"操作失败: {str(e)}"

app/agent/tools/manager.py

@@ -0,0 +1,319 @@
+import json
+import uuid
+from typing import Any, Dict, List, Optional
+
+from app.agent.tools.factory import MoviePilotToolFactory
+from app.log import logger
+
+
+class ToolDefinition:
+    """
+    工具定义
+    """
+
+    def __init__(self, name: str, description: str, input_schema: Dict[str, Any]):
+        self.name = name
+        self.description = description
+        self.input_schema = input_schema
+
+
+class MoviePilotToolsManager:
+    """
+    MoviePilot工具管理器（用于HTTP API）
+    """
+
+    def __init__(self, user_id: str = "api_user", session_id: str = uuid.uuid4()):
+        """
+        初始化工具管理器
+
+        Args:
+            user_id: 用户ID
+            session_id: 会话ID
+        """
+        self.user_id = user_id
+        self.session_id = session_id
+        self.tools: List[Any] = []
+        self._load_tools()
+
+    def _load_tools(self):
+        """
+        加载所有MoviePilot工具
+        """
+        try:
+            # 创建工具实例
+            self.tools = MoviePilotToolFactory.create_tools(
+                session_id=self.session_id,
+                user_id=self.user_id,
+                channel=None,
+                source="api",
+                username="API Client",
+                stream_handler=None,
+            )
+            logger.info(f"成功加载 {len(self.tools)} 个工具")
+        except Exception as e:
+            logger.error(f"加载工具失败: {e}", exc_info=True)
+            self.tools = []
+
+    def list_tools(self) -> List[ToolDefinition]:
+        """
+        列出所有可用的工具
+
+        Returns:
+            工具定义列表
+        """
+        tools_list = []
+        for tool in self.tools:
+            # 获取工具的输入参数模型
+            args_schema = getattr(tool, "args_schema", None)
+            if args_schema:
+                # 将Pydantic模型转换为JSON Schema
+                input_schema = self._convert_to_json_schema(args_schema)
+            else:
+                # 如果没有args_schema，使用基本信息
+                input_schema = {"type": "object", "properties": {}, "required": []}
+
+            tools_list.append(
+                ToolDefinition(
+                    name=tool.name,
+                    description=tool.description or "",
+                    input_schema=input_schema,
+                )
+            )
+
+        return tools_list
+
+    def get_tool(self, tool_name: str) -> Optional[Any]:
+        """
+        获取指定工具实例
+
+        Args:
+            tool_name: 工具名称
+
+        Returns:
+            工具实例，如果未找到返回None
+        """
+        for tool in self.tools:
+            if tool.name == tool_name:
+                return tool
+        return None
+
+    @staticmethod
+    def _resolve_field_schema(field_info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        解析字段schema，兼容 Optional[T] 生成的 anyOf 结构
+        """
+        if field_info.get("type"):
+            return field_info
+
+        any_of = field_info.get("anyOf")
+        if not any_of:
+            return field_info
+
+        for type_option in any_of:
+            if type_option.get("type") and type_option["type"] != "null":
+                merged = dict(type_option)
+                if "description" not in merged and field_info.get("description"):
+                    merged["description"] = field_info["description"]
+                if "default" not in merged and "default" in field_info:
+                    merged["default"] = field_info["default"]
+                return merged
+
+        return field_info
+
+    @staticmethod
+    def _normalize_scalar_value(field_type: Optional[str], value: Any, key: str) -> Any:
+        """
+        根据字段类型规范化单个值
+        """
+        if field_type == "integer" and isinstance(value, str):
+            try:
+                return int(value)
+            except (ValueError, TypeError):
+                logger.warning(f"无法将参数 {key}='{value}' 转换为整数，返回 None")
+                return None
+        if field_type == "number" and isinstance(value, str):
+            try:
+                return float(value)
+            except (ValueError, TypeError):
+                logger.warning(f"无法将参数 {key}='{value}' 转换为浮点数，返回 None")
+                return None
+        if field_type == "boolean":
+            if isinstance(value, str):
+                return value.lower() in ("true", "1", "yes", "on")
+            if isinstance(value, (int, float)):
+                return value != 0
+            if isinstance(value, bool):
+                return value
+            return True
+        return value
+
+    @staticmethod
+    def _parse_array_string(value: str, key: str, item_type: str = "string") -> list:
+        """
+        将逗号分隔的字符串解析为列表，并根据 item_type 转换元素类型
+        """
+        trimmed = value.strip()
+        if not trimmed:
+            return []
+        return [
+            MoviePilotToolsManager._normalize_scalar_value(item_type, item.strip(), key)
+            for item in trimmed.split(",")
+            if item.strip()
+        ]
+
+    @staticmethod
+    def _normalize_arguments(
+        tool_instance: Any, arguments: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        根据工具的参数schema规范化参数类型
+
+        Args:
+            tool_instance: 工具实例
+            arguments: 原始参数
+
+        Returns:
+            规范化后的参数
+        """
+        # 获取工具的参数schema
+        args_schema = getattr(tool_instance, "args_schema", None)
+        if not args_schema:
+            return arguments
+
+        # 获取schema中的字段定义
+        try:
+            schema = args_schema.model_json_schema()
+            properties = schema.get("properties", {})
+        except Exception as e:
+            logger.warning(f"获取工具schema失败: {e}")
+            return arguments
+
+        # 规范化参数
+        normalized = {}
+        for key, value in arguments.items():
+            if key not in properties:
+                # 参数不在schema中，保持原样
+                normalized[key] = value
+                continue
+
+            field_info = MoviePilotToolsManager._resolve_field_schema(properties[key])
+            field_type = field_info.get("type")
+
+            # 数组类型：将字符串解析为列表
+            if field_type == "array" and isinstance(value, str):
+                item_type = field_info.get("items", {}).get("type", "string")
+                normalized[key] = MoviePilotToolsManager._parse_array_string(
+                    value, key, item_type
+                )
+                continue
+
+            # 根据类型进行转换
+            normalized[key] = MoviePilotToolsManager._normalize_scalar_value(
+                field_type, value, key
+            )
+
+        return normalized
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
+        """
+        调用工具
+
+        Args:
+            tool_name: 工具名称
+            arguments: 工具参数
+
+        Returns:
+            工具执行结果（字符串）
+        """
+        tool_instance = self.get_tool(tool_name)
+
+        if not tool_instance:
+            error_msg = json.dumps(
+                {"error": f"工具 '{tool_name}' 未找到"}, ensure_ascii=False
+            )
+            return error_msg
+
+        try:
+            # 规范化参数类型
+            normalized_arguments = self._normalize_arguments(tool_instance, arguments)
+
+            # 调用工具的run方法
+            result = await tool_instance.run(**normalized_arguments)
+
+            # 确保返回字符串
+            if isinstance(result, str):
+                formated_result = result
+            elif isinstance(result, (int, float)):
+                formated_result = str(result)
+            else:
+                try:
+                    formated_result = json.dumps(result, ensure_ascii=False, indent=2)
+                except Exception as e:
+                    logger.warning(f"结果转换为JSON失败: {e}, 使用字符串表示")
+                    formated_result = str(result)
+
+            return formated_result
+        except Exception as e:
+            logger.error(f"调用工具 {tool_name} 时发生错误: {e}", exc_info=True)
+            error_msg = json.dumps(
+                {"error": f"调用工具 '{tool_name}' 时发生错误: {str(e)}"},
+                ensure_ascii=False,
+            )
+            return error_msg
+
+    @staticmethod
+    def _convert_to_json_schema(args_schema: Any) -> Dict[str, Any]:
+        """
+        将Pydantic模型转换为JSON Schema
+
+        Args:
+            args_schema: Pydantic模型类
+
+        Returns:
+            JSON Schema字典
+        """
+        # 获取Pydantic模型的字段信息
+        schema = args_schema.model_json_schema()
+
+        # 构建JSON Schema
+        properties = {}
+        required = []
+
+        if "properties" in schema:
+            for field_name, field_info in schema["properties"].items():
+                resolved_field_info = MoviePilotToolsManager._resolve_field_schema(
+                    field_info
+                )
+                # 转换字段类型
+                field_type = resolved_field_info.get("type", "string")
+                field_description = resolved_field_info.get("description", "")
+
+                # 处理可选字段
+                if field_name not in schema.get("required", []):
+                    # 可选字段
+                    default_value = resolved_field_info.get("default")
+                    properties[field_name] = {
+                        "type": field_type,
+                        "description": field_description,
+                    }
+                    if default_value is not None:
+                        properties[field_name]["default"] = default_value
+                else:
+                    properties[field_name] = {
+                        "type": field_type,
+                        "description": field_description,
+                    }
+                    required.append(field_name)
+
+                # 处理枚举类型
+                if "enum" in resolved_field_info:
+                    properties[field_name]["enum"] = resolved_field_info["enum"]
+
+                # 处理数组类型
+                if field_type == "array" and "items" in resolved_field_info:
+                    properties[field_name]["items"] = resolved_field_info["items"]
+
+        return {"type": "object", "properties": properties, "required": required}
+
+
+moviepilot_tool_manager = MoviePilotToolsManager()

app/api/apiv1.py

@@ -1,11 +1,13 @@
 from fastapi import APIRouter
 
-from app.api.endpoints import login, user, site, message, webhook, subscribe, \
-    media, douban, search, plugin, tmdb, history, system, download, dashboard, rss, filebrowser, transfer
+from app.api.endpoints import login, user, webhook, message, site, subscribe, \
+    media, douban, search, plugin, tmdb, history, system, download, dashboard, \
+    transfer, mediaserver, bangumi, storage, discover, recommend, workflow, torrent, mcp, mfa
 
 api_router = APIRouter()
 api_router.include_router(login.router, prefix="/login", tags=["login"])
 api_router.include_router(user.router, prefix="/user", tags=["user"])
+api_router.include_router(mfa.router, prefix="/mfa", tags=["mfa"])
 api_router.include_router(site.router, prefix="/site", tags=["site"])
 api_router.include_router(message.router, prefix="/message", tags=["message"])
 api_router.include_router(webhook.router, prefix="/webhook", tags=["webhook"])
@@ -19,6 +21,12 @@ api_router.include_router(system.router, prefix="/system", tags=["system"])
 api_router.include_router(plugin.router, prefix="/plugin", tags=["plugin"])
 api_router.include_router(download.router, prefix="/download", tags=["download"])
 api_router.include_router(dashboard.router, prefix="/dashboard", tags=["dashboard"])
-api_router.include_router(rss.router, prefix="/rss", tags=["rss"])
-api_router.include_router(filebrowser.router, prefix="/filebrowser", tags=["filebrowser"])
+api_router.include_router(storage.router, prefix="/storage", tags=["storage"])
 api_router.include_router(transfer.router, prefix="/transfer", tags=["transfer"])
+api_router.include_router(mediaserver.router, prefix="/mediaserver", tags=["mediaserver"])
+api_router.include_router(bangumi.router, prefix="/bangumi", tags=["bangumi"])
+api_router.include_router(discover.router, prefix="/discover", tags=["discover"])
+api_router.include_router(recommend.router, prefix="/recommend", tags=["recommend"])
+api_router.include_router(workflow.router, prefix="/workflow", tags=["workflow"])
+api_router.include_router(torrent.router, prefix="/torrent", tags=["torrent"])
+api_router.include_router(mcp.router, prefix="/mcp", tags=["mcp"])

app/api/endpoints/bangumi.py

@@ -0,0 +1,74 @@
+from typing import List, Any, Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.chain.bangumi import BangumiChain
+from app.core.context import MediaInfo
+from app.core.security import verify_token
+
+router = APIRouter()
+
+
+@router.get("/credits/{bangumiid}", summary="查询Bangumi演职员表", response_model=List[schemas.MediaPerson])
+async def bangumi_credits(bangumiid: int,
+                          page: Optional[int] = 1,
+                          count: Optional[int] = 20,
+                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询Bangumi演职员表
+    """
+    persons = await BangumiChain().async_bangumi_credits(bangumiid)
+    if persons:
+        return persons[(page - 1) * count: page * count]
+    return []
+
+
+@router.get("/recommend/{bangumiid}", summary="查询Bangumi推荐", response_model=List[schemas.MediaInfo])
+async def bangumi_recommend(bangumiid: int,
+                            page: Optional[int] = 1,
+                            count: Optional[int] = 20,
+                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询Bangumi推荐
+    """
+    medias = await BangumiChain().async_bangumi_recommend(bangumiid)
+    if medias:
+        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
+    return []
+
+
+@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
+async def bangumi_person(person_id: int,
+                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据人物ID查询人物详情
+    """
+    return await BangumiChain().async_person_detail(person_id=person_id)
+
+
+@router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
+async def bangumi_person_credits(person_id: int,
+                                 page: Optional[int] = 1,
+                                 count: Optional[int] = 20,
+                                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据人物ID查询人物参演作品
+    """
+    medias = await BangumiChain().async_person_credits(person_id=person_id)
+    if medias:
+        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
+    return []
+
+
+@router.get("/{bangumiid}", summary="查询Bangumi详情", response_model=schemas.MediaInfo)
+async def bangumi_info(bangumiid: int,
+                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询Bangumi详情
+    """
+    info = await BangumiChain().async_bangumi_info(bangumiid)
+    if info:
+        return MediaInfo(bangumi_info=info).to_dict()
+    else:
+        return schemas.MediaInfo()

app/api/endpoints/dashboard.py

@@ -1,58 +1,84 @@
 from pathlib import Path
-from typing import Any, List
+from typing import Any, List, Optional, Annotated
 
 from fastapi import APIRouter, Depends
-from requests import Session
+from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.dashboard import DashboardChain
-from app.core.config import settings
-from app.core.security import verify_token
+from app.chain.storage import StorageChain
+from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
 from app.db.models.transferhistory import TransferHistory
+from app.helper.directory import DirectoryHelper
 from app.scheduler import Scheduler
-from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
-from app.utils.timer import TimerUtils
 
 router = APIRouter()
 
 
 @router.get("/statistic", summary="媒体数量统计", response_model=schemas.Statistic)
-def statistic(db: Session = Depends(get_db),
-              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def statistic(name: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询媒体数量统计信息
     """
-    media_statistic = DashboardChain(db).media_statistic()
-    if media_statistic:
-        return schemas.Statistic(
-            movie_count=media_statistic.movie_count,
-            tv_count=media_statistic.tv_count,
-            episode_count=media_statistic.episode_count,
-            user_count=media_statistic.user_count
-        )
+    media_statistics: Optional[List[schemas.Statistic]] = DashboardChain().media_statistic(name)
+    if media_statistics:
+        # 汇总各媒体库统计信息
+        ret_statistic = schemas.Statistic()
+        has_episode_count = False
+        for media_statistic in media_statistics:
+            ret_statistic.movie_count += media_statistic.movie_count or 0
+            ret_statistic.tv_count += media_statistic.tv_count or 0
+            ret_statistic.user_count += media_statistic.user_count or 0
+            if media_statistic.episode_count is not None:
+                ret_statistic.episode_count += media_statistic.episode_count or 0
+                has_episode_count = True
+        if not has_episode_count:
+            # 所有媒体服务都未提供剧集统计时，返回 None 供前端展示“未获取”。
+            ret_statistic.episode_count = None
+        return ret_statistic
     else:
         return schemas.Statistic()
 
 
-@router.get("/storage", summary="存储空间", response_model=schemas.Storage)
+@router.get("/statistic2", summary="媒体数量统计（API_TOKEN）", response_model=schemas.Statistic)
+def statistic2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询媒体数量统计信息 API_TOKEN认证（?token=xxx）
+    """
+    return statistic()
+
+
+@router.get("/storage", summary="本地存储空间", response_model=schemas.Storage)
 def storage(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    查询存储空间信息
+    查询本地存储空间信息
     """
-    if settings.LIBRARY_PATH:
-        total_storage, free_storage = SystemUtils.space_usage(
-            [Path(path) for path in settings.LIBRARY_PATH.split(",")]
-        )
-    else:
-        total_storage, free_storage = 0, 0
+    total, available = 0, 0
+    dirs = DirectoryHelper().get_dirs()
+    if not dirs:
+        return schemas.Storage(total_storage=total, used_storage=total - available)
+    storages = set([d.library_storage for d in dirs if d.library_storage])
+    for _storage in storages:
+        _usage = StorageChain().storage_usage(_storage)
+        if _usage:
+            total += _usage.total
+            available += _usage.available
     return schemas.Storage(
-        total_storage=total_storage,
-        used_storage=total_storage - free_storage
+        total_storage=total,
+        used_storage=total - available
     )
 
 
+@router.get("/storage2", summary="本地存储空间（API_TOKEN）", response_model=schemas.Storage)
+def storage2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询本地存储空间信息 API_TOKEN认证（?token=xxx）
+    """
+    return storage()
+
+
 @router.get("/processes", summary="进程信息", response_model=List[schemas.ProcessInfo])
 def processes(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -62,65 +88,104 @@ def processes(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/downloader", summary="下载器信息", response_model=schemas.DownloaderInfo)
-def downloader(db: Session = Depends(get_db),
-               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def downloader(name: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询下载器信息
     """
-    transfer_info = DashboardChain(db).downloader_info()
-    free_space = SystemUtils.free_space(Path(settings.DOWNLOAD_PATH))
-    return schemas.DownloaderInfo(
-        download_speed=transfer_info.download_speed,
-        upload_speed=transfer_info.upload_speed,
-        download_size=transfer_info.download_size,
-        upload_size=transfer_info.upload_size,
-        free_space=free_space
-    )
+    # 下载目录空间
+    download_dirs = DirectoryHelper().get_local_download_dirs()
+    _, free_space = SystemUtils.space_usage([Path(d.download_path) for d in download_dirs])
+    # 下载器信息
+    downloader_info = schemas.DownloaderInfo()
+    transfer_infos = DashboardChain().downloader_info(name)
+    if transfer_infos:
+        for transfer_info in transfer_infos:
+            downloader_info.download_speed += transfer_info.download_speed
+            downloader_info.upload_speed += transfer_info.upload_speed
+            downloader_info.download_size += transfer_info.download_size
+            downloader_info.upload_size += transfer_info.upload_size
+        downloader_info.free_space = free_space
+    return downloader_info
+
+
+@router.get("/downloader2", summary="下载器信息（API_TOKEN）", response_model=schemas.DownloaderInfo)
+def downloader2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询下载器信息 API_TOKEN认证（?token=xxx）
+    """
+    return downloader()
 
 
 @router.get("/schedule", summary="后台服务", response_model=List[schemas.ScheduleInfo])
-def schedule(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def schedule(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询后台服务信息
     """
-    # 返回计时任务
-    schedulers = []
-    # 去重
-    added = []
-    jobs = Scheduler().list()
-    # 按照下次运行时间排序
-    jobs.sort(key=lambda x: x.next_run_time)
-    for job in jobs:
-        if job.name not in added:
-            added.append(job.name)
-        else:
-            continue
-        if not StringUtils.is_chinese(job.name):
-            continue
-        if not job.next_run_time:
-            status = "已停止"
-            next_run = ""
-        else:
-            next_run = TimerUtils.time_difference(job.next_run_time)
-            if not next_run:
-                status = "正在运行"
-            else:
-                status = "阻塞" if job.pending else "等待"
-        schedulers.append(schemas.ScheduleInfo(
-            id=job.id,
-            name=job.name,
-            status=status,
-            next_run=next_run
-        ))
+    return Scheduler().list()
 
-    return schedulers
+
+@router.get("/schedule2", summary="后台服务（API_TOKEN）", response_model=List[schemas.ScheduleInfo])
+async def schedule2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询下载器信息 API_TOKEN认证（?token=xxx）
+    """
+    return await schedule()
 
 
 @router.get("/transfer", summary="文件整理统计", response_model=List[int])
-def transfer(days: int = 7, db: Session = Depends(get_db),
-             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def transfer(days: Optional[int] = 7,
+                   db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询文件整理统计信息
     """
-    transfer_stat = TransferHistory.statistic(db, days)
+    transfer_stat = await TransferHistory.async_statistic(db, days)
     return [stat[1] for stat in transfer_stat]
+
+
+@router.get("/cpu", summary="获取当前CPU使用率", response_model=float)
+def cpu(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取当前CPU使用率
+    """
+    return SystemUtils.cpu_usage()
+
+
+@router.get("/cpu2", summary="获取当前CPU使用率（API_TOKEN）", response_model=float)
+def cpu2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    获取当前CPU使用率 API_TOKEN认证（?token=xxx）
+    """
+    return cpu()
+
+
+@router.get("/memory", summary="获取当前内存使用量和使用率", response_model=List[int])
+def memory(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取当前内存使用率
+    """
+    return SystemUtils.memory_usage()
+
+
+@router.get("/memory2", summary="获取当前内存使用量和使用率（API_TOKEN）", response_model=List[int])
+def memory2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    获取当前内存使用率 API_TOKEN认证（?token=xxx）
+    """
+    return memory()
+
+
+@router.get("/network", summary="获取当前网络流量", response_model=List[int])
+def network(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取当前网络流量（上行和下行流量，单位：bytes/s）
+    """
+    return SystemUtils.network_usage()
+
+
+@router.get("/network2", summary="获取当前网络流量（API_TOKEN）", response_model=List[int])
+def network2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    获取当前网络流量 API_TOKEN认证（?token=xxx）
+    """
+    return network()

app/api/endpoints/discover.py

@@ -0,0 +1,130 @@
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.chain.bangumi import BangumiChain
+from app.chain.douban import DoubanChain
+from app.chain.tmdb import TmdbChain
+from app.core.event import eventmanager
+from app.core.security import verify_token
+from app.schemas import DiscoverSourceEventData
+from app.schemas.types import ChainEventType, MediaType
+
+router = APIRouter()
+
+
+@router.get("/source", summary="获取探索数据源", response_model=List[schemas.DiscoverMediaSource])
+def source(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取探索数据源
+    """
+    # 广播事件，请示额外的探索数据源支持
+    event_data = DiscoverSourceEventData()
+    event = eventmanager.send_event(ChainEventType.DiscoverSource, event_data)
+    # 使用事件返回的上下文数据
+    if event and event.event_data:
+        event_data: DiscoverSourceEventData = event.event_data
+        if event_data.extra_sources:
+            return event_data.extra_sources
+    return []
+
+
+@router.get("/bangumi", summary="探索Bangumi", response_model=List[schemas.MediaInfo])
+async def bangumi(type: Optional[int] = 2,
+                  cat: Optional[int] = None,
+                  sort: Optional[str] = 'rank',
+                  year: Optional[str] = None,
+                  page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    探索Bangumi
+    """
+    medias = await BangumiChain().async_discover(type=type, cat=cat, sort=sort, year=year,
+                                                 limit=count, offset=(page - 1) * count)
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
+
+
+@router.get("/douban_movies", summary="探索豆瓣电影", response_model=List[schemas.MediaInfo])
+async def douban_movies(sort: Optional[str] = "R",
+                        tags: Optional[str] = "",
+                        page: Optional[int] = 1,
+                        count: Optional[int] = 30,
+                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣电影信息
+    """
+    movies = await DoubanChain().async_douban_discover(mtype=MediaType.MOVIE,
+                                                       sort=sort, tags=tags, page=page, count=count)
+    return [media.to_dict() for media in movies] if movies else []
+
+
+@router.get("/douban_tvs", summary="探索豆瓣剧集", response_model=List[schemas.MediaInfo])
+async def douban_tvs(sort: Optional[str] = "R",
+                     tags: Optional[str] = "",
+                     page: Optional[int] = 1,
+                     count: Optional[int] = 30,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    tvs = await DoubanChain().async_douban_discover(mtype=MediaType.TV,
+                                                    sort=sort, tags=tags, page=page, count=count)
+    return [media.to_dict() for media in tvs] if tvs else []
+
+
+@router.get("/tmdb_movies", summary="探索TMDB电影", response_model=List[schemas.MediaInfo])
+async def tmdb_movies(sort_by: Optional[str] = "popularity.desc",
+                      with_genres: Optional[str] = "",
+                      with_original_language: Optional[str] = "",
+                      with_keywords: Optional[str] = "",
+                      with_watch_providers: Optional[str] = "",
+                      vote_average: Optional[float] = 0.0,
+                      vote_count: Optional[int] = 0,
+                      release_date: Optional[str] = "",
+                      page: Optional[int] = 1,
+                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB电影信息
+    """
+    movies = await TmdbChain().async_tmdb_discover(mtype=MediaType.MOVIE,
+                                                   sort_by=sort_by,
+                                                   with_genres=with_genres,
+                                                   with_original_language=with_original_language,
+                                                   with_keywords=with_keywords,
+                                                   with_watch_providers=with_watch_providers,
+                                                   vote_average=vote_average,
+                                                   vote_count=vote_count,
+                                                   release_date=release_date,
+                                                   page=page)
+    return [movie.to_dict() for movie in movies] if movies else []
+
+
+@router.get("/tmdb_tvs", summary="探索TMDB剧集", response_model=List[schemas.MediaInfo])
+async def tmdb_tvs(sort_by: Optional[str] = "popularity.desc",
+                   with_genres: Optional[str] = "",
+                   with_original_language: Optional[str] = "",
+                   with_keywords: Optional[str] = "",
+                   with_watch_providers: Optional[str] = "",
+                   vote_average: Optional[float] = 0.0,
+                   vote_count: Optional[int] = 0,
+                   release_date: Optional[str] = "",
+                   page: Optional[int] = 1,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB剧集信息
+    """
+    tvs = await TmdbChain().async_tmdb_discover(mtype=MediaType.TV,
+                                                sort_by=sort_by,
+                                                with_genres=with_genres,
+                                                with_original_language=with_original_language,
+                                                with_keywords=with_keywords,
+                                                with_watch_providers=with_watch_providers,
+                                                vote_average=vote_average,
+                                                vote_count=vote_count,
+                                                release_date=release_date,
+                                                page=page)
+    return [tv.to_dict() for tv in tvs] if tvs else []

app/api/endpoints/douban.py

@@ -1,152 +1,79 @@
-from typing import List, Any
+from typing import Any, List, Optional
 
-from fastapi import APIRouter, Depends, Response
-from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
 
 from app import schemas
 from app.chain.douban import DoubanChain
-from app.core.config import settings
 from app.core.context import MediaInfo
 from app.core.security import verify_token
-from app.db import get_db
 from app.schemas import MediaType
-from app.utils.http import RequestUtils
 
 router = APIRouter()
 
 
-@router.get("/img/{imgurl:path}", summary="豆瓣图片代理")
-def douban_img(imgurl: str) -> Any:
+@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
+async def douban_person(person_id: int,
+                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    豆瓣图片代理
+    根据人物ID查询人物详情
     """
-    if not imgurl:
-        return None
-    response = RequestUtils(headers={
-        'Referer': "https://movie.douban.com/"
-    }, ua=settings.USER_AGENT).get_res(url=imgurl)
-    if response:
-        return Response(content=response.content, media_type="image/jpeg")
-    return None
+    return await DoubanChain().async_person_detail(person_id=person_id)
 
 
-@router.get("/recognize/{doubanid}", summary="豆瓣ID识别", response_model=schemas.Context)
-def recognize_doubanid(doubanid: str,
-                       db: Session = Depends(get_db),
-                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
+async def douban_person_credits(person_id: int,
+                                page: Optional[int] = 1,
+                                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    根据豆瓣ID识别媒体信息
+    根据人物ID查询人物参演作品
     """
-    # 识别媒体信息
-    context = DoubanChain(db).recognize_by_doubanid(doubanid=doubanid)
-    if context:
-        return context.to_dict()
+    medias = await DoubanChain().async_person_credits(person_id=person_id, page=page)
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
+
+
+@router.get("/credits/{doubanid}/{type_name}", summary="豆瓣演员阵容", response_model=List[schemas.MediaPerson])
+async def douban_credits(doubanid: str,
+                         type_name: str,
+                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据豆瓣ID查询演员阵容，type_name: 电影/电视剧
+    """
+    mediatype = MediaType(type_name)
+    if mediatype == MediaType.MOVIE:
+        return await DoubanChain().async_movie_credits(doubanid=doubanid)
+    elif mediatype == MediaType.TV:
+        return await DoubanChain().async_tv_credits(doubanid=doubanid)
+    return []
+
+
+@router.get("/recommend/{doubanid}/{type_name}", summary="豆瓣推荐电影/电视剧", response_model=List[schemas.MediaInfo])
+async def douban_recommend(doubanid: str,
+                           type_name: str,
+                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据豆瓣ID查询推荐电影/电视剧，type_name: 电影/电视剧
+    """
+    mediatype = MediaType(type_name)
+    if mediatype == MediaType.MOVIE:
+        medias = await DoubanChain().async_movie_recommend(doubanid=doubanid)
+    elif mediatype == MediaType.TV:
+        medias = await DoubanChain().async_tv_recommend(doubanid=doubanid)
     else:
-        return schemas.Context()
-
-
-@router.get("/showing", summary="豆瓣正在热映", response_model=List[schemas.MediaInfo])
-def movie_showing(page: int = 1,
-                  count: int = 30,
-                  db: Session = Depends(get_db),
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣正在热映
-    """
-    movies = DoubanChain(db).movie_showing(page=page, count=count)
-    if not movies:
         return []
-    medias = [MediaInfo(douban_info=movie) for movie in movies]
-    return [media.to_dict() for media in medias]
-
-
-@router.get("/movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
-def douban_movies(sort: str = "R",
-                  tags: str = "",
-                  page: int = 1,
-                  count: int = 30,
-                  db: Session = Depends(get_db),
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣电影信息
-    """
-    movies = DoubanChain(db).douban_discover(mtype=MediaType.MOVIE,
-                                             sort=sort, tags=tags, page=page, count=count)
-    if not movies:
-        return []
-    medias = [MediaInfo(douban_info=movie) for movie in movies]
-    return [media.to_dict() for media in medias
-            if media.poster_path
-            and "movie_large.jpg" not in media.poster_path
-            and "tv_normal.png" not in media.poster_path]
-
-
-@router.get("/tvs", summary="豆瓣剧集", response_model=List[schemas.MediaInfo])
-def douban_tvs(sort: str = "R",
-               tags: str = "",
-               page: int = 1,
-               count: int = 30,
-               db: Session = Depends(get_db),
-               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣剧集信息
-    """
-    tvs = DoubanChain(db).douban_discover(mtype=MediaType.TV,
-                                          sort=sort, tags=tags, page=page, count=count)
-    if not tvs:
-        return []
-    medias = [MediaInfo(douban_info=tv) for tv in tvs]
-    return [media.to_dict() for media in medias
-            if media.poster_path
-            and "movie_large.jpg" not in media.poster_path
-            and "tv_normal.jpg" not in media.poster_path
-            and "tv_large.jpg" not in media.poster_path]
-
-
-@router.get("/movie_top250", summary="豆瓣电影TOP250", response_model=List[schemas.MediaInfo])
-def movie_top250(page: int = 1,
-                 count: int = 30,
-                 db: Session = Depends(get_db),
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣剧集信息
-    """
-    movies = DoubanChain(db).movie_top250(page=page, count=count)
-    return [MediaInfo(douban_info=movie).to_dict() for movie in movies]
-
-
-@router.get("/tv_weekly_chinese", summary="豆瓣国产剧集周榜", response_model=List[schemas.MediaInfo])
-def tv_weekly_chinese(page: int = 1,
-                      count: int = 30,
-                      db: Session = Depends(get_db),
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    中国每周剧集口碑榜
-    """
-    tvs = DoubanChain(db).tv_weekly_chinese(page=page, count=count)
-    return [MediaInfo(douban_info=tv).to_dict() for tv in tvs]
-
-
-@router.get("/tv_weekly_global", summary="豆瓣全球剧集周榜", response_model=List[schemas.MediaInfo])
-def tv_weekly_global(page: int = 1,
-                     count: int = 30,
-                     db: Session = Depends(get_db),
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    全球每周剧集口碑榜
-    """
-    tvs = DoubanChain(db).tv_weekly_global(page=page, count=count)
-    return [MediaInfo(douban_info=tv).to_dict() for tv in tvs]
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
 
 
 @router.get("/{doubanid}", summary="查询豆瓣详情", response_model=schemas.MediaInfo)
-def douban_info(doubanid: str,
-                db: Session = Depends(get_db),
-                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def douban_info(doubanid: str,
+                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据豆瓣ID查询豆瓣媒体信息
     """
-    doubaninfo = DoubanChain(db).douban_info(doubanid=doubanid)
+    doubaninfo = await DoubanChain().async_douban_info(doubanid=doubanid)
     if doubaninfo:
         return MediaInfo(douban_info=doubaninfo).to_dict()
     else:

app/api/endpoints/download.py

@@ -1,126 +1,145 @@
-from typing import Any, List
+from typing import Any, List, Annotated, Optional
 
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends, Body
 
 from app import schemas
-from app.chain.douban import DoubanChain
 from app.chain.download import DownloadChain
 from app.chain.media import MediaChain
 from app.core.context import MediaInfo, Context, TorrentInfo
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
-from app.db import get_db
-from app.schemas import NotExistMediaInfo, MediaType
+from app.db.models.user import User
+from app.db.systemconfig_oper import SystemConfigOper
+from app.db.user_oper import get_current_active_user
+from app.schemas.types import SystemConfigKey
 
 router = APIRouter()
 
 
 @router.get("/", summary="正在下载", response_model=List[schemas.DownloadingTorrent])
-def read_downloading(
-        db: Session = Depends(get_db),
+def current(
+        name: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询正在下载的任务
     """
-    return DownloadChain(db).downloading()
+    return DownloadChain().downloading(name)
 
 
-@router.post("/", summary="添加下载", response_model=schemas.Response)
-def add_downloading(
+@router.post("/", summary="添加下载（含媒体信息）", response_model=schemas.Response)
+def download(
         media_in: schemas.MediaInfo,
         torrent_in: schemas.TorrentInfo,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+        downloader: Annotated[str | None, Body()] = None,
+        save_path: Annotated[str | None, Body()] = None,
+        current_user: User = Depends(get_current_active_user)) -> Any:
     """
-    添加下载任务
+    添加下载任务（含媒体信息）
     """
     # 元数据
     metainfo = MetaInfo(title=torrent_in.title, subtitle=torrent_in.description)
     # 媒体信息
     mediainfo = MediaInfo()
-    mediainfo.from_dict(media_in.dict())
+    mediainfo.from_dict(media_in.model_dump())
     # 种子信息
     torrentinfo = TorrentInfo()
-    torrentinfo.from_dict(torrent_in.dict())
+    torrentinfo.from_dict(torrent_in.model_dump())
+    # 手动下载始终使用选择的下载器
+    torrentinfo.site_downloader = downloader
     # 上下文
     context = Context(
         meta_info=metainfo,
         media_info=mediainfo,
         torrent_info=torrentinfo
     )
-    did = DownloadChain(db).download_single(context=context)
-    return schemas.Response(success=True if did else False, data={
+    did = DownloadChain().download_single(context=context, username=current_user.name,
+                                          save_path=save_path, source="Manual")
+    if not did:
+        return schemas.Response(success=False, message="任务添加失败")
+    return schemas.Response(success=True, data={
         "download_id": did
     })
 
 
-@router.post("/notexists", summary="查询缺失媒体信息", response_model=List[NotExistMediaInfo])
-def exists(media_in: schemas.MediaInfo,
-           db: Session = Depends(get_db),
-           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.post("/add", summary="添加下载（不含媒体信息）", response_model=schemas.Response)
+def add(
+        torrent_in: schemas.TorrentInfo,
+        tmdbid: Annotated[int | None, Body()] = None,
+        doubanid: Annotated[str | None, Body()] = None,
+        downloader: Annotated[str | None, Body()] = None,
+        # 保存路径, 支持<storage>:<path>, 如rclone:/MP, smb:/server/share/Movies等
+        save_path: Annotated[str | None, Body()] = None,
+        current_user: User = Depends(get_current_active_user)) -> Any:
     """
-    查询缺失媒体信息
+    添加下载任务（不含媒体信息）
     """
+    # 元数据
+    metainfo = MetaInfo(title=torrent_in.title, subtitle=torrent_in.description)
     # 媒体信息
-    mediainfo = MediaInfo()
-    meta = MetaInfo(title=media_in.title)
-    if media_in.tmdb_id:
-        mediainfo.from_dict(media_in.dict())
-    elif media_in.douban_id:
-        context = DoubanChain(db).recognize_by_doubanid(doubanid=media_in.douban_id)
-        if context:
-            mediainfo = context.media_info
-            meta = context.meta_info
-    else:
-        context = MediaChain(db).recognize_by_title(title=f"{media_in.title} {media_in.year}")
-        if context:
-            mediainfo = context.media_info
-            meta = context.meta_info
-    # 查询缺失信息
-    if not mediainfo or not mediainfo.tmdb_id:
-        raise HTTPException(status_code=404, detail="媒体信息不存在")
-    exist_flag, no_exists = DownloadChain(db).get_no_exists_info(meta=meta, mediainfo=mediainfo)
-    if mediainfo.type == MediaType.MOVIE:
-        # 电影已存在时返回空列表，存在时返回空对像列表
-        return [] if exist_flag else [NotExistMediaInfo()]
-    elif no_exists and no_exists.get(mediainfo.tmdb_id):
-        # 电视剧返回缺失的剧集
-        return list(no_exists.get(mediainfo.tmdb_id).values())
-    return []
+    mediainfo = MediaChain().select_recognize_source(
+                    log_name=torrent_in.title,
+                    log_context=torrent_in.title,
+                    native_fn=lambda: MediaChain().recognize_media(meta=metainfo, tmdbid=tmdbid, doubanid=doubanid),
+                    plugin_fn=lambda: MediaChain().recognize_help(title=torrent_in.title, org_meta=metainfo)
+                )
+    if not mediainfo:
+        return schemas.Response(success=False, message="无法识别媒体信息")
+    # 种子信息
+    torrentinfo = TorrentInfo()
+    torrentinfo.from_dict(torrent_in.model_dump())
+    # 上下文
+    context = Context(
+        meta_info=metainfo,
+        media_info=mediainfo,
+        torrent_info=torrentinfo
+    )
+
+    did = DownloadChain().download_single(context=context, username=current_user.name,
+                                          downloader=downloader, save_path=save_path, source="Manual")
+    if not did:
+        return schemas.Response(success=False, message="任务添加失败")
+    return schemas.Response(success=True, data={
+        "download_id": did
+    })
 
 
 @router.get("/start/{hashString}", summary="开始任务", response_model=schemas.Response)
-def start_downloading(
-        hashString: str,
-        db: Session = Depends(get_db),
+def start(
+        hashString: str, name: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     开如下载任务
     """
-    ret = DownloadChain(db).set_downloading(hashString, "start")
+    ret = DownloadChain().set_downloading(hashString, "start", name=name)
     return schemas.Response(success=True if ret else False)
 
 
 @router.get("/stop/{hashString}", summary="暂停任务", response_model=schemas.Response)
-def stop_downloading(
-        hashString: str,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def stop(hashString: str, name: Optional[str] = None,
+         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    控制下载任务
+    暂停下载任务
     """
-    ret = DownloadChain(db).set_downloading(hashString, "stop")
+    ret = DownloadChain().set_downloading(hashString, "stop", name=name)
     return schemas.Response(success=True if ret else False)
 
 
+@router.get("/clients", summary="查询可用下载器", response_model=List[dict])
+async def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询可用下载器
+    """
+    downloaders: List[dict] = SystemConfigOper().get(SystemConfigKey.Downloaders)
+    if downloaders:
+        return [{"name": d.get("name"), "type": d.get("type")} for d in downloaders if d.get("enabled")]
+    return []
+
+
 @router.delete("/{hashString}", summary="删除下载任务", response_model=schemas.Response)
-def remove_downloading(
-        hashString: str,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def delete(hashString: str, name: Optional[str] = None,
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    控制下载任务
+    删除下载任务
     """
-    ret = DownloadChain(db).remove_downloading(hashString)
+    ret = DownloadChain().remove_downloading(hashString, name=name)
     return schemas.Response(success=True if ret else False)

app/api/endpoints/filebrowser.py

@@ -1,176 +0,0 @@
-import shutil
-from pathlib import Path
-from typing import Any, List
-
-from fastapi import APIRouter, Depends
-from starlette.responses import FileResponse, Response
-
-from app import schemas
-from app.core.config import settings
-from app.core.security import verify_token
-from app.log import logger
-from app.utils.system import SystemUtils
-
-router = APIRouter()
-
-IMAGE_TYPES = [".jpg", ".png", ".gif", ".bmp", ".jpeg", ".webp"]
-
-
-@router.get("/list", summary="所有插件", response_model=List[schemas.FileItem])
-def list_path(path: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询当前目录下所有目录和文件
-    """
-    # 返回结果
-    ret_items = []
-    if not path or path == "/":
-        if SystemUtils.is_windows():
-            partitions = SystemUtils.get_windows_drives() or ["C:/"]
-            for partition in partitions:
-                ret_items.append(schemas.FileItem(
-                    type="dir",
-                    path=partition + "/",
-                    name=partition,
-                    basename=partition
-                ))
-            return ret_items
-        else:
-            path = "/"
-    else:
-        if not SystemUtils.is_windows() and not path.startswith("/"):
-            path = "/" + path
-
-    # 遍历目录
-    path_obj = Path(path)
-    if not path_obj.exists():
-        logger.error(f"目录不存在：{path}")
-        return []
-
-    # 如果是文件
-    if path_obj.is_file():
-        ret_items.append(schemas.FileItem(
-            type="file",
-            path=str(path_obj).replace("\\", "/"),
-            name=path_obj.name,
-            basename=path_obj.stem,
-            extension=path_obj.suffix[1:],
-            size=path_obj.stat().st_size,
-        ))
-        return ret_items
-
-    # 扁历所有目录
-    for item in SystemUtils.list_sub_directory(path_obj):
-        ret_items.append(schemas.FileItem(
-            type="dir",
-            path=str(item).replace("\\", "/") + "/",
-            name=item.name,
-            basename=item.stem,
-        ))
-
-    # 遍历所有文件，不含子目录
-    for item in SystemUtils.list_sub_files(path_obj,
-                                           settings.RMT_MEDIAEXT
-                                           + settings.RMT_SUBEXT
-                                           + IMAGE_TYPES
-                                           + [".nfo"]):
-        ret_items.append(schemas.FileItem(
-            type="file",
-            path=str(item).replace("\\", "/"),
-            name=item.name,
-            basename=item.stem,
-            extension=item.suffix[1:],
-            size=item.stat().st_size,
-        ))
-
-    return ret_items
-
-
-@router.get("/mkdir", summary="创建目录", response_model=schemas.Response)
-def mkdir(path: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    创建目录
-    """
-    if not path:
-        return schemas.Response(success=False)
-    path_obj = Path(path)
-    if path_obj.exists():
-        return schemas.Response(success=False)
-    path_obj.mkdir(parents=True, exist_ok=True)
-    return schemas.Response(success=True)
-
-
-@router.get("/delete", summary="删除文件或目录", response_model=schemas.Response)
-def delete(path: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    删除文件或目录
-    """
-    if not path:
-        return schemas.Response(success=False)
-    path_obj = Path(path)
-    if not path_obj.exists():
-        return schemas.Response(success=True)
-    if path_obj.is_file():
-        path_obj.unlink()
-    else:
-        shutil.rmtree(path_obj, ignore_errors=True)
-    return schemas.Response(success=True)
-
-
-@router.get("/download", summary="下载文件或目录")
-def download(path: str, token: str) -> Any:
-    """
-    下载文件或目录
-    """
-    if not path:
-        return schemas.Response(success=False)
-    # 认证token
-    if not verify_token(token):
-        return None
-    path_obj = Path(path)
-    if not path_obj.exists():
-        return schemas.Response(success=False)
-    if path_obj.is_file():
-        # 做为文件流式下载
-        return FileResponse(path_obj)
-    else:
-        # 做为压缩包下载
-        shutil.make_archive(base_name=path_obj.stem, format="zip", root_dir=path_obj)
-        reponse = Response(content=path_obj.read_bytes(), media_type="application/zip")
-        # 删除压缩包
-        Path(f"{path_obj.stem}.zip").unlink()
-        return reponse
-
-
-@router.get("/rename", summary="重命名文件或目录", response_model=schemas.Response)
-def rename(path: str, new_name: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    重命名文件或目录
-    """
-    if not path or not new_name:
-        return schemas.Response(success=False)
-    path_obj = Path(path)
-    if not path_obj.exists():
-        return schemas.Response(success=False)
-    path_obj.rename(path_obj.parent / new_name)
-    return schemas.Response(success=True)
-
-
-@router.get("/image", summary="读取图片")
-def image(path: str, token: str) -> Any:
-    """
-    读取图片
-    """
-    if not path:
-        return None
-    # 认证token
-    if not verify_token(token):
-        return None
-    path_obj = Path(path)
-    if not path_obj.exists():
-        return None
-    if not path_obj.is_file():
-        return None
-    # 判断是否图片文件
-    if path_obj.suffix.lower() not in IMAGE_TYPES:
-        return None
-    return Response(content=path_obj.read_bytes(), media_type="image/jpeg")

app/api/endpoints/history.py

@@ -1,98 +1,124 @@
-from pathlib import Path
-from typing import List, Any
+from typing import List, Any, Optional
 
+import jieba
 from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
+from pathlib import Path
 
 from app import schemas
-from app.chain.transfer import TransferChain
+from app.chain.storage import StorageChain
+from app.core.event import eventmanager
 from app.core.security import verify_token
-from app.db import get_db
-from app.db.models.downloadhistory import DownloadHistory
+from app.db import get_async_db, get_db
+from app.db.models import User
+from app.db.models.downloadhistory import DownloadHistory, DownloadFiles
 from app.db.models.transferhistory import TransferHistory
-from app.schemas import MediaType
+from app.db.user_oper import get_current_active_superuser_async, get_current_active_superuser
+from app.schemas.types import EventType
 
 router = APIRouter()
 
 
 @router.get("/download", summary="查询下载历史记录", response_model=List[schemas.DownloadHistory])
-def download_history(page: int = 1,
-                     count: int = 30,
-                     db: Session = Depends(get_db),
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def download_history(page: Optional[int] = 1,
+                           count: Optional[int] = 30,
+                           db: AsyncSession = Depends(get_async_db),
+                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询下载历史记录
     """
-    return DownloadHistory.list_by_page(db, page, count)
+    return await DownloadHistory.async_list_by_page(db, page, count)
 
 
 @router.delete("/download", summary="删除下载历史记录", response_model=schemas.Response)
-def delete_download_history(history_in: schemas.DownloadHistory,
-                            db: Session = Depends(get_db),
-                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+async def delete_download_history(history_in: schemas.DownloadHistory,
+                                  db: AsyncSession = Depends(get_async_db),
+                                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     删除下载历史记录
     """
-    DownloadHistory.delete(db, history_in.id)
+    await DownloadHistory.async_delete(db, history_in.id)
     return schemas.Response(success=True)
 
 
-@router.get("/transfer", summary="查询转移历史记录", response_model=schemas.Response)
-def transfer_history(title: str = None,
-                     page: int = 1,
-                     count: int = 30,
-                     db: Session = Depends(get_db),
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/transfer", summary="查询整理记录", response_model=schemas.Response)
+async def transfer_history(title: Optional[str] = None,
+                           page: Optional[int] = 1,
+                           count: Optional[int] = 30,
+                           status: Optional[bool] = None,
+                           db: AsyncSession = Depends(get_async_db),
+                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    查询转移历史记录
+    查询整理记录
     """
+    if title == "失败":
+        title = None
+        status = False
+    elif title == "成功":
+        title = None
+        status = True
+
     if title:
-        total = TransferHistory.count_by_title(db, title)
-        result = TransferHistory.list_by_title(db, title, page, count)
+        words = jieba.cut(title, HMM=False)
+        title = "%".join(words)
+        total = await TransferHistory.async_count_by_title(db, title=title, status=status)
+        result = await TransferHistory.async_list_by_title(db, title=title, page=page,
+                                                           count=count, status=status)
     else:
-        result = TransferHistory.list_by_page(db, page, count)
-        total = TransferHistory.count(db)
+        result = await TransferHistory.async_list_by_page(db, page=page, count=count, status=status)
+        total = await TransferHistory.async_count(db, status=status)
 
     return schemas.Response(success=True,
                             data={
-                                "list": result,
+                                "list": [item.to_dict() for item in result],
                                 "total": total,
                             })
 
 
-@router.delete("/transfer", summary="删除转移历史记录", response_model=schemas.Response)
+@router.delete("/transfer", summary="删除整理记录", response_model=schemas.Response)
 def delete_transfer_history(history_in: schemas.TransferHistory,
-                            delete_file: bool = False,
+                            deletesrc: Optional[bool] = False,
+                            deletedest: Optional[bool] = False,
                             db: Session = Depends(get_db),
-                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+                            _: User = Depends(get_current_active_superuser)) -> Any:
     """
-    删除转移历史记录
+    删除整理记录
     """
-    # 触发删除事件
-    if delete_file:
-        history = TransferHistory.get(db, history_in.id)
-        if not history:
-            return schemas.Response(success=False, msg="记录不存在")
-        # 册除文件
-        if history.dest:
-            TransferChain(db).delete_files(Path(history.dest))
+    history: TransferHistory = TransferHistory.get(db, history_in.id)
+    if not history:
+        return schemas.Response(success=False, message="记录不存在")
+    # 册除媒体库文件
+    if deletedest and history.dest_fileitem:
+        dest_fileitem = schemas.FileItem(**history.dest_fileitem)
+        StorageChain().delete_media_file(dest_fileitem)
+
+    # 删除源文件
+    if deletesrc and history.src_fileitem:
+        src_fileitem = schemas.FileItem(**history.src_fileitem)
+        state = StorageChain().delete_media_file(src_fileitem)
+        if not state:
+            return schemas.Response(success=False, message=f"{src_fileitem.path} 删除失败")
+        # 删除下载记录中关联的文件
+        DownloadFiles.delete_by_fullpath(db, Path(src_fileitem.path).as_posix())
+        # 发送事件
+        eventmanager.send_event(
+            EventType.DownloadFileDeleted,
+            {
+                "src": history.src,
+                "hash": history.download_hash
+            }
+        )
     # 删除记录
     TransferHistory.delete(db, history_in.id)
     return schemas.Response(success=True)
 
 
-@router.post("/transfer", summary="历史记录重新转移", response_model=schemas.Response)
-def redo_transfer_history(history_in: schemas.TransferHistory,
-                          mtype: str,
-                          new_tmdbid: int,
-                          db: Session = Depends(get_db),
-                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/empty/transfer", summary="清空整理记录", response_model=schemas.Response)
+async def empty_transfer_history(db: AsyncSession = Depends(get_async_db),
+                                 _: User = Depends(get_current_active_superuser_async)) -> Any:
     """
-    历史记录重新转移
+    清空整理记录
     """
-    state, errmsg = TransferChain(db).re_transfer(logid=history_in.id,
-                                                  mtype=MediaType(mtype), tmdbid=new_tmdbid)
-    if state:
-        return schemas.Response(success=True)
-    else:
-        return schemas.Response(success=False, message=errmsg)
+    await TransferHistory.async_truncate(db)
+    return schemas.Response(success=True)

app/api/endpoints/login.py

@@ -1,100 +1,83 @@
-import random
 from datetime import timedelta
-from typing import Any
+from typing import Any, List, Annotated
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, Form, HTTPException
 from fastapi.security import OAuth2PasswordRequestForm
-from sqlalchemy.orm import Session
 
 from app import schemas
-from app.chain.tmdb import TmdbChain
 from app.chain.user import UserChain
 from app.core import security
 from app.core.config import settings
-from app.core.security import get_password_hash
-from app.db import get_db
-from app.db.models.user import User
-from app.log import logger
-from app.utils.http import RequestUtils
+from app.db.systemconfig_oper import SystemConfigOper
+from app.helper.sites import SitesHelper  # noqa
+from app.helper.image import WallpaperHelper
+from app.schemas.types import SystemConfigKey
 
 router = APIRouter()
 
 
 @router.post("/access-token", summary="获取token", response_model=schemas.Token)
-async def login_access_token(
-        db: Session = Depends(get_db), form_data: OAuth2PasswordRequestForm = Depends()
+def login_access_token(
+        form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
+        otp_password: Annotated[str | None, Form()] = None
 ) -> Any:
     """
     获取认证Token
     """
-    # 检查数据库
-    user = User.authenticate(
-        db=db,
-        name=form_data.username,
-        password=form_data.password
-    )
-    if not user:
-        # 请求协助认证
-        logger.warn("登录用户本地不匹配，尝试辅助认证 ...")
-        token = UserChain(db).user_authenticate(form_data.username, form_data.password)
-        if not token:
-            raise HTTPException(status_code=401, detail="用户名或密码不正确")
-        else:
-            logger.info(f"辅助认证成功，用户信息: {token}")
-            # 加入用户信息表
-            user = User.get_by_name(db=db, name=form_data.username)
-            if not user:
-                logger.info(f"用户不存在，创建用户: {form_data.username}")
-                user = User(name=form_data.username, is_active=True,
-                            is_superuser=False, hashed_password=get_password_hash(token))
-                user.create(db)
-    elif not user.is_active:
-        raise HTTPException(status_code=403, detail="用户未启用")
-    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    success, user_or_message = UserChain().user_authenticate(username=form_data.username,
+                                                             password=form_data.password,
+                                                             mfa_code=otp_password)
+
+    if not success:
+        # 如果是需要MFA验证，返回特殊标识
+        if user_or_message == "MFA_REQUIRED":
+            raise HTTPException(
+                status_code=401,
+                detail="需要双重验证，请提供验证码或使用通行密钥",
+                headers={"X-MFA-Required": "true"}
+            )
+        raise HTTPException(status_code=401, detail="用户名或密码错误")
+
+    # 用户等级
+    level = SitesHelper().auth_level
+    # 是否显示配置向导
+    show_wizard = not SystemConfigOper().get(SystemConfigKey.SetupWizardState) and not settings.ADVANCED_MODE
     return schemas.Token(
         access_token=security.create_access_token(
-            user.id, expires_delta=access_token_expires
+            userid=user_or_message.id,
+            username=user_or_message.name,
+            super_user=user_or_message.is_superuser,
+            expires_delta=timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES),
+            level=level
         ),
         token_type="bearer",
+        super_user=user_or_message.is_superuser,
+        user_id=user_or_message.id,
+        user_name=user_or_message.name,
+        avatar=user_or_message.avatar,
+        level=level,
+        permissions=user_or_message.permissions or {},
+        wizard=show_wizard
     )
 
 
-@router.get("/bing", summary="Bing每日壁纸", response_model=schemas.Response)
-def bing_wallpaper() -> Any:
+@router.get("/wallpaper", summary="登录页面电影海报", response_model=schemas.Response)
+def wallpaper() -> Any:
     """
-    获取Bing每日壁纸
+    获取登录页面电影海报
     """
-    url = "https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1"
-    try:
-        resp = RequestUtils(timeout=5).get_res(url)
-    except Exception as err:
-        print(str(err))
-        return schemas.Response(success=False)
-    if resp and resp.status_code == 200:
-        try:
-            result = resp.json()
-            if isinstance(result, dict):
-                for image in result.get('images') or []:
-                    return schemas.Response(success=False,
-                                            message=f"https://cn.bing.com{image.get('url')}" if 'url' in image else '')
-        except Exception as err:
-            print(str(err))
+    url = WallpaperHelper().get_wallpaper()
+    if url:
+        return schemas.Response(
+            success=True,
+            message=url
+        )
     return schemas.Response(success=False)
 
 
-@router.get("/tmdb", summary="TMDB电影海报", response_model=schemas.Response)
-def tmdb_wallpaper(db: Session = Depends(get_db)) -> Any:
+@router.get("/wallpapers", summary="登录页面电影海报列表", response_model=List[str])
+def wallpapers() -> Any:
     """
-    获取TMDB电影海报
+    获取登录页面电影海报
     """
-    infos = TmdbChain(db).tmdb_trending()
-    if infos:
-        # 随机一个电影
-        while True:
-            info = random.choice(infos)
-            if info and info.get("backdrop_path"):
-                return schemas.Response(
-                    success=True,
-                    message=f"https://image.tmdb.org/t/p/original{info.get('backdrop_path')}"
-                )
-    return schemas.Response(success=False)
+    return WallpaperHelper().get_wallpapers()