报错文案映射与 AI 归纳 + 上传限流换号 + Skills 批量删除

后台报错文案
- 新增 error_message_service：按关键词子串（任一命中 OR、不区分大小写）把上游原始报错
映射成管理员配置的大白话，只影响前台展示，原始报错仍进后台日志。
- 未命中时记入「未配置报错」待办，并在列表里附候选关键词，便于一键建规则。
- 新增 POST /api/error-messages/summarize：粘贴报错即可让模型归纳出
「关键词 + 大白话」，模型不可用时退化为本地正则抽取。
- 提示词写入本项目上下文：匹配为任一命中语义、上游报文格式
`{接口路径} failed: status={状态码}, body={...}`、路径须带区分步骤片段、
禁止 file_id/uuid 等易变片段，避免归纳出过宽规则（如裸 /backend-api/files 会吞掉 429 限流）。
- 关键词清洗：新增 _sanitize_keyword / _strip_volatile_path / _GENERIC_TOKENS，
剔除 JSON 语法碎片（引号、花括号、冒号）与 error_code 等通用字段名。
- 三类报错出口统一走映射：协议层 error_response、生图任务、可编辑文件任务。
- 前端设置页新增「报错文案」卡片：粘贴框 + AI 归纳按钮 + 内联结果卡片
（关键词/大白话就地可改、可就地保存）、规则列表、未配置报错列表。
- 修复「点添加规则没反应」：store 拆成 coerce（编辑态，保留空行）与
normalize（保存态，丢弃无效项）两档归一化，编辑态不再误丢刚加的空行。
- 修复「归纳结果看不见」：高亮延长到 6 秒并加绿底/绿边/徽标，结果面板就地可操作。

生图上传限流换号
- 新增 is_account_scoped_upload_error：识别 upload_protection_limit_exceeded /
429 上传类失败。这类限制是单账号配额，换号几乎必成，不再当作终态失败。
- 号池因上传限流被逐个排除到池空时，给出准确原因而非笼统的「生成失败」。
- 被限流换掉的账号不触发账号清理（只加入本轮排除集合并归还并发槽）。

Skills
- 新增 POST /api/admin/skills/batch-delete，一次删多个；未知 id 只回报不致命。

测试
- 新增 test/test_error_message_service.py（覆盖真实 500/429 报错闭环、路径截断、
通用词过滤、500 与 429 规则正交、提示词含项目上下文）。
- 新增 test/test_upload_throttle_failover.py（上传限流换号与号池耗尽提示）。

api/skills.py

@@ -87,6 +87,10 @@ class SkillFavoriteRequest(BaseModel):
     favorite: bool = True
 
 
+class SkillBatchDeleteRequest(BaseModel):
+    ids: list[str] = Field(default_factory=list)
+
+
 class SkillPresentationRequest(BaseModel):
     display: dict[str, Any] | None = None
     assets: list[dict[str, Any]] | None = None
@@ -667,6 +671,30 @@ def create_router() -> APIRouter:
             raise HTTPException(status_code=400, detail=str(exc)) from exc
         return {"skill": skill, "items": await run_in_threadpool(skill_service.list)}
 
+    # Registered before the DELETE /{skill_id} handler to keep the literal path
+    # explicit; POST has no {skill_id} route but this documents the intent.
+    @router.post("/api/admin/skills/batch-delete")
+    async def batch_delete_skills(body: SkillBatchDeleteRequest, authorization: str | None = Header(default=None)):
+        """Delete several Skills in one call; unknown ids are reported, not fatal."""
+        require_admin(authorization)
+        deleted: list[str] = []
+        missing: list[str] = []
+        for raw_id in body.ids:
+            skill_id = str(raw_id or "").strip()
+            if not skill_id:
+                continue
+            try:
+                await run_in_threadpool(skill_service.delete, skill_id)
+                deleted.append(skill_id)
+            except SkillInstallError as exc:
+                logger.warning("Batch delete skipped skill %s: %s", skill_id, exc)
+                missing.append(skill_id)
+        return {
+            "deleted": deleted,
+            "missing": missing,
+            "items": await run_in_threadpool(skill_service.list),
+        }
+
     @router.delete("/api/admin/skills/{skill_id}")
     async def delete_skill(skill_id: str, authorization: str | None = Header(default=None)):
         require_admin(authorization)

api/system.py

@@ -8,18 +8,25 @@ import httpx
 from fastapi import APIRouter, Header, HTTPException, Query, Request
 from fastapi.concurrency import run_in_threadpool
 from fastapi.responses import HTMLResponse, Response, StreamingResponse
-from pydantic import BaseModel, ConfigDict
+from pydantic import BaseModel, ConfigDict, Field
 
 from api.support import require_admin, require_identity, resolve_image_base_url
 from api.image_inputs import _download_image_url
 from services.backup_service import BackupError, backup_service
 from services.config import config
 from services.content_filter import preview_local_review
+from services.error_message_service import (
+    ERROR_SUMMARY_SYSTEM_PROMPT,
+    error_message_service,
+    extract_keyword_candidates,
+    parse_ai_suggestion,
+)
+from services.log_service import LoggedCall, log_service
+from services.protocol import openai_v1_chat_complete
 from services.auth_service import auth_service
 from services.image_service import delete_images, download_images_zip, get_image_download_response, get_image_response, get_thumbnail_response, list_images
 from services.image_storage_service import ImageStorageError, image_storage_service
 from services.image_tags_service import delete_tag, get_all_tags, set_tags
-from services.log_service import log_service
 from services.proxy_service import proxy_settings, test_clearance, test_proxy
 from services.pool_pricing_service import pool_pricing_service
 from services.third_party_image_service import third_party_image_service
@@ -42,6 +49,18 @@ class SettingsUpdateRequest(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
+class UnconfiguredErrorClearRequest(BaseModel):
+    """清空「未配置报错」待办；不传 fingerprints 表示全部清空。"""
+
+    fingerprints: list[str] = Field(default_factory=list)
+
+
+class ErrorSummarizeRequest(BaseModel):
+    """把一段报错原文交给模型归纳成「关键词 + 大白话」。"""
+
+    text: str = Field(..., min_length=1, max_length=8000)
+
+
 class ContentReviewPreviewRequest(BaseModel):
     text: str = ""
     sensitive_words: list[str] | None = None
@@ -469,6 +488,59 @@ def create_router(app_version: str) -> APIRouter:
         require_admin(authorization)
         return log_service.delete(body.ids)
 
+    @router.get("/api/error-messages/unconfigured")
+    async def get_unconfigured_errors(authorization: str | None = Header(default=None)):
+        """前台撞上但还没配文案的报错，供管理员照着补规则。"""
+        require_admin(authorization)
+        return {"items": await run_in_threadpool(error_message_service.list_unconfigured)}
+
+    @router.post("/api/error-messages/unconfigured/clear")
+    async def clear_unconfigured_errors(body: UnconfiguredErrorClearRequest, authorization: str | None = Header(default=None)):
+        require_admin(authorization)
+        removed = await run_in_threadpool(error_message_service.clear_unconfigured, body.fingerprints or None)
+        return {"removed": removed, "items": await run_in_threadpool(error_message_service.list_unconfigured)}
+
+    @router.post("/api/error-messages/summarize")
+    async def summarize_error_message(body: ErrorSummarizeRequest, authorization: str | None = Header(default=None)):
+        """管理员粘贴一条报错，让模型归纳出可用的规则（关键词 + 大白话）。
+
+        **永不硬失败**：模型不可用 / 超时 / 返回的不是 JSON / 返回了原文里不存在的
+        关键词，都会退化成「本地抽取候选关键词」，保证这个按钮总有东西可用。
+        """
+        identity = require_admin(authorization)
+        raw = body.text.strip()
+        local_keywords = await run_in_threadpool(extract_keyword_candidates, raw)
+        local_result = {"keywords": local_keywords, "display": "", "source": "local"}
+
+        model = (config.error_message_ai_model or "").strip() or config.default_upstream_model_name
+        payload = {
+            "model": model,
+            "stream": False,
+            "messages": [
+                {"role": "system", "content": ERROR_SUMMARY_SYSTEM_PROMPT},
+                {"role": "user", "content": raw},
+            ],
+        }
+        call = LoggedCall(identity, "/api/error-messages/summarize", model, "报错文案归纳", request_text=raw[:200])
+        try:
+            result = await call.run(openai_v1_chat_complete.handle, payload, identity)
+        except Exception as exc:
+            return {**local_result, "reason": str(exc)[:300]}
+
+        from api.ai import _chat_completion_text
+
+        answer = _chat_completion_text(result) if isinstance(result, dict) else ""
+        suggestion = await run_in_threadpool(parse_ai_suggestion, answer, raw=raw)
+        if not suggestion.get("keywords") and not suggestion.get("display"):
+            return {**local_result, "reason": "模型未返回可解析的 JSON"}
+        # 模型漏了关键词时，用本地抽取的结果补齐，别让这一行是空的。
+        return {
+            "keywords": suggestion.get("keywords") or local_keywords,
+            "display": suggestion.get("display") or "",
+            "source": "ai",
+            "model": model,
+        }
+
     @router.post("/api/proxy/test")
     async def test_proxy_endpoint(body: ProxyTestRequest, authorization: str | None = Header(default=None)):
         require_admin(authorization)

services/config.py

@@ -235,6 +235,9 @@ SHARED_SETTINGS_KEYS = (
     "product_visual_agent_model",
     "normal_user_pool_pricing",
     "normal_user_third_party_image_pricing",
+    "error_message_rules",
+    "error_message_fallback_enabled",
+    "error_message_ai_model",
 )
 SHARED_SETTINGS_CACHE_SECONDS = 10.0
 
@@ -833,6 +836,17 @@ def _normalize_checkin_content(value: object, fallback: object = None) -> dict[s
     return normalized
 
 
+def _normalize_error_message_rules(value: object) -> list[dict[str, object]]:
+    """归一化前台报错文案映射规则。
+
+    真正的校验逻辑在 error_message_service.normalize_rules；此处延迟导入，
+    因为该模块会反向读取 config，导入期不能互相依赖。
+    """
+    from services.error_message_service import normalize_rules
+
+    return normalize_rules(value)
+
+
 def _normalize_shared_settings(value: object, fallback: dict[str, object] | None = None) -> dict[str, object]:
     source = value if isinstance(value, dict) else {}
     fallback = fallback or {}
@@ -986,6 +1000,20 @@ def _normalize_shared_settings(value: object, fallback: dict[str, object] | None
             if isinstance(third_party_source, dict)
             else fallback.get("normal_user_third_party_image_pricing", DEFAULT_NORMAL_USER_THIRD_PARTY_IMAGE_PRICING)
         ),
+        # 报错文案映射：管理员配置「关键词 -> 大白话」，只影响前台展示，
+        # 后台日志保留原始报错。规则归一化逻辑放在 error_message_service，
+        # 这里延迟导入以避免 config 与 service 的循环依赖。
+        "error_message_rules": _normalize_error_message_rules(
+            source.get("error_message_rules", fallback.get("error_message_rules"))
+        ),
+        "error_message_fallback_enabled": _normalize_bool(
+            source.get("error_message_fallback_enabled"),
+            _normalize_bool(fallback.get("error_message_fallback_enabled"), False),
+        ),
+        # 「AI 归纳」用的模型名；留空表示走池子默认文本模型。
+        "error_message_ai_model": str(
+            source.get("error_message_ai_model", fallback.get("error_message_ai_model", "")) or ""
+        ).strip(),
     }
 
 
@@ -1287,6 +1315,21 @@ class ConfigStore:
         """签到赠送积分的可用天数；0 表示永久有效（发放进基础积分池）。"""
         return min(3650, max(0, int(self._load_shared_settings().get("checkin_credit_valid_days") or 0)))
 
+    @property
+    def error_message_rules(self) -> list[dict[str, object]]:
+        """前台报错文案替换规则（关键词 -> 大白话）。"""
+        return _normalize_error_message_rules(self._load_shared_settings().get("error_message_rules"))
+
+    @property
+    def error_message_fallback_enabled(self) -> bool:
+        """未命中规则时是否强制隐藏原始报错（默认关闭，即照原样显示）。"""
+        return _normalize_bool(self._load_shared_settings().get("error_message_fallback_enabled"), False)
+
+    @property
+    def error_message_ai_model(self) -> str:
+        """「AI 归纳」使用的模型名；空串表示用池子默认文本模型。"""
+        return str(self._load_shared_settings().get("error_message_ai_model") or "").strip()
+
     @property
     def checkin_content(self) -> dict[str, str]:
         return _normalize_checkin_content(self.data.get("checkin_content"))
@@ -1590,6 +1633,9 @@ class ConfigStore:
         data["checkin_invite_reward"] = self.checkin_invite_reward
         data["checkin_credit_valid_days"] = self.checkin_credit_valid_days
         data["checkin_content"] = self.checkin_content
+        data["error_message_rules"] = self.error_message_rules
+        data["error_message_fallback_enabled"] = self.error_message_fallback_enabled
+        data["error_message_ai_model"] = self.error_message_ai_model
         data["internal_image_model_daily_limits"] = self.internal_image_model_daily_limits
         data["wechat_login_enabled"] = self.wechat_login_enabled
         data["wechat_auto_register_enabled"] = self.wechat_auto_register_enabled

services/editable_file_task_service.py

@@ -11,6 +11,7 @@ from urllib.parse import quote
 from services.account_service import account_service
 from services.config import DATA_DIR
 from services.content_filter import request_text
+from services.error_message_service import error_message_service
 from services.log_service import LOG_TYPE_CALL, log_service
 from services.openai_backend_api import EDITABLE_FILE_MODEL, OpenAIBackendAPI
 from utils.helper import new_uuid
@@ -81,7 +82,11 @@ def _public_task(task: dict[str, Any]) -> dict[str, Any]:
     if task.get("result"):
         item["result"] = task["result"]
     if task.get("error"):
-        item["error"] = sanitize_sensitive_text(task["error"])
+        # 与生图任务一致：前台只给大白话，原始报错留在后台日志里。
+        item["error"] = error_message_service.translate(
+            sanitize_sensitive_text(task["error"]),
+            channel="editable_file_task",
+        )
     return item
 
 

services/error_message_service.py

@@ -0,0 +1,488 @@
+"""把上游/后端的技术报错翻译成普通用户看得懂的大白话。
+
+设计要点：
+- 规则由管理员在后台配置，形如「关键词列表 -> 展示文案」；命中任意关键词即替换。
+- **只影响前台展示**：后台日志（LogService）始终保留原始报错，方便排查。
+- 未命中任何规则时保留原始报错，同时把这条「未配置报错」记下来，
+  后台会看到一个待办列表，照着补规则即可 —— 规则库能自我完善。
+"""
+from __future__ import annotations
+
+import json
+import re
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+from services.config import DATA_DIR
+
+
+# 未配置报错的收集文件。与业务数据放在一起，随持久卷保留。
+UNCONFIGURED_ERRORS_FILE = DATA_DIR / "error-message-unconfigured.json"
+
+# 同一个报错模板最多保留多少条样本；超出后只累加计数，避免文件无限膨胀。
+_MAX_UNCONFIGURED_ENTRIES = 200
+# 单条样本的原文上限，防止把整段 HTML/JSON 塞进去。
+_MAX_SAMPLE_CHARS = 600
+# 关键词的最短长度：太短的关键词（如 "a"）会误伤一大片正常报错。
+_MIN_KEYWORD_CHARS = 2
+# 归一化后用于去重的指纹长度。
+_FINGERPRINT_CHARS = 16
+
+
+class ErrorMessageRuleError(ValueError):
+    """规则校验失败。"""
+
+
+def _clean(value: object) -> str:
+    return str(value or "").strip()
+
+
+def _normalize_keywords(value: object) -> list[str]:
+    """把关键词字段归一化成去重、非空、长度达标的列表。
+
+    支持列表或换行/逗号/中文顿号分隔的字符串，方便后台直接粘贴多行。
+    """
+    raw: list[str] = []
+    if isinstance(value, (list, tuple)):
+        raw = [str(item or "") for item in value]
+    elif isinstance(value, str):
+        text = value.replace("，", "\n").replace(",", "\n").replace("、", "\n")
+        raw = text.splitlines()
+    result: list[str] = []
+    seen: set[str] = set()
+    for item in raw:
+        keyword = item.strip()
+        if len(keyword) < _MIN_KEYWORD_CHARS:
+            continue
+        lowered = keyword.lower()
+        if lowered in seen:
+            continue
+        seen.add(lowered)
+        result.append(keyword)
+    return result
+
+
+def normalize_rule(value: object, *, fallback_index: int = 0) -> dict[str, Any] | None:
+    """归一化单条规则；缺少关键词或文案则返回 None（视为无效，直接丢弃）。"""
+    if not isinstance(value, dict):
+        return None
+    rule_id = _clean(value.get("id")) or f"rule-{fallback_index + 1}"
+    keywords = _normalize_keywords(value.get("keywords"))
+    display = _clean(value.get("display"))
+    if not keywords or not display:
+        return None
+    enabled = value.get("enabled")
+    if isinstance(enabled, str):
+        enabled = enabled.strip().lower() in {"1", "true", "yes", "on"}
+    elif enabled is None:
+        enabled = True
+    else:
+        enabled = bool(enabled)
+    return {
+        "id": rule_id,
+        "keywords": keywords,
+        "display": display,
+        "enabled": enabled,
+        "note": _clean(value.get("note")),
+    }
+
+
+def normalize_rules(value: object) -> list[dict[str, Any]]:
+    """归一化规则列表，丢弃无效项并保证 id 唯一。"""
+    if not isinstance(value, (list, tuple)):
+        return []
+    rules: list[dict[str, Any]] = []
+    seen_ids: set[str] = set()
+    for index, item in enumerate(value):
+        rule = normalize_rule(item, fallback_index=index)
+        if rule is None:
+            continue
+        base_id = rule["id"]
+        suffix = 1
+        while rule["id"] in seen_ids:
+            suffix += 1
+            rule["id"] = f"{base_id}-{suffix}"
+        seen_ids.add(rule["id"])
+        rules.append(rule)
+    return rules
+
+
+# --------------------------------------------------------------- AI 归纳规则
+
+# 「AI 归纳」的 system prompt：让模型只回 JSON，并禁止它编造原文里没有的词。
+ERROR_SUMMARY_SYSTEM_PROMPT = (
+    "你是这个上游中转服务的运维助手，负责把一条报错归纳成「报错文案映射规则」。\n"
+    "用户会给你一段报错原文，请输出两部分：\n"
+    "1. keywords：2-4 个能**唯一标识这一类**报错的关键词，"
+    "必须是原文里**原样出现**的子串，不要翻译、不要改写、不要造词。\n"
+    "【最关键的一条】本服务的匹配是「原文包含**任意一个**关键词即命中」，"
+    "不是全部命中 —— 关键词越多，这条规则覆盖的报错就越宽。"
+    "所以宁可少而准，每个关键词都要单凭它自己就能定位到这一类报错。\n"
+    "本服务的报错格式固定为 `{接口路径} failed: status={状态码}, body={上游返回体}`。"
+    "接口路径是上游接口，同一个前缀会对应多种完全不同的操作"
+    "（例如 /backend-api/files 下面既有创建、上传确认，也有下载和文件库），"
+    "所以取路径时要**带上能区分「哪一步」的片段**（如 /uploaded、/download、/library、/conversation），"
+    "只写 /backend-api/files 这样的前缀会误伤一大片其它报错。\n"
+    "优先选：错误标识符（如 upload_protection_limit_exceeded）、"
+    "「步骤 + 状态码」组合（如 /uploaded failed: status=500）、"
+    "状态码（如 status=429）、curl 错误号（如 curl: (16)）。\n"
+    "严禁选过于通用、会误伤正常报错的词（如 error、failed、exception、status、body、detail、"
+    "只出现一次的 file_id / uuid）。\n"
+    "2. display：一句给普通用户看的中文说明，不超过 20 个字。"
+    "不要出现英文术语、状态码、接口路径、账号邮箱、网址或联系方式。\n"
+    "只返回 JSON，不要解释、不要 markdown 代码块，格式固定为："
+    '{"keywords": ["..."], "display": "..."}'
+)
+
+# 抽取候选关键词时要忽略的「太通用」片段：拿它们当规则会误伤一片正常报错。
+# 其中一批是 JSON 字段名（error_code、reason…）——它们是报错的「骨架」，
+# 几乎每条报错都有，当关键词等于没筛。
+_GENERIC_TOKENS = frozenset({
+    "error", "errors", "failed", "failure", "exception", "status", "body",
+    "detail", "details", "message", "msg", "type", "code", "request",
+    "response", "http", "https", "true", "false", "null", "none", "data",
+    "error_code", "error_message", "error_type", "error_detail",
+})
+
+# 每次请求都会变的高熵片段（uuid / 上游 file_id / 长十六进制）。
+# 把它们当关键词等于给单次请求打标，下一次必然命中不了。
+_VOLATILE_SEGMENT = re.compile(
+    r"^(?:[0-9a-f]{8,}|file_[0-9a-z]{6,}|[0-9]{6,})$",
+    re.IGNORECASE,
+)
+
+
+def _strip_volatile_path(path: str) -> str:
+    """把路径截断到第一个高熵片段之前。
+
+    `/backend-api/files/file_00000000ab.../uploaded` → `/backend-api/files`：
+    前两段才代表链路，后面是单次请求的 id。
+    """
+    kept: list[str] = []
+    for segment in str(path or "").split("/"):
+        if segment and _VOLATILE_SEGMENT.match(segment):
+            break
+        kept.append(segment)
+    trimmed = "/".join(kept).rstrip("/")
+    # 只留单段的路径太泛（/files 之类），不值得当关键词。
+    return trimmed if trimmed.count("/") >= 2 else ""
+
+
+# 形如 `"reason": "xxx"` 的 JSON 键值片段。
+_JSON_FRAGMENT = re.compile(r'"\s*:\s*"')
+
+
+def _sanitize_keyword(value: object) -> str:
+    """剥掉关键词两端的 JSON 语法碎片，只留下「值」本身。
+
+    归纳（模型或本地抽取）偶尔会把 `reason": "upload_protection_limit_exceeded`
+    这种从报文里直接截出来的片段整条当关键词。它虽然能把当前这条报错匹配上，
+    但可读性差，而且上游 JSON 的字段顺序/空格一变就失效 —— 例如相邻字段换成
+    `"a": "reason": "upload_...` 时，`reason` 就跑到中间、不再是行首了。
+
+    ⚠️ 只用于「归纳」链路；后台手输的关键词走 _normalize_keywords 原样保留，
+    避免把管理员明确想匹配的带引号子串改掉。
+    """
+    text = str(value or "").strip()
+    if not text:
+        return ""
+    parts = _JSON_FRAGMENT.split(text)
+    if len(parts) > 1:
+        text = parts[-1]
+    return text.strip("\"':,{}[]\\").strip()
+
+
+def _dedupe_ordered(items: list[str]) -> list[str]:
+    """按首次出现顺序去重，同时过滤空值和过短的项。"""
+    result: list[str] = []
+    seen: set[str] = set()
+    for item in items:
+        text = str(item or "").strip()
+        if len(text) < _MIN_KEYWORD_CHARS:
+            continue
+        lowered = text.lower()
+        if lowered in seen:
+            continue
+        seen.add(lowered)
+        result.append(text)
+    return result
+
+
+def extract_keyword_candidates(message: object) -> list[str]:
+    """从报错原文里抽出可直接用作关键词的片段（不依赖模型）。
+
+    这是「AI 归纳」的兜底：模型不可用、超时或被限流时，仍然能给出一组
+    高辨识度的候选词，管理员补一句文案即可。抽取顺序即优先级，越靠前
+    越能唯一标识这类报错。
+    """
+    import re
+
+    text = str(message or "")
+    if not text.strip():
+        return []
+    candidates: list[str] = []
+
+    # 1) 结构化字段值：reason / error_code / code —— 这些是上游给的精确标识
+    for pattern in (
+        r'"reason"\s*:\s*"([^"]+)"',
+        r'"error_code"\s*:\s*"([^"]+)"',
+        r'"code"\s*:\s*"([^"]+)"',
+    ):
+        candidates.extend(re.findall(pattern, text, flags=re.IGNORECASE))
+
+    # 2) 接口路径：/backend-api/xxx 这类前缀最能区分链路。
+    #    路径里常混着每次请求都变的 file_id / uuid，必须截断，
+    #    否则规则只对这一次报错生效，下次换 id 就再也命中不了。
+    candidates.extend(
+        trimmed
+        for trimmed in (
+            _strip_volatile_path(item)
+            for item in re.findall(r"/[a-z0-9][a-z0-9._/-]{3,}", text, flags=re.IGNORECASE)
+        )
+        if trimmed
+    )
+
+    # 3) 状态码：status=429
+    candidates.extend(re.findall(r"status=\d{3}", text, flags=re.IGNORECASE))
+
+    # 4) curl 错误号：curl: (16)
+    candidates.extend(re.findall(r"curl:\s*\(\d+\)", text, flags=re.IGNORECASE))
+
+    # 5) 长标识符（snake_case / 驼峰之外的连续字母数字串）；高熵的不收。
+    candidates.extend(
+        item
+        for item in re.findall(r"[a-z][a-z0-9_]{7,}", text, flags=re.IGNORECASE)
+        if not _VOLATILE_SEGMENT.match(item)
+    )
+
+    # 路径会带出 /backend-api、/files 之类碎片，去掉只有斜杠的单段噪声
+    cleaned: list[str] = []
+    for item in candidates:
+        fixed = _sanitize_keyword(item)
+        if len(fixed) < _MIN_KEYWORD_CHARS or fixed == "/":
+            continue
+        if fixed.lower() in _GENERIC_TOKENS:
+            continue
+        cleaned.append(fixed)
+    return _dedupe_ordered(cleaned)[:12]
+
+
+def parse_ai_suggestion(value: object, *, raw: str = "") -> dict[str, Any]:
+    """把模型返回的文本解析成 {keywords, display}。
+
+    - 容忍 markdown 代码块、前后解释文字（取第一个 JSON 对象）。
+    - **只保留在原文里真实出现的关键词**：匹配是子串匹配，编造的词永远命中不了。
+    """
+    import json
+    import re
+
+    text = str(value or "").strip()
+    if not text:
+        return {"keywords": [], "display": ""}
+    if text.startswith("```"):
+        text = re.sub(r"^```[a-zA-Z]*\s*", "", text)
+        text = re.sub(r"\s*```$", "", text).strip()
+    match = re.search(r"\{.*\}", text, flags=re.DOTALL)
+    if match:
+        text = match.group(0)
+    try:
+        data = json.loads(text)
+    except ValueError:
+        return {"keywords": [], "display": ""}
+    if not isinstance(data, dict):
+        return {"keywords": [], "display": ""}
+    # 先剥 JSON 语法碎片（模型会把 `reason": "upload_xxx` 整条当关键词），再去重。
+    keywords = _normalize_keywords(
+        [_sanitize_keyword(item) for item in _normalize_keywords(data.get("keywords"))]
+    )
+    # 通用 JSON 字段名（error_code / reason / message…）几乎每条报错都有，
+    # 当关键词等于把所有报错都命中，必须剔掉（本地抽取走的是同一份黑名单）。
+    keywords = [keyword for keyword in keywords if keyword.lower() not in _GENERIC_TOKENS]
+    lowered = str(raw or "").lower()
+    if lowered:
+        keywords = [keyword for keyword in keywords if keyword.lower() in lowered]
+    return {"keywords": keywords, "display": _clean(data.get("display"))}
+
+
+def _fingerprint(message: str) -> str:
+    """把报错原文压成一个稳定指纹，用于同模板去重。
+
+    同一类报错每次的 uuid / 时间戳 / 文件名都不同，直接按原文去重会得到
+    成百上千条噪声；这里剥掉明显的可变片段（十六进制串、数字、引号内容）
+    后再算指纹。
+    """
+    import hashlib
+    import re
+
+    text = str(message or "")
+    # UUID（8-4-4-4-12）整段归一，避免只吃掉前半段、剩余片段被 \d+ 打成
+    # 不同长度的 `#` 序列，导致同类报错算出不同指纹。
+    normalized = re.sub(
+        r"\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b",
+        "#",
+        text,
+        flags=re.IGNORECASE,
+    )
+    # 其余长十六进制串（hash / token / 文件名）同样归一。
+    normalized = re.sub(r"[0-9a-f]{8,}", "#", normalized, flags=re.IGNORECASE)
+    normalized = re.sub(r"\d+", "#", normalized)
+    normalized = re.sub(r"\s+", " ", normalized).strip().lower()
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:_FINGERPRINT_CHARS]
+
+
+class ErrorMessageService:
+    def __init__(self, store_path: Path | None = None) -> None:
+        self._path = store_path or UNCONFIGURED_ERRORS_FILE
+        self._lock = threading.RLock()
+        self._unconfigured_cache: dict[str, dict[str, Any]] | None = None
+
+    # ---------------------------------------------------------------- 规则
+
+    def _rules(self) -> list[dict[str, Any]]:
+        # 延迟导入：config 在导入期会读取 DATA_DIR，避免循环依赖。
+        from services.config import config
+
+        return normalize_rules(config.data.get("error_message_rules"))
+
+    def translate(self, message: object, *, channel: str = "") -> str:
+        """把一条原始报错翻译成前台文案。
+
+        命中规则 -> 返回配置的大白话；
+        未命中   -> 返回原文，并记录一条「未配置报错」待办。
+        """
+        text = _clean(message)
+        if not text:
+            return text
+        lowered = text.lower()
+        for rule in self._rules():
+            if not rule.get("enabled", True):
+                continue
+            if any(keyword.lower() in lowered for keyword in rule["keywords"]):
+                return rule["display"]
+        self._record_unconfigured(text, channel=channel)
+        return text
+
+    def translate_detail(self, detail: object, *, channel: str = "") -> object:
+        """对 FastAPI 的 detail 结构做就地翻译，保持原有结构。"""
+        if isinstance(detail, str):
+            return self.translate(detail, channel=channel)
+        if isinstance(detail, list):
+            return [self.translate_detail(item, channel=channel) for item in detail]
+        if isinstance(detail, dict):
+            translated: dict[Any, Any] = {}
+            for key, value in detail.items():
+                # 只翻译真正承载文案的字段，避免把 code / type 也换掉。
+                if key in {"message", "error", "detail", "msg"}:
+                    translated[key] = self.translate_detail(value, channel=channel)
+                else:
+                    translated[key] = value
+            return translated
+        return detail
+
+    # ------------------------------------------------------- 未配置报错收集
+
+    def _load_unconfigured(self) -> dict[str, dict[str, Any]]:
+        with self._lock:
+            if self._unconfigured_cache is not None:
+                return self._unconfigured_cache
+            data: dict[str, dict[str, Any]] = {}
+            try:
+                raw = json.loads(self._path.read_text(encoding="utf-8"))
+            except (OSError, ValueError):
+                raw = {}
+            items = raw.get("items") if isinstance(raw, dict) else None
+            if isinstance(items, list):
+                for item in items:
+                    if not isinstance(item, dict):
+                        continue
+                    fingerprint = _clean(item.get("fingerprint"))
+                    if fingerprint:
+                        data[fingerprint] = item
+            self._unconfigured_cache = data
+            return data
+
+    def _save_unconfigured(self, data: dict[str, dict[str, Any]]) -> None:
+        with self._lock:
+            payload = {"items": sorted(data.values(), key=lambda item: str(item.get("last_seen") or ""), reverse=True)}
+            try:
+                self._path.parent.mkdir(parents=True, exist_ok=True)
+                temp = self._path.with_suffix(self._path.suffix + ".tmp")
+                temp.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+                temp.replace(self._path)
+            except OSError:
+                # 收集失败绝不能影响正常请求链路。
+                return
+            self._unconfigured_cache = data
+
+    def _record_unconfigured(self, message: str, *, channel: str = "") -> None:
+        fingerprint = _fingerprint(message)
+        sample = message[:_MAX_SAMPLE_CHARS]
+        with self._lock:
+            data = self._load_unconfigured()
+            existing = data.get(fingerprint)
+            now = time.strftime("%Y-%m-%d %H:%M:%S")
+            if existing is None and len(data) >= _MAX_UNCONFIGURED_ENTRIES:
+                self._prune_locked(data)
+            if existing is None:
+                data[fingerprint] = {
+                    "fingerprint": fingerprint,
+                    "sample": sample,
+                    "count": 1,
+                    "channel": _clean(channel),
+                    "first_seen": now,
+                    "last_seen": now,
+                }
+            else:
+                entry = dict(existing)
+                entry["count"] = int(entry.get("count") or 0) + 1
+                entry["last_seen"] = now
+                entry["sample"] = sample
+                if channel and not entry.get("channel"):
+                    entry["channel"] = _clean(channel)
+                data[fingerprint] = entry
+            self._save_unconfigured(data)
+
+    @staticmethod
+    def _prune_locked(data: dict[str, dict[str, Any]]) -> None:
+        """超出上限时先淘汰最久未出现、且出现次数最少的条目。"""
+        ordered = sorted(
+            data.values(),
+            key=lambda item: (int(item.get("count") or 0), str(item.get("last_seen") or "")),
+        )
+        for item in ordered[: max(1, len(ordered) // 10)]:
+            data.pop(_clean(item.get("fingerprint")), None)
+
+    def list_unconfigured(self) -> list[dict[str, Any]]:
+        data = self._load_unconfigured()
+        items = sorted(
+            (dict(item) for item in data.values()),
+            key=lambda item: (
+                -int(item.get("count") or 0),
+                str(item.get("last_seen") or ""),
+            ),
+        )
+        # 顺带给出可直接用作关键词的候选片段，省得管理员从整段报错里手抠。
+        for item in items:
+            item["keywords"] = extract_keyword_candidates(item.get("sample"))
+        return items
+
+    def clear_unconfigured(self, fingerprints: list[str] | None = None) -> int:
+        with self._lock:
+            data = self._load_unconfigured()
+            if not fingerprints:
+                removed = len(data)
+                data.clear()
+            else:
+                removed = 0
+                for raw in fingerprints:
+                    fingerprint = _clean(raw)
+                    if fingerprint in data:
+                        data.pop(fingerprint)
+                        removed += 1
+            self._save_unconfigured(data)
+            return removed
+
+
+error_message_service = ErrorMessageService()

services/image_task_service.py

@@ -17,6 +17,7 @@ from typing import Any
 from services.auth_service import DAILY_GIFT_ACCOUNT_POOL_MODEL_ID
 from services.config import DATA_DIR, config
 from services.content_filter import request_text
+from services.error_message_service import error_message_service
 from services.image_storage_service import image_storage_service
 from services.log_service import LOG_TYPE_CALL, log_service
 from services.protocol import openai_v1_image_edit, openai_v1_image_generations
@@ -266,7 +267,12 @@ def _public_task(task: dict[str, Any]) -> dict[str, Any]:
     if task.get("data") is not None:
         item["data"] = task.get("data")
     if task.get("error"):
-        item["error"] = sanitize_sensitive_text(task.get("error"))
+        # 前台只展示管理员配置过的大白话；未命中规则时保留原文，
+        # 同时由 error_message_service 记下这条待配置报错。
+        item["error"] = error_message_service.translate(
+            sanitize_sensitive_text(task.get("error")),
+            channel="image_task",
+        )
     return item
 
 

services/protocol/conversation.py

@@ -115,6 +115,37 @@ def is_transient_image_connection_error(message: str) -> bool:
     )
 
 
+_UPLOAD_THROTTLE_MARKERS = (
+    # ChatGPT 的上传限流是一个账号维度的配额（upload_protection_limit_exceeded），
+    # 换一个账号通常仍能上传，所以绝不能当成终态失败暴露给用户。
+    "upload_protection_limit_exceeded",
+    "throttled",
+    "文件上传上限",
+    "file upload limit",
+    "upload limit",
+)
+
+_UPLOAD_PATHS = ("/backend-api/files", "image_upload failed", "file_upload failed", "image upload", "file upload")
+
+
+def is_account_scoped_upload_error(message: str) -> bool:
+    """识别「换个账号就能成功」的上传类失败。
+
+    上传限流（429 throttled / upload_protection_limit_exceeded）是绑定在单个
+    ChatGPT 账号上的配额，和网络抖动、token 失效不同：重试同一个账号没有意义，
+    但换号几乎总能成功。因此这类错误必须进换号分支，而不是当作终态失败抛出。
+    """
+    text = str(message or "").lower()
+    if not text:
+        return False
+    if not any(marker in text for marker in _UPLOAD_PATHS):
+        return False
+    if any(marker in text for marker in _UPLOAD_THROTTLE_MARKERS):
+        return True
+    # 未带 detail 的裸 429 上传响应同样按账号配额处理。
+    return "status=429" in text
+
+
 def is_retryable_multimodal_account_error(message: str) -> bool:
     """Treat account-scoped image-upload failures as eligible for failover."""
     text = str(message or "").lower()
@@ -125,6 +156,8 @@ def is_retryable_multimodal_account_error(message: str) -> bool:
         for marker in ("status=401", "status=403", "authenticationfailed", "signature fields")
     ):
         return True
+    if is_account_scoped_upload_error(text):
+        return True
     return is_transient_image_connection_error(text)
 
 
@@ -133,6 +166,8 @@ def image_stream_error_message(message: str) -> str:
     lower = text.lower()
     if is_token_invalid_error(text):
         return "image generation failed"
+    if is_account_scoped_upload_error(text):
+        return "号池中所有账号的上传额度均已达到上限，请稍后重试或补充账号"
     if is_transient_image_connection_error(text) and (
         "curl: (35)" in lower
         or "tls connect error" in lower
@@ -1282,6 +1317,8 @@ def _stream_image_outputs_with_pool(
     emitted = False
     last_error = ""
     failed_tokens: set[str] = set()
+    # 因上传限流被换掉的账号，用于在号池耗尽时给出准确原因。
+    throttled_tokens: set[str] = set()
     renewal_attempted_tokens: set[str] = set()
     memory_key = str(memory_key or "default").strip() or "default"
     total = max(1, int(total_count or request.n or 1))
@@ -1309,6 +1346,13 @@ def _stream_image_outputs_with_pool(
             except RuntimeError as exc:
                 if emitted:
                     return
+                # 如果本轮是因为上传限流把账号逐个排除到池空，直说原因，
+                # 否则用户只会看到和「号池没号」一样的提示。
+                if throttled_tokens:
+                    raise ImageGenerationError(
+                        "号池中所有账号的上传额度均已达到上限，请稍后重试或补充账号",
+                        account_email="",
+                    ) from exc
                 raise ImageGenerationError(str(exc) or "image generation failed") from exc
 
             get_account = getattr(account_service, "get_account", None)
@@ -1445,6 +1489,20 @@ def _stream_image_outputs_with_pool(
                     failed_tokens.add(token)
                     account_service.mark_image_result(token, False)
                     continue
+                if not emitted_for_token and is_account_scoped_upload_error(last_error):
+                    # 上传限流是单账号配额，换号即可，不应把账号判为不可用。
+                    # 只把它加进本轮排除集合并归还并发槽，避免触发
+                    # verify_free_account_after_image_failure 的账号清理。
+                    failed_tokens.add(token)
+                    throttled_tokens.add(token)
+                    account_service.release_image_slot(token)
+                    logger.warning({
+                        "event": "image_upload_throttled_switch_account",
+                        "account_email": account_email,
+                        "excluded_accounts": len(failed_tokens),
+                        "error": last_error,
+                    })
+                    continue
                 if not emitted_for_token and is_transient_image_connection_error(last_error):
                     connection_retry_attempts += 1
                     if connection_retry_attempts <= 2:

services/protocol/error_response.py

@@ -7,6 +7,19 @@ from fastapi.responses import JSONResponse
 from utils.sensitive_data import sanitize_sensitive_text
 
 
+def _translate(message: str) -> str:
+    """先做敏感信息脱敏，再交给管理员配置的报错文案映射。
+
+    映射只影响前台展示；调用方（日志）拿到的仍是脱敏后的原始报错。
+    """
+    cleaned = sanitize_sensitive_text(message)
+    if not cleaned:
+        return cleaned
+    from services.error_message_service import error_message_service
+
+    return error_message_service.translate(cleaned, channel="api")
+
+
 def _message_from_value(value: object) -> str:
     if isinstance(value, str):
         return value
@@ -30,12 +43,12 @@ def error_message_from_detail(detail: object) -> str:
                 messages.append(f"{location}: {message}")
             elif message:
                 messages.append(message)
-        return sanitize_sensitive_text("; ".join(messages))
+        return _translate("; ".join(messages))
     if isinstance(detail, dict):
         message = _message_from_value(detail.get("error")) or _message_from_value(detail)
         if message:
-            return sanitize_sensitive_text(message)
-    return sanitize_sensitive_text(str(detail or "").strip())
+            return _translate(message)
+    return _translate(str(detail or "").strip())
 
 
 def _default_error_type(status_code: int) -> str:

test/test_error_message_service.py

@@ -0,0 +1,503 @@
+"""报错文案映射服务测试。
+
+覆盖三块：
+1. 关键词归一化与规则归一化（脏数据要能安全丢弃 / 去重）；
+2. translate 的命中优先级（命中即替换、未命中记待办并保留原文）；
+3. 未配置报错的收集、去重计数、清空与上限淘汰。
+"""
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+
+class KeywordNormalizationTests(unittest.TestCase):
+    def test_accepts_list_and_separator_strings(self) -> None:
+        from services.error_message_service import _normalize_keywords
+
+        self.assertEqual(_normalize_keywords(["a1", "b2"]), ["a1", "b2"])
+        # 换行 / 逗号 / 中文逗号 / 顿号都应被拆开
+        self.assertEqual(_normalize_keywords("a1\nb2,c3，d4、e5"), ["a1", "b2", "c3", "d4", "e5"])
+
+    def test_drops_short_and_duplicate_keywords(self) -> None:
+        from services.error_message_service import _normalize_keywords
+
+        # 短于 MIN_KEYWORD_CHARS 的关键词会误伤正常报错，必须丢掉；重复项按小写去重
+        self.assertEqual(_normalize_keywords(["a", "ab", "AB", "cd", ""]), ["ab", "cd"])
+
+    def test_ignores_non_string_input(self) -> None:
+        from services.error_message_service import _normalize_keywords
+
+        self.assertEqual(_normalize_keywords(None), [])
+        self.assertEqual(_normalize_keywords(123), [])
+
+
+class RuleNormalizationTests(unittest.TestCase):
+    def test_drops_rules_missing_keywords_or_display(self) -> None:
+        from services.error_message_service import normalize_rules
+
+        rules = normalize_rules([
+            {"keywords": ["throttled"], "display": "太挤了"},
+            {"keywords": [], "display": "没关键词"},
+            {"keywords": ["x1"], "display": ""},
+            "not-a-dict",
+        ])
+        self.assertEqual(len(rules), 1)
+        self.assertEqual(rules[0]["keywords"], ["throttled"])
+
+    def test_enabled_defaults_and_string_coercion(self) -> None:
+        from services.error_message_service import normalize_rules
+
+        rules = normalize_rules([
+            {"id": "r1", "keywords": ["aa"], "display": "x"},
+            {"id": "r2", "keywords": ["bb"], "display": "y", "enabled": "false"},
+            {"id": "r3", "keywords": ["cc"], "display": "z", "enabled": "yes"},
+        ])
+        self.assertTrue(rules[0]["enabled"])
+        self.assertFalse(rules[1]["enabled"])
+        self.assertTrue(rules[2]["enabled"])
+
+    def test_duplicate_ids_get_suffixed(self) -> None:
+        from services.error_message_service import normalize_rules
+
+        rules = normalize_rules([
+            {"id": "dup", "keywords": ["aa"], "display": "x"},
+            {"id": "dup", "keywords": ["bb"], "display": "y"},
+        ])
+        self.assertEqual([rule["id"] for rule in rules], ["dup", "dup-2"])
+
+    def test_missing_id_gets_fallback(self) -> None:
+        from services.error_message_service import normalize_rules
+
+        rules = normalize_rules([{"keywords": ["aa"], "display": "x"}])
+        self.assertEqual(rules[0]["id"], "rule-1")
+
+
+class TranslateTests(unittest.TestCase):
+    """translate 的命中 / 未命中行为。用临时文件隔离未配置报错的写入。"""
+
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        self._store = Path(self._tmp.name) / "unconfigured.json"
+
+    def tearDown(self) -> None:
+        self._tmp.cleanup()
+
+    def _service(self, rules):
+        from services.error_message_service import ErrorMessageService
+
+        service = ErrorMessageService(store_path=self._store)
+        service._rules = lambda: __import__(
+            "services.error_message_service", fromlist=["normalize_rules"]
+        ).normalize_rules(rules)
+        return service
+
+    def test_hit_returns_display_text(self) -> None:
+        service = self._service([{"keywords": ["upload_protection_limit_exceeded"], "display": "上传额度已满"}])
+        raw = '/backend-api/files failed: status=429, body={"reason": "upload_protection_limit_exceeded"}'
+        self.assertEqual(service.translate(raw), "上传额度已满")
+
+    def test_match_is_case_insensitive(self) -> None:
+        service = self._service([{"keywords": ["Throttled"], "display": "太挤了"}])
+        self.assertEqual(service.translate("upstream THROTTLED now"), "太挤了")
+
+    def test_disabled_rule_is_skipped(self) -> None:
+        service = self._service([{"keywords": ["throttled"], "display": "太挤了", "enabled": False}])
+        self.assertEqual(service.translate("throttled"), "throttled")
+
+    def test_miss_keeps_original_and_records_todo(self) -> None:
+        service = self._service([{"keywords": ["throttled"], "display": "太挤了"}])
+        raw = "upstream connect failed: 由于目标计算机积极拒绝"
+        self.assertEqual(service.translate(raw, channel="api"), raw)
+
+        items = service.list_unconfigured()
+        self.assertEqual(len(items), 1)
+        self.assertEqual(items[0]["channel"], "api")
+        self.assertEqual(items[0]["count"], 1)
+
+    def test_empty_message_is_ignored(self) -> None:
+        service = self._service([])
+        self.assertEqual(service.translate(""), "")
+        self.assertEqual(service.translate(None), "")
+        self.assertEqual(service.list_unconfigured(), [])
+
+    def test_translate_detail_only_touches_text_fields(self) -> None:
+        service = self._service([{"keywords": ["throttled"], "display": "太挤了"}])
+        detail = {"code": "throttled", "message": "throttled for you", "type": "throttled"}
+        result = service.translate_detail(detail)
+        self.assertEqual(result["message"], "太挤了")
+        # code / type 是程序判断用的，不能被替换
+        self.assertEqual(result["code"], "throttled")
+        self.assertEqual(result["type"], "throttled")
+
+
+class UnconfiguredCollectionTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        self._store = Path(self._tmp.name) / "unconfigured.json"
+
+    def tearDown(self) -> None:
+        self._tmp.cleanup()
+
+    def _service(self):
+        from services.error_message_service import ErrorMessageService
+
+        service = ErrorMessageService(store_path=self._store)
+        service._rules = lambda: []
+        return service
+
+    def test_same_shape_errors_share_one_fingerprint(self) -> None:
+        """同一类报错每次 uuid / 数字不同，不应各记一条。"""
+        service = self._service()
+        service.translate("/api/x failed id=550e8400-e29b-41d4-a716-446655440000 code=429")
+        service.translate("/api/x failed id=6ba7b810-9dad-11d1-80b4-00c04fd430c8 code=500")
+
+        items = service.list_unconfigured()
+        self.assertEqual(len(items), 1)
+        self.assertEqual(items[0]["count"], 2)
+
+    def test_list_sorted_by_count_desc(self) -> None:
+        service = self._service()
+        service.translate("alpha error occurred")
+        service.translate("beta error occurred")
+        service.translate("beta error occurred")
+        service.translate("beta error occurred")
+
+        items = service.list_unconfigured()
+        self.assertEqual(items[0]["count"], 3)
+        self.assertEqual(items[1]["count"], 1)
+
+    def test_list_includes_keyword_candidates(self) -> None:
+        """待办列表要带上可直接用的候选关键词，省得管理员手抠。"""
+        service = self._service()
+        service.translate('beta failed: status=429, body={"reason": "some_specific_reason"}')
+
+        items = service.list_unconfigured()
+        self.assertEqual(len(items), 1)
+        self.assertIn("some_specific_reason", items[0]["keywords"])
+        self.assertIn("status=429", items[0]["keywords"])
+
+    def test_persists_across_instances(self) -> None:
+        from services.error_message_service import ErrorMessageService
+
+        service = self._service()
+        service.translate("some unique error text")
+
+        reloaded = ErrorMessageService(store_path=self._store)
+        reloaded._rules = lambda: []
+        self.assertEqual(len(reloaded.list_unconfigured()), 1)
+
+    def test_clear_selected_and_all(self) -> None:
+        service = self._service()
+        service.translate("alpha error occurred")
+        service.translate("beta error occurred")
+        items = service.list_unconfigured()
+        target = items[0]["fingerprint"]
+
+        self.assertEqual(service.clear_unconfigured([target]), 1)
+        self.assertEqual(len(service.list_unconfigured()), 1)
+
+        self.assertEqual(service.clear_unconfigured(), 1)
+        self.assertEqual(service.list_unconfigured(), [])
+
+    def test_entry_cap_prunes_oldest(self) -> None:
+        from services import error_message_service as module
+
+        service = self._service()
+        original_cap = module._MAX_UNCONFIGURED_ENTRIES
+        module._MAX_UNCONFIGURED_ENTRIES = 10
+        try:
+            for index in range(30):
+                service.translate(f"unique error number {index:04d} text")
+            self.assertLessEqual(len(service.list_unconfigured()), 10)
+        finally:
+            module._MAX_UNCONFIGURED_ENTRIES = original_cap
+
+    def test_corrupt_store_is_tolerated(self) -> None:
+        self._store.write_text("{ this is not json", encoding="utf-8")
+        service = self._service()
+        # 坏文件不能让请求链路崩，且能继续写入
+        service.translate("brand new error text")
+        self.assertEqual(len(service.list_unconfigured()), 1)
+
+    def test_sample_is_truncated(self) -> None:
+        from services import error_message_service as module
+
+        service = self._service()
+        service.translate("x" * (module._MAX_SAMPLE_CHARS + 500))
+        items = service.list_unconfigured()
+        self.assertEqual(len(items[0]["sample"]), module._MAX_SAMPLE_CHARS)
+
+
+class KeywordCandidateExtractionTests(unittest.TestCase):
+    """本地抽取：AI 不可用时的兜底，必须能捞出高辨识度片段。"""
+
+    def test_extracts_from_real_upload_throttle_payload(self) -> None:
+        from services.error_message_service import extract_keyword_candidates
+
+        raw = (
+            '/backend-api/files failed: status=429, body={"detail": {"code": "throttled", '
+            '"error_code": "throttled", "message": "你已达到文件上传上限。请4小时 内重试。", '
+            '"type": "throttled", "reason": "upload_protection_limit_exceeded"}}'
+        )
+        candidates = extract_keyword_candidates(raw)
+        # 最精确的标识符排在最前
+        self.assertEqual(candidates[0], "upload_protection_limit_exceeded")
+        self.assertIn("/backend-api/files", candidates)
+        self.assertIn("status=429", candidates)
+
+    def test_skips_json_key_names_and_generic_words(self) -> None:
+        from services.error_message_service import extract_keyword_candidates
+
+        raw = '{"error_code": "abc12345", "message": "failed", "reason": "xyz98765"}'
+        candidates = extract_keyword_candidates(raw)
+        # 字段名本身不参与匹配，否则等于没筛
+        for noise in ("error_code", "message", "reason", "failed", "status"):
+            self.assertNotIn(noise, candidates)
+
+    def test_extracts_curl_noise(self) -> None:
+        from services.error_message_service import extract_keyword_candidates
+
+        self.assertIn("curl: (16)", extract_keyword_candidates("upstream curl: (16) recv failure"))
+
+    def test_deduplicates_and_handles_empty(self) -> None:
+        from services.error_message_service import extract_keyword_candidates
+
+        self.assertEqual(extract_keyword_candidates(""), [])
+        self.assertEqual(extract_keyword_candidates(None), [])
+        repeated = extract_keyword_candidates("status=429 then again status=429")
+        self.assertEqual(repeated.count("status=429"), 1)
+
+    def test_no_json_syntax_fragments_in_candidates(self) -> None:
+        """候选词里不能出现引号/冒号/花括号 —— 那是报文语法，不是错误标识。"""
+        from services.error_message_service import extract_keyword_candidates
+
+        raw = (
+            '/backend-api/files failed: status=429, body={"detail": {"code": "throttled", '
+            '"reason": "upload_protection_limit_exceeded"}}'
+        )
+        candidates = extract_keyword_candidates(raw)
+        # 注意不能一律禁冒号：`curl: (16)` 这种是合法关键词，只禁 JSON 的 `": "` 片段。
+        for candidate in candidates:
+            for noise in ('"', "'", "{", "}", '": "'):
+                self.assertNotIn(noise, candidate, msg=f"{candidate!r} 里混进了 JSON 语法碎片")
+
+
+class ReportedUploadErrorTests(unittest.TestCase):
+    """用户实际上报的 /uploaded 500 报错：从「粘贴原文」到「规则真能命中」必须闭环。
+
+    这条报错是多模态里最常见的 500（file_id 每次不同），用来守住：
+    1. 本地抽取能捞出高辨识度片段；
+    2. 模型编造的关键词会被丢弃；
+    3. 归纳出来的规则确实能命中原始报错（子串匹配）。
+    """
+
+    RAW = (
+        "/backend-api/files/file_000000006bcc81f5b6f6f32ff45d7f55/uploaded failed: status=500, "
+        'body={"detail": {"code": "internal_error", "error_code": "internal_error"}}'
+    )
+
+    def setUp(self) -> None:
+        self._tmp = tempfile.TemporaryDirectory()
+        self._store = Path(self._tmp.name) / "unconfigured.json"
+
+    def tearDown(self) -> None:
+        self._tmp.cleanup()
+
+    def test_extracts_usable_candidates(self) -> None:
+        from services.error_message_service import extract_keyword_candidates
+
+        candidates = extract_keyword_candidates(self.RAW)
+        self.assertIn("/backend-api/files", candidates)
+        self.assertIn("status=500", candidates)
+        self.assertIn("internal_error", candidates)
+
+    def test_ai_suggestion_drops_hallucinated_keywords(self) -> None:
+        from services.error_message_service import parse_ai_suggestion
+
+        answer = (
+            '{"keywords": ["status=500", "internal_error", "definitely_absent", "error_code"], '
+            '"display": "文件上传失败，请稍后重试"}'
+        )
+        result = parse_ai_suggestion(answer, raw=self.RAW)
+        self.assertEqual(result["display"], "文件上传失败，请稍后重试")
+        self.assertIn("status=500", result["keywords"])
+        self.assertIn("internal_error", result["keywords"])
+        # 原文里没有的词永远命中不了；JSON 字段名会命中所有报错，两者都要剔。
+        self.assertNotIn("definitely_absent", result["keywords"])
+        self.assertNotIn("error_code", result["keywords"])
+
+    def test_volatile_path_segments_are_trimmed(self) -> None:
+        from services.error_message_service import _strip_volatile_path
+
+        # file_id 每次都变，关键词必须停在它之前，否则规则只对这一次生效。
+        self.assertEqual(
+            _strip_volatile_path("/backend-api/files/file_000000006bcc81f5b6f6f32ff45d7f55/uploaded"),
+            "/backend-api/files",
+        )
+        self.assertEqual(_strip_volatile_path("/backend-api/files"), "/backend-api/files")
+        # 单段路径太泛，直接丢弃。
+        self.assertEqual(_strip_volatile_path("/files"), "")
+
+    def test_generated_rule_matches_the_reported_error(self) -> None:
+        from services.error_message_service import ErrorMessageService, extract_keyword_candidates
+
+        service = ErrorMessageService(store_path=self._store)
+        service._rules = lambda: __import__(
+            "services.error_message_service", fromlist=["normalize_rules"]
+        ).normalize_rules(
+            [
+                {
+                    "keywords": extract_keyword_candidates(self.RAW),
+                    "display": "文件上传失败，请稍后重试",
+                }
+            ]
+        )
+        # file_id 每次都不同，命中靠的是路径前缀 + 状态码，不是整条原文。
+        other = (
+            "/backend-api/files/file_00000000aaaaaaaaaaaaaaaaaaaaaaaa/uploaded failed: status=500, "
+            'body={"detail": {"code": "internal_error"}}'
+        )
+        self.assertEqual(service.translate(self.RAW), "文件上传失败，请稍后重试")
+        self.assertEqual(service.translate(other), "文件上传失败，请稍后重试")
+
+    # 429 上传限流：和上面那条 500 报错共用 /backend-api/files 前缀。
+    THROTTLE = (
+        '/backend-api/files failed: status=429, body={"detail": {"code": "throttled", '
+        '"error_code": "throttled", "reason": "upload_protection_limit_exceeded"}}'
+    )
+
+    def _service_with(self, rules):
+        from services.error_message_service import ErrorMessageService
+
+        service = ErrorMessageService(store_path=self._store)
+        service._rules = lambda: __import__(
+            "services.error_message_service", fromlist=["normalize_rules"]
+        ).normalize_rules(rules)
+        return service
+
+    def test_upload_500_rule_does_not_swallow_throttle_error(self) -> None:
+        """两条规则必须正交：500 规则不能吞掉 429 限流，反之亦然。
+
+        匹配是「任一关键词命中」，所以关键词选宽一点就会让两条规则互相覆盖。
+        这是「结合本项目」的核心：路径必须带上区分步骤的片段。
+        """
+        service = self._service_with(
+            [
+                {"keywords": ["internal_error", "/uploaded failed: status=500"], "display": "文件上传失败，请重试"},
+                {"keywords": ["upload_protection_limit_exceeded", "你已达到文件上传上限"], "display": "文件上传次数已达上限"},
+            ]
+        )
+        self.assertEqual(service.translate(self.RAW), "文件上传失败，请重试")
+        self.assertEqual(service.translate(self.THROTTLE), "文件上传次数已达上限")
+
+    def test_broad_path_prefix_swallows_other_errors(self) -> None:
+        """反面用例：只有裸前缀 /backend-api/files 时，500 规则会吞掉 429 限流报错。
+
+        这条用例存在的意义是防止有人把提示词改回「只写接口路径前缀」——
+        那样前台会把「配额用满」误报成「服务内部错误」，用户会一直重试而不是等换号。
+        """
+        service = self._service_with(
+            [{"keywords": ["/backend-api/files"], "display": "服务器内部错误，请稍后重试"}]
+        )
+        self.assertEqual(service.translate(self.RAW), "服务器内部错误，请稍后重试")
+        # 这就是误伤：限流报错也被换成了 500 的文案。
+        self.assertEqual(service.translate(self.THROTTLE), "服务器内部错误，请稍后重试")
+
+
+class AiSuggestionParsingTests(unittest.TestCase):
+    def test_parses_plain_json(self) -> None:
+        from services.error_message_service import parse_ai_suggestion
+
+        result = parse_ai_suggestion('{"keywords": ["aa", "bb"], "display": "出错了"}')
+        self.assertEqual(result["keywords"], ["aa", "bb"])
+        self.assertEqual(result["display"], "出错了")
+
+    def test_strips_markdown_code_fence(self) -> None:
+        from services.error_message_service import parse_ai_suggestion
+
+        result = parse_ai_suggestion('```json\n{"keywords": ["aa"], "display": "出错了"}\n```')
+        self.assertEqual(result["keywords"], ["aa"])
+
+    def test_tolerates_surrounding_prose(self) -> None:
+        from services.error_message_service import parse_ai_suggestion
+
+        result = parse_ai_suggestion('好的，结果如下：\n{"keywords": ["aa"], "display": "出错了"}\n希望有帮助')
+        self.assertEqual(result["display"], "出错了")
+
+    def test_drops_keywords_absent_from_raw(self) -> None:
+        """关键在原文里必须真实出现，否则规则永远命中不了。"""
+        from services.error_message_service import parse_ai_suggestion
+
+        result = parse_ai_suggestion(
+            '{"keywords": ["upload_protection_limit_exceeded", "hallucinated_token"], "display": "太挤了"}',
+            raw="/backend-api/files failed: upload_protection_limit_exceeded",
+        )
+        self.assertEqual(result["keywords"], ["upload_protection_limit_exceeded"])
+
+    def test_bad_output_returns_empty(self) -> None:
+        from services.error_message_service import parse_ai_suggestion
+
+        for bad in ("", None, "抱歉我无法处理", "[1,2,3]", "{ not json"):
+            self.assertEqual(parse_ai_suggestion(bad, raw="x")["keywords"], [])
+            self.assertEqual(parse_ai_suggestion(bad, raw="x")["display"], "")
+
+    def test_prompt_forbids_generic_keywords(self) -> None:
+        from services.error_message_service import ERROR_SUMMARY_SYSTEM_PROMPT
+
+        for word in ("error", "failed", "exception"):
+            self.assertIn(word, ERROR_SUMMARY_SYSTEM_PROMPT)
+
+    def test_sanitizes_json_fragment_keywords(self) -> None:
+        """模型会把 `reason": "upload_xxx` 这种截断片段整条当关键词。
+
+        它虽然能把当前这条报错匹配上，但只要上游 JSON 的字段顺序或空格一变
+        就失效；归纳链路必须只保留「值」本身。
+        """
+        from services.error_message_service import parse_ai_suggestion
+
+        raw = '/backend-api/files failed: status=429, body={"detail": {"code": "throttled", "reason": "upload_protection_limit_exceeded"}}'
+        result = parse_ai_suggestion(
+            json.dumps({
+                "keywords": ['reason": "upload_protection_limit_exceeded', "status=429"],
+                "display": "上传频率过高，请稍后再试",
+            }),
+            raw=raw,
+        )
+        self.assertEqual(result["keywords"], ["upload_protection_limit_exceeded", "status=429"])
+
+    def test_prompt_carries_project_context(self) -> None:
+        """归纳要「结合本项目」：必须告诉模型匹配语义、报文格式和路径步骤要求。
+
+        少了这些，模型会把 /backend-api/files 这种通用前缀当关键词；
+        而匹配是「任一命中」，一条规则就会吞掉一大片语义完全不同的报错。
+        """
+        from services.error_message_service import ERROR_SUMMARY_SYSTEM_PROMPT
+
+        self.assertIn("任意一个", ERROR_SUMMARY_SYSTEM_PROMPT)
+        self.assertIn("failed: status=", ERROR_SUMMARY_SYSTEM_PROMPT)
+        for step in ("/uploaded", "/download", "/library"):
+            self.assertIn(step, ERROR_SUMMARY_SYSTEM_PROMPT)
+        self.assertIn("file_id", ERROR_SUMMARY_SYSTEM_PROMPT)
+
+
+class ConfigIntegrationTests(unittest.TestCase):
+    def test_config_exposes_rule_helpers(self) -> None:
+        """config 的归一化入口要能安全处理脏数据。"""
+        from services.config import _normalize_error_message_rules
+
+        self.assertEqual(_normalize_error_message_rules(None), [])
+        self.assertEqual(_normalize_error_message_rules([{"keywords": [], "display": ""}]), [])
+        result = _normalize_error_message_rules([{"keywords": ["aa"], "display": "bb"}])
+        self.assertEqual(result[0]["keywords"], ["aa"])
+        self.assertEqual(result[0]["display"], "bb")
+
+    def test_shared_settings_keys_registered(self) -> None:
+        from services.config import SHARED_SETTINGS_KEYS
+
+        self.assertIn("error_message_rules", SHARED_SETTINGS_KEYS)
+        self.assertIn("error_message_fallback_enabled", SHARED_SETTINGS_KEYS)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/test_upload_throttle_failover.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import unittest
+from unittest import mock
+
+from services.protocol.conversation import (
+    ImageGenerationError,
+    image_stream_error_message,
+    is_account_scoped_upload_error,
+    is_retryable_multimodal_account_error,
+    is_token_invalid_error,
+    is_transient_image_connection_error,
+)
+
+# 真实上报的限流响应体（ChatGPT 文件上传配额）。
+UPLOAD_THROTTLED_BODY = (
+    '/backend-api/files failed: status=429, body={"detail": {"code": "throttled", '
+    '"error_code": "throttled", "message": "你已达到文件上传上限。请xxx小时 内重试。", '
+    '"type": "throttled", "reason": "upload_protection_limit_exceeded"}}'
+)
+
+
+class AccountScopedUploadErrorTests(unittest.TestCase):
+    def test_upload_throttle_is_account_scoped(self) -> None:
+        self.assertTrue(is_account_scoped_upload_error(UPLOAD_THROTTLED_BODY))
+
+    def test_upload_throttle_is_eligible_for_failover(self) -> None:
+        # 关键行为：文本/多模态链路遇到上传限流必须换号，而不是直接把错误抛给用户。
+        self.assertTrue(is_retryable_multimodal_account_error(UPLOAD_THROTTLED_BODY))
+
+    def test_bare_429_upload_response_is_account_scoped(self) -> None:
+        self.assertTrue(is_account_scoped_upload_error("/backend-api/files failed: status=429"))
+
+    def test_upload_marker_variants(self) -> None:
+        for message in (
+            'image_upload failed: status=429, body={"detail":{"error_code":"upload_protection_limit_exceeded"}}',
+            "file_upload failed: status=429",
+            "image upload failed: throttled",
+            "/backend-api/files failed: status=429, body={\"detail\":{\"code\":\"throttled\"}}",
+        ):
+            with self.subTest(message=message):
+                self.assertTrue(is_account_scoped_upload_error(message))
+
+    def test_non_upload_429_is_not_account_scoped(self) -> None:
+        # 对话限流不是上传配额，换号无意义，不该吞掉原本的错误处理路径。
+        self.assertFalse(is_account_scoped_upload_error("/backend-api/conversation failed: status=429"))
+
+    def test_unrelated_errors_are_not_account_scoped(self) -> None:
+        for message in (
+            '/backend-api/files failed: status=401, body={"detail":{"error_code":"token_invalidated"}}',
+            "/backend-api/conversation failed: status=500",
+            "curl: (28) operation timed out",
+            "content policy violation",
+            "",
+        ):
+            with self.subTest(message=message):
+                self.assertFalse(is_account_scoped_upload_error(message))
+
+    def test_existing_classifiers_unchanged(self) -> None:
+        # 上传限流不是 token 失效，也不该伪装成网络抖动，否则会走错重试策略。
+        self.assertFalse(is_token_invalid_error(UPLOAD_THROTTLED_BODY))
+        self.assertFalse(is_transient_image_connection_error(UPLOAD_THROTTLED_BODY))
+
+    def test_user_facing_message_explains_quota(self) -> None:
+        message = image_stream_error_message(UPLOAD_THROTTLED_BODY)
+        self.assertIn("上传额度", message)
+        self.assertNotIn("status=429", message)
+
+
+class PoolFailoverTests(unittest.TestCase):
+    """驱动 _stream_image_outputs_with_pool，确认限流会换成下一个账号。"""
+
+    def _run_pool(self, responses: list[Exception | None]):
+        """responses 按调用次数依次返回：Exception 表示该账号失败。"""
+        calls: list[str] = []
+        state = {"i": 0}
+
+        def fake_get_token(*_args, excluded_tokens=None, **_kwargs):
+            # 号池规模 = len(responses)；一旦全部被排除就模拟池空。
+            excluded = set(excluded_tokens or set())
+            if len(excluded) >= len(responses):
+                raise RuntimeError("no available image quota")
+            return f"token-{len(excluded) + 1}"
+
+        def fake_stream(backend, *_args, **_kwargs):
+            index = state["i"]
+            state["i"] += 1
+            calls.append(backend.access_token)
+            outcome = responses[index] if index < len(responses) else None
+            if isinstance(outcome, Exception):
+                raise outcome
+            from services.protocol.conversation import ImageOutput
+
+            yield ImageOutput(kind="result", model="gpt-image-2", index=1, total=1, data=[{"b64_json": "x"}])
+
+        from services.protocol import conversation as conversation_module
+
+        request = conversation_module.ConversationRequest(prompt="p", model="gpt-image-2", n=1)
+
+        with mock.patch.object(conversation_module.account_service, "get_available_access_token", fake_get_token), \
+                mock.patch.object(conversation_module.account_service, "get_account", return_value={}), \
+                mock.patch.object(conversation_module.account_service, "release_image_slot"), \
+                mock.patch.object(conversation_module.account_service, "mark_image_result"), \
+                mock.patch.object(conversation_module.account_service, "is_shared_account_use", return_value=False), \
+                mock.patch.object(conversation_module, "OpenAIBackendAPI") as backend_cls, \
+                mock.patch.object(conversation_module, "stream_image_outputs", fake_stream):
+            backend_cls.return_value.access_token = "backend"
+            outputs = list(conversation_module._stream_image_outputs_with_pool(request))
+
+        return calls, outputs
+
+    def test_throttled_account_switches_and_succeeds(self) -> None:
+        throttled = RuntimeError(UPLOAD_THROTTLED_BODY)
+        calls, outputs = self._run_pool([throttled, None])
+        # 第一个账号限流后必须换号，第二个账号出图成功。
+        self.assertEqual(len(outputs), 1)
+        self.assertGreaterEqual(len(calls), 2)
+
+    def test_all_accounts_throttled_reports_quota(self) -> None:
+        throttled = RuntimeError(UPLOAD_THROTTLED_BODY)
+        with self.assertRaises(ImageGenerationError) as ctx:
+            self._run_pool([throttled, throttled, throttled, throttled, throttled])
+        self.assertIn("上传额度", str(ctx.exception))
+
+    def test_throttled_account_is_not_marked_unavailable(self) -> None:
+        """限流是临时配额，不能触发账号失败计数/清理。"""
+        throttled = RuntimeError(UPLOAD_THROTTLED_BODY)
+        from services.protocol import conversation as conversation_module
+
+        with mock.patch.object(conversation_module.account_service, "mark_image_result") as mark, \
+                mock.patch.object(
+                    conversation_module.account_service,
+                    "verify_free_account_after_image_failure",
+                ) as verify:
+            self._run_pool([throttled, None])
+        # 仅在成功账号上记 mark_image_result(True)；限流账号不得被记为失败。
+        for call in mark.call_args_list:
+            self.assertIs(call.args[1], True)
+        verify.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

web/src/app/settings/components/error-message-card.tsx

@@ -0,0 +1,579 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+import { AlertCircle, LoaderCircle, Plus, RefreshCw, Save, Sparkles, Trash2, WandSparkles } from "lucide-react";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import { Card, CardContent } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
+import {
+  clearUnconfiguredErrors,
+  fetchUnconfiguredErrors,
+  summarizeErrorMessage,
+  type ErrorMessageRule,
+  type UnconfiguredError,
+} from "@/lib/api";
+import { useSettingsStore } from "../store";
+
+/** 生成一个本地唯一 id：规则还没保存时也要能稳定定位每一行。 */
+function nextRuleId(existing: ErrorMessageRule[]): string {
+  const used = new Set(existing.map((rule) => rule.id));
+  let index = existing.length + 1;
+  while (used.has(`rule-${index}`)) {
+    index += 1;
+  }
+  return `rule-${index}`;
+}
+
+/** 新生成规则的高亮时长：覆盖「模型返回 6–10 秒 + 用户滚下去看」的整段过程。 */
+const HIGHLIGHT_MS = 6000;
+
+/** 多行/逗号分隔的关键词文本 <-> 数组。 */
+function keywordsToText(keywords: string[]): string {
+  return (keywords || []).join("\n");
+}
+
+function textToKeywords(text: string): string[] {
+  return text
+    .split(/[\n,，、]/)
+    .map((keyword) => keyword.trim())
+    .filter(Boolean);
+}
+
+export function ErrorMessageCard() {
+  const config = useSettingsStore((state) => state.config);
+  const isSaving = useSettingsStore((state) => state.isSavingConfig);
+  const setRules = useSettingsStore((state) => state.setErrorMessageRules);
+  const setFallbackEnabled = useSettingsStore((state) => state.setErrorMessageFallbackEnabled);
+  const setAiModel = useSettingsStore((state) => state.setErrorMessageAiModel);
+  const saveConfig = useSettingsStore((state) => state.saveConfig);
+
+  const rules = config?.error_message_rules ?? [];
+  const fallbackEnabled = config?.error_message_fallback_enabled === true;
+  const aiModel = String(config?.error_message_ai_model ?? "");
+
+  const [unconfigured, setUnconfigured] = useState<UnconfiguredError[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [clearing, setClearing] = useState(false);
+  const [pasteText, setPasteText] = useState("");
+  const [summarizing, setSummarizing] = useState(false);
+  /** 刚生成的规则 id：滚过去并高亮一下，避免「点了没反应」的错觉。 */
+  const [highlightId, setHighlightId] = useState<string | null>(null);
+  /** 最近一次「AI 归纳」的结果，直接贴在输入框下面，不用去列表里翻。 */
+  const [lastSuggestion, setLastSuggestion] = useState<
+    { ruleId: string; keywords: string[]; display: string; source: "ai" | "local"; model?: string } | null
+  >(null);
+
+  /** 归纳结果面板直接绑定刚生成的那条规则，可以在面板里就地修改。 */
+  const activeRule = lastSuggestion
+    ? rules.find((rule) => rule.id === lastSuggestion.ruleId) ?? null
+    : null;
+  const activeRuleIndex = activeRule ? rules.findIndex((rule) => rule.id === activeRule.id) : -1;
+
+  const loadUnconfigured = useCallback(async (silent = false) => {
+    if (!silent) {
+      setLoading(true);
+    }
+    try {
+      const data = await fetchUnconfiguredErrors();
+      setUnconfigured(data.items || []);
+    } catch {
+      if (!silent) {
+        toast.error("读取未配置报错失败");
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void loadUnconfigured();
+  }, [loadUnconfigured]);
+
+  // 归纳出的规则在输入框下方，页面上很容易滚出视野；这里主动滚过去并高亮。
+  // ⚠️ 模型归纳要等 6–10 秒，高亮必须撑到用户滚下去看完，2.8 秒会被完全错过。
+  useEffect(() => {
+    if (!highlightId) {
+      return;
+    }
+    const node = document.getElementById(`error-rule-${highlightId}`);
+    node?.scrollIntoView({ behavior: "smooth", block: "center" });
+    const timer = window.setTimeout(() => setHighlightId(null), HIGHLIGHT_MS);
+    return () => window.clearTimeout(timer);
+  }, [highlightId]);
+
+  const updateRule = (id: string, patch: Partial<ErrorMessageRule>) => {
+    setRules(rules.map((rule) => (rule.id === id ? { ...rule, ...patch } : rule)));
+  };
+
+  const addRule = (seed?: Partial<ErrorMessageRule>) => {
+    const rule: ErrorMessageRule = {
+      id: nextRuleId(rules),
+      keywords: [],
+      display: "",
+      enabled: true,
+      note: "",
+      ...seed,
+    };
+    setRules([...rules, rule]);
+    // 新加的行也滚过去高亮：不管从哪个入口加，都必须看得见。
+    setHighlightId(rule.id);
+    return rule.id;
+  };
+
+  /** 手动把视野拉回某条规则并重新高亮（高亮结束后还能再点一次）。 */
+  const focusRule = (id: string) => {
+    setHighlightId(null);
+    window.setTimeout(() => setHighlightId(id), 30);
+  };
+
+  const removeRule = (id: string) => {
+    setRules(rules.filter((rule) => rule.id !== id));
+  };
+
+  const handleClearUnconfigured = async (fingerprints?: string[]) => {
+    setClearing(true);
+    try {
+      const data = await clearUnconfiguredErrors(fingerprints);
+      setUnconfigured(data.items || []);
+      toast.success(fingerprints?.length ? "已忽略该条报错" : "已清空未配置报错");
+    } catch {
+      toast.error("操作失败");
+    } finally {
+      setClearing(false);
+    }
+  };
+
+  /**
+   * 粘贴一段报错，让模型归纳出关键词 + 大白话，直接追加成一条新规则。
+   * 后端保证不硬失败：模型不可用时会退化成「本地抽取关键词」。
+   */
+  const handleSummarize = async () => {
+    const text = pasteText.trim();
+    if (!text) {
+      toast.error("先把报错原文粘贴进来");
+      return;
+    }
+    setSummarizing(true);
+    try {
+      const suggestion = await summarizeErrorMessage(text);
+      const keywords = suggestion.keywords || [];
+      const display = suggestion.display || "";
+      if (!keywords.length && !display) {
+        toast.error("没能从中归纳出规则，请确认粘贴的是报错原文");
+        return;
+      }
+      const ruleId = addRule({
+        keywords,
+        display,
+        note: suggestion.source === "ai"
+          ? `AI 归纳（${suggestion.model || "默认模型"}）`
+          : "本地抽取（AI 不可用，请自行补文案）",
+      });
+      // 结果必须立刻可见：面板里内联出这条规则，可直接改、可直接存（addRule 已负责滚动 + 高亮）。
+      setLastSuggestion({
+        ruleId,
+        keywords,
+        display,
+        source: suggestion.source,
+        model: suggestion.model,
+      });
+      setPasteText("");
+      if (suggestion.source === "ai") {
+        const preview = keywords.slice(0, 2).join("、");
+        toast.success(`已生成规则：命中「${preview}${keywords.length > 2 ? " 等" : ""}」`);
+      } else if (display) {
+        toast.warning("AI 不可用，已退化为本地抽取关键词");
+      } else {
+        toast.warning("AI 不可用，已抽取关键词，请自行填写「显示给用户的大白话」");
+      }
+    } catch {
+      toast.error("归纳失败，请稍后重试");
+    } finally {
+      setSummarizing(false);
+    }
+  };
+
+  return (
+    <Card className="rounded-2xl border-stone-200 bg-white/90">
+      <CardContent className="space-y-6 p-5 sm:p-6">
+        <div>
+          <h2 className="text-lg font-semibold tracking-tight">报错文案</h2>
+          <p className="mt-1 text-sm text-stone-500">
+            把上游/后端返回的技术报错翻译成用户看得懂的大白话。只替换前台展示，后台日志仍保留原始报错，方便排查。
+          </p>
+        </div>
+
+        {/* --------------------------------------------------- 粘贴 + AI 归纳 */}
+        <div className="space-y-3 border-t border-stone-100 pt-5">
+          <div className="rounded-xl border border-stone-200 bg-stone-50 p-3">
+            <div className="flex items-start justify-between gap-3">
+              <div>
+                <h3 className="flex items-center gap-2 text-sm font-medium text-stone-900">
+                  <WandSparkles className="size-4 text-stone-500" />
+                  粘贴报错，自动归纳
+                </h3>
+                <p className="mt-1 text-xs text-stone-500">
+                  把后台日志或用户反馈里的原始报错整段粘进来，自动生成关键词和给用户看的大白话。
+                </p>
+              </div>
+              <Button
+                className="shrink-0 rounded-xl"
+                disabled={summarizing}
+                onClick={() => void handleSummarize()}
+              >
+                {summarizing ? <LoaderCircle className="size-4 animate-spin" /> : <WandSparkles className="size-4" />}
+                {summarizing ? "归纳中…" : "AI 归纳"}
+              </Button>
+            </div>
+            <Textarea
+              rows={3}
+              value={pasteText}
+              placeholder={'整段粘贴，例如：\n/backend-api/files failed: status=429, body={"detail": {"code": "throttled", "reason": "upload_protection_limit_exceeded"}}'}
+              onChange={(event) => setPasteText(event.target.value)}
+              className="mt-3 rounded-xl border-stone-200 bg-white font-mono text-xs"
+            />
+            <div className="mt-2 flex flex-wrap items-center justify-between gap-2">
+              <div className="flex items-center gap-2">
+                <span className="whitespace-nowrap text-xs text-stone-500">归纳用模型</span>
+                <Input
+                  value={aiModel}
+                  placeholder="留空 = 池子默认文本模型"
+                  onChange={(event) => setAiModel(event.target.value)}
+                  className="h-8 w-56 rounded-lg border-stone-200 bg-white text-xs"
+                />
+              </div>
+              {pasteText ? (
+                <Button variant="ghost" size="sm" className="rounded-lg" onClick={() => setPasteText("")}>
+                  清空
+                </Button>
+              ) : null}
+            </div>
+            {summarizing ? (
+              <p className="mt-2 text-xs text-stone-500">正在调用模型归纳，通常需要 5–10 秒…</p>
+            ) : null}
+            {lastSuggestion && activeRule ? (
+              <div className="mt-3 rounded-xl border border-emerald-300 bg-emerald-50 p-3 text-xs text-emerald-900">
+                <div className="flex items-start justify-between gap-2">
+                  <span className="flex items-center gap-1.5 font-medium">
+                    <Sparkles className="size-3.5" />
+                    {lastSuggestion.source === "ai"
+                      ? `已归纳出规则（${lastSuggestion.model || "默认模型"}）`
+                      : "AI 不可用，已用本地规则抽取关键词"}
+                  </span>
+                  <button
+                    type="button"
+                    className="shrink-0 text-emerald-700 hover:underline"
+                    onClick={() => setLastSuggestion(null)}
+                  >
+                    收起
+                  </button>
+                </div>
+
+                {/* 就地可改：这里改的就是列表里的那条规则，不用去下面找。 */}
+                <div className="mt-3 grid gap-3 md:grid-cols-[1fr_1fr]">
+                  <div className="space-y-1.5">
+                    <span className="font-medium text-emerald-800">关键词（每行一个）</span>
+                    <Textarea
+                      rows={3}
+                      value={keywordsToText(activeRule.keywords)}
+                      onChange={(event) => updateRule(activeRule.id, { keywords: textToKeywords(event.target.value) })}
+                      className="rounded-lg border-emerald-200 bg-white font-mono text-xs"
+                    />
+                  </div>
+                  <div className="space-y-1.5">
+                    <span className="font-medium text-emerald-800">显示给用户的大白话</span>
+                    <Textarea
+                      rows={3}
+                      value={activeRule.display}
+                      onChange={(event) => updateRule(activeRule.id, { display: event.target.value })}
+                      className="rounded-lg border-emerald-200 bg-white text-xs"
+                    />
+                  </div>
+                </div>
+
+                <div className="mt-3 flex flex-wrap items-center justify-between gap-2">
+                  <span className="text-emerald-800">
+                    已在下方「匹配规则」<b>第 {activeRuleIndex + 1} 条</b>（共 {rules.length} 条），并高亮{" "}
+                    {HIGHLIGHT_MS / 1000} 秒。
+                  </span>
+                  <div className="flex items-center gap-2">
+                    <Button
+                      variant="outline"
+                      size="sm"
+                      className="rounded-lg"
+                      onClick={() => focusRule(activeRule.id)}
+                    >
+                      滚到列表查看
+                    </Button>
+                    <Button
+                      size="sm"
+                      className="rounded-lg"
+                      disabled={isSaving}
+                      onClick={() => void saveConfig()}
+                    >
+                      {isSaving ? <LoaderCircle className="size-3.5 animate-spin" /> : <Save className="size-3.5" />}
+                      保存设置
+                    </Button>
+                  </div>
+                </div>
+                <p className="mt-2 text-emerald-700">
+                  确认无误后点「保存设置」才会真正生效；不保存的话刷新页面就丢了。
+                </p>
+              </div>
+            ) : null}
+            {lastSuggestion && !activeRule ? (
+              <div className="mt-3 rounded-xl border border-amber-200 bg-amber-50 p-3 text-xs text-amber-800">
+                刚才归纳出的那条规则已经被删掉了。
+                <button
+                  type="button"
+                  className="ml-2 text-amber-700 underline"
+                  onClick={() => setLastSuggestion(null)}
+                >
+                  知道了
+                </button>
+              </div>
+            ) : null}
+          </div>
+        </div>
+
+        {/* --------------------------------------------------------- 规则列表 */}
+        <div className="space-y-3 border-t border-stone-100 pt-5">
+          <div className="flex items-start justify-between gap-3">
+            <div>
+              <h3 className="font-medium text-stone-900">匹配规则</h3>
+              <p className="mt-1 text-xs text-stone-500">
+                报错原文包含<b>任意一个</b>关键词即命中（不区分大小写），命中后前台显示右边的大白话。多个关键词一行一个 —— <b>关键词��多，规则越宽</b>，不要写太通用的词（如 /backend-api/files、status=500 单独出现时会误伤其它报错）。
+              </p>
+            </div>
+            <Button variant="outline" className="shrink-0 rounded-xl" onClick={() => addRule()}>
+              <Plus className="size-4" />
+              添加规则
+            </Button>
+          </div>
+
+          {rules.length === 0 ? (
+            <div className="rounded-xl border border-dashed border-stone-200 bg-stone-50 px-4 py-8 text-center text-sm text-stone-500">
+              还没有任何规则。可以把报错粘到上面的框里点「AI 归纳」自动生成，或点右上角「添加规则」手动填。
+              <br />
+              未命中的报错会原样显示，并出现在下方「未配置报错」里。
+            </div>
+          ) : (
+            <div className="space-y-3">
+              {rules.map((rule) => {
+                const keywordCount = rule.keywords.length;
+                const invalid = keywordCount === 0 || !rule.display.trim();
+                const highlighted = highlightId === rule.id;
+                return (
+                  <div
+                    key={rule.id}
+                    id={`error-rule-${rule.id}`}
+                    className={`rounded-xl border p-3 transition-all ${
+                      highlighted
+                        ? "border-emerald-400 bg-emerald-50 shadow-md ring-2 ring-emerald-300"
+                        : "border-stone-200 bg-stone-50"
+                    }`}
+                  >
+                    {highlighted ? (
+                      <div className="mb-2 flex items-center gap-2">
+                        <span className="inline-flex items-center gap-1 rounded-full bg-emerald-600 px-2 py-0.5 text-xs font-medium text-white">
+                          <Sparkles className="size-3" />
+                          刚生成，还没保存
+                        </span>
+                        <button
+                          type="button"
+                          className="text-xs text-emerald-700 hover:underline"
+                          onClick={() => setHighlightId(null)}
+                        >
+                          取消高亮
+                        </button>
+                      </div>
+                    ) : null}
+                    <div className="grid gap-3 md:grid-cols-[1fr_1fr]">
+                      <div className="space-y-1.5">
+                        <label className="text-xs font-medium text-stone-600">
+                          关键词{keywordCount > 0 ? `（${keywordCount}）` : ""}
+                        </label>
+                        <Textarea
+                          rows={3}
+                          value={keywordsToText(rule.keywords)}
+                          placeholder={"每行一个，例如：\nstatus=429\nupload_protection_limit_exceeded"}
+                          onChange={(event) => updateRule(rule.id, { keywords: textToKeywords(event.target.value) })}
+                          className="rounded-xl border-stone-200 bg-white text-sm"
+                        />
+                      </div>
+                      <div className="space-y-1.5">
+                        <label className="text-xs font-medium text-stone-600">显示给用户的大白话</label>
+                        <Textarea
+                          rows={3}
+                          value={rule.display}
+                          placeholder="例如：当前上传人数较多，请稍后重试"
+                          onChange={(event) => updateRule(rule.id, { display: event.target.value })}
+                          className="rounded-xl border-stone-200 bg-white text-sm"
+                        />
+                      </div>
+                    </div>
+                    <div className="mt-2 flex items-center justify-between gap-3">
+                      <label className="flex items-center gap-2 text-sm text-stone-600">
+                        <input
+                          type="checkbox"
+                          checked={rule.enabled}
+                          onChange={(event) => updateRule(rule.id, { enabled: event.target.checked })}
+                        />
+                        启用
+                      </label>
+                      <div className="flex items-center gap-3">
+                        {invalid ? (
+                          <span className="text-xs text-amber-600">缺关键词或文案，保存时会被丢弃</span>
+                        ) : null}
+                        <Button
+                          variant="ghost"
+                          size="icon"
+                          title="删除该规则"
+                          onClick={() => removeRule(rule.id)}
+                        >
+                          <Trash2 className="size-4 text-stone-500" />
+                        </Button>
+                      </div>
+                    </div>
+                  </div>
+                );
+              })}
+            </div>
+          )}
+        </div>
+
+        {/* --------------------------------------------------------- 兜底开关 */}
+        <div className="space-y-3 border-t border-stone-100 pt-5">
+          <label className="flex items-start gap-3">
+            <input
+              type="checkbox"
+              className="mt-1"
+              checked={fallbackEnabled}
+              onChange={(event) => setFallbackEnabled(event.target.checked)}
+            />
+            <span>
+              <span className="text-sm font-medium text-stone-900">未匹配时报错也兜底成通用文案</span>
+              <span className="mt-1 block text-xs text-stone-500">
+                勾选后，未命中规则的报错前台统一显示「操作失败，请稍后重试」。不勾选则原样显示技术报错（默认，便于你先补规则）。
+              </span>
+            </span>
+          </label>
+        </div>
+
+        {/* ------------------------------------------------------- 未配置报错 */}
+        <div className="space-y-3 border-t border-stone-100 pt-5">
+          <div className="flex items-start justify-between gap-3">
+            <div>
+              <h3 className="flex items-center gap-2 font-medium text-stone-900">
+                <AlertCircle className="size-4 text-amber-500" />
+                未配置报错
+                {unconfigured.length > 0 ? (
+                  <span className="rounded-full bg-amber-100 px-2 py-0.5 text-xs font-medium text-amber-700">
+                    {unconfigured.length}
+                  </span>
+                ) : null}
+              </h3>
+              <p className="mt-1 text-xs text-stone-500">
+                自动收集还匹配不到规则的报错。照着补一条规则，前台就再也看不到这些代码了。
+              </p>
+            </div>
+            <div className="flex shrink-0 items-center gap-2">
+              <Button
+                variant="outline"
+                size="icon"
+                className="rounded-xl"
+                title="刷新"
+                disabled={loading}
+                onClick={() => void loadUnconfigured()}
+              >
+                {loading ? <LoaderCircle className="size-4 animate-spin" /> : <RefreshCw className="size-4" />}
+              </Button>
+              <Button
+                variant="outline"
+                className="rounded-xl"
+                disabled={clearing || unconfigured.length === 0}
+                onClick={() => void handleClearUnconfigured()}
+              >
+                <Trash2 className="size-4" />
+                全部忽略
+              </Button>
+            </div>
+          </div>
+
+          {unconfigured.length === 0 ? (
+            <div className="rounded-xl border border-dashed border-stone-200 bg-stone-50 px-4 py-6 text-center text-sm text-stone-500">
+              {loading ? "读取中…" : "暂无未配置报错，规则已覆盖当前所有报错。"}
+            </div>
+          ) : (
+            <div className="space-y-2">
+              {unconfigured.map((item) => (
+                <div
+                  key={item.fingerprint}
+                  className="rounded-xl border border-stone-200 bg-stone-50 p-3"
+                >
+                  <div className="flex items-start justify-between gap-3">
+                    <div className="min-w-0 flex-1">
+                      <div className="flex flex-wrap items-center gap-2 text-xs text-stone-500">
+                        <span className="rounded-full bg-stone-200 px-2 py-0.5 font-medium text-stone-700">
+                          出现 {item.count} 次
+                        </span>
+                        {item.channel ? <span>来源：{item.channel}</span> : null}
+                        {item.last_seen ? <span>最近：{item.last_seen}</span> : null}
+                      </div>
+                      <pre className="mt-2 max-h-32 overflow-auto whitespace-pre-wrap break-all rounded-lg bg-white p-2 text-xs text-stone-600">
+                        {item.sample}
+                      </pre>
+                    </div>
+                  </div>
+                  <div className="mt-2 flex items-center justify-end gap-2">
+                    <Button
+                      variant="outline"
+                      className="rounded-xl"
+                      onClick={() =>
+                        addRule({
+                          // 后端已从这段报错里抽好候选关键词；抽不到才退回原文片段。
+                          keywords: item.keywords?.length ? item.keywords : [item.sample.slice(0, 60)],
+                          note: `来自未配置报错 ${item.fingerprint}`,
+                        })
+                      }
+                    >
+                      <Sparkles className="size-4" />
+                      以此为模板新建规则
+                    </Button>
+                    <Button
+                      variant="ghost"
+                      size="icon"
+                      title="忽略该条"
+                      disabled={clearing}
+                      onClick={() => void handleClearUnconfigured([item.fingerprint])}
+                    >
+                      <Trash2 className="size-4 text-stone-500" />
+                    </Button>
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+
+        {/* ----------------------------------------------------------- 保存 */}
+        <div className="flex items-center justify-between gap-3 border-t border-stone-100 pt-5">
+          <p className="text-xs text-stone-500">
+            共 {rules.length} 条规则，其中 {rules.filter((rule) => rule.enabled).length} 条已启用。
+          </p>
+          <Button
+            className="rounded-xl"
+            disabled={isSaving}
+            onClick={() => void saveConfig()}
+          >
+            {isSaving ? <LoaderCircle className="size-4 animate-spin" /> : <Save className="size-4" />}
+            保存设置
+          </Button>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}

web/src/app/settings/components/skills-card.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useEffect, useMemo, useRef, useState } from "react";
-import { Archive, CloudDownload, Download, Eye, EyeOff, Link2, LoaderCircle, PackageOpen, Pencil, Presentation, RefreshCw, Search, ShieldCheck, ShieldOff, Trash2, UploadCloud, X } from "lucide-react";
+import { Archive, CloudDownload, Download, Eye, EyeOff, Link2, ListChecks, LoaderCircle, PackageOpen, Pencil, Presentation, RefreshCw, Search, ShieldCheck, ShieldOff, Trash2, UploadCloud, X } from "lucide-react";
 import { toast } from "sonner";
 
 import { Button } from "@/components/ui/button";
@@ -14,6 +14,7 @@ import { SkillCoverThumbnail, SkillOriginLine, SkillShowcase } from "@/app/chat/
 import { SkillPresentationEditor } from "@/app/settings/components/skill-presentation-editor";
 import {
   deleteInstalledSkill,
+  deleteInstalledSkills,
   exportSkillsArchive,
   fetchAdminSkillRuntime,
   fetchInstalledSkills,
@@ -87,6 +88,8 @@ export function SkillsCard() {
   const [groupMode, setGroupMode] = useState<GroupMode>("none");
   const [categoryFilter, setCategoryFilter] = useState(ALL);
   const [tagFilters, setTagFilters] = useState<string[]>([]);
+  const [selectMode, setSelectMode] = useState(false);
+  const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
   const fileRef = useRef<HTMLInputElement>(null);
 
   const refresh = async () => {
@@ -104,6 +107,17 @@ export function SkillsCard() {
     void refresh();
   }, []);
 
+  // Keep the multi-select set in sync with the install list so deleted Skills
+  // disappear from the selection instead of being counted as ghost rows.
+  useEffect(() => {
+    setSelectedIds((current) => {
+      if (!current.size) return current;
+      const live = new Set(items.map((item) => item.id));
+      const next = new Set([...current].filter((id) => live.has(id)));
+      return next.size === current.size ? current : next;
+    });
+  }, [items]);
+
   /** Categories present in the current install, most populated first. */
   const categoryOptions = useMemo(() => {
     const counts = new Map<string, number>();
@@ -263,6 +277,40 @@ export function SkillsCard() {
     }
   };
 
+  const toggleSelect = (id: string, checked: boolean) => {
+    setSelectedIds((current) => {
+      const next = new Set(current);
+      if (checked) next.add(id);
+      else next.delete(id);
+      return next;
+    });
+  };
+
+  const selectAllFiltered = () => {
+    setSelectedIds(new Set(filtered.map((item) => item.id)));
+  };
+
+  const clearSelection = () => setSelectedIds(new Set());
+
+  const removeSelected = async () => {
+    const targets = filtered.filter((item) => selectedIds.has(item.id));
+    if (!targets.length) return;
+    const preview = targets.slice(0, 10).map((item) => `· ${item.name}`).join("\n");
+    const suffix = targets.length > 10 ? `\n…等共 ${targets.length} 个` : "";
+    if (!window.confirm(`确定删除选中的 ${targets.length} 个 Skill 吗？删除后不可恢复。\n\n${preview}${suffix}`)) return;
+    setWorking(true);
+    try {
+      const result = await deleteInstalledSkills(targets.map((item) => item.id));
+      setItems(result.items);
+      toast.success(`已删除 ${result.deleted.length} 个 Skill`);
+      if (result.missing.length) toast.warning(`${result.missing.length} 个 Skill 未找到，已被跳过`);
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "批量删除失败");
+    } finally {
+      setWorking(false);
+    }
+  };
+
   const toggleScripts = async (item: InstalledSkill) => {
     const next = !item.scripts_allowed;
     if (next && !window.confirm(`允许 Skill「${item.name}」执行其 scripts/ 目录中的代码吗？仅应为你信任的来源开启。`)) return;
@@ -410,6 +458,19 @@ export function SkillsCard() {
                 </SelectContent>
               </Select>
             </div>
+            <Button
+              variant={selectMode ? "default" : "outline"}
+              size="sm"
+              className="h-10 rounded-xl border-stone-200 px-3"
+              disabled={working || !items.length}
+              title={selectMode ? "退出多选模式" : "勾选多个 Skill 后批量删除"}
+              onClick={() => {
+                setSelectMode((current) => !current);
+                setSelectedIds(new Set());
+              }}
+            >
+              <ListChecks className="size-4" />{selectMode ? "退出多选" : "多选"}
+            </Button>
             <span className="rounded-full bg-white px-2.5 py-1 text-xs text-stone-500 ring-1 ring-stone-200">
               {filtering ? `${filtered.length} / ${items.length}` : items.length} 个 Skill
             </span>
@@ -467,6 +528,28 @@ export function SkillsCard() {
           ) : null}
         </div>
 
+        {selectMode ? (
+          <div className="flex flex-wrap items-center gap-2 rounded-2xl border border-stone-200 bg-white px-4 py-2.5">
+            <span className="text-sm text-stone-600">
+              已选 <span className="font-semibold text-stone-900">{selectedIds.size}</span> 个
+              {filtering ? <span className="text-xs text-stone-400">（当前筛选 {filtered.length} 个）</span> : null}
+            </span>
+            <Button variant="ghost" size="sm" disabled={working || !filtered.length} onClick={selectAllFiltered}>全选当前筛选</Button>
+            <Button variant="ghost" size="sm" disabled={working || !selectedIds.size} onClick={clearSelection}>清空选择</Button>
+            <div className="min-w-4 flex-1" />
+            <Button
+              variant="outline"
+              size="sm"
+              className="border-red-200 text-red-600 hover:bg-red-50 hover:text-red-700"
+              disabled={working || !selectedIds.size}
+              title="删除所有勾选的 Skill（不可恢复）"
+              onClick={() => void removeSelected()}
+            >
+              <Trash2 className="size-3.5" />删除所选
+            </Button>
+          </div>
+        ) : null}
+
         {loading ? (
           <div className="flex items-center justify-center gap-2 rounded-2xl border border-stone-200 bg-white p-8 text-sm text-stone-500"><LoaderCircle className="size-4 animate-spin" />正在读取</div>
         ) : groups.every((group) => !group.items.length) ? (
@@ -488,6 +571,14 @@ export function SkillsCard() {
                   {group.items.map((item) => (
                     <div key={item.id} data-skill-id={item.id} className="flex items-start justify-between gap-4 px-4 py-3">
                       <div className="flex min-w-0 gap-3">
+                        {selectMode ? (
+                          <Checkbox
+                            className="mt-1 shrink-0"
+                            checked={selectedIds.has(item.id)}
+                            onCheckedChange={(checked) => toggleSelect(item.id, checked === true)}
+                            aria-label={`选择 ${item.name}`}
+                          />
+                        ) : null}
                         <SkillCoverThumbnail skillId={item.id} asset={item.presentation_summary?.cover} className="aspect-[4/3] w-32 shrink-0 self-start" />
                         <div className="min-w-0 space-y-1">
                         <div className="font-medium text-stone-900">{item.name}</div>

web/src/app/settings/page.tsx

@@ -13,6 +13,7 @@ import { ConfigCard } from "./components/config-card";
 import { CheckinSettingsCard } from "./components/checkin-settings-card";
 import { CPAPoolDialog } from "./components/cpa-pool-dialog";
 import { CPAPoolsCard } from "./components/cpa-pools-card";
+import { ErrorMessageCard } from "./components/error-message-card";
 import { ImportBrowserDialog } from "./components/import-browser-dialog";
 import { NavigationSettingsCard } from "./components/navigation-settings-card";
 import { ProxyRuntimeCard } from "./components/proxy-runtime-card";
@@ -35,6 +36,7 @@ const settingsTabs = [
   { value: "image-api", title: "API 接入" },
   { value: "users", title: "用户" },
   { value: "checkin", title: "签到页" },
+  { value: "error-message", title: "报错文案" },
   { value: "shop-codes", title: "卡密管理" },
   { value: "cpa", title: "CPA" },
   { value: "sub2api", title: "Sub2API" },
@@ -132,6 +134,9 @@ function SettingsPageContent() {
         <TabsContent value="checkin" keepMounted>
           <CheckinSettingsCard />
         </TabsContent>
+        <TabsContent value="error-message" keepMounted>
+          <ErrorMessageCard />
+        </TabsContent>
         <TabsContent value="shop-codes" keepMounted>
           <ShopCodesCard />
         </TabsContent>

web/src/app/settings/store.ts

@@ -46,12 +46,65 @@ import {
   type SettingsConfig,
 } from "@/lib/api";
 
-import { DEFAULT_CHECKIN_CONTENT, type CheckinContent } from "@/lib/api";
+import { DEFAULT_CHECKIN_CONTENT, type CheckinContent, type ErrorMessageRule } from "@/lib/api";
 
 export const PAGE_SIZE_OPTIONS = ["50", "100", "200"] as const;
 
 export type PageSizeOption = (typeof PAGE_SIZE_OPTIONS)[number];
 
+/**
+ * 轻量整形报错文案规则：**保留空规则**，只做类型归一和 id 去重。
+ *
+ * 编辑态必须用它而不是 normalizeErrorMessageRules —— 刚点「添加规则」时
+ * 关键词和文案都是空的，若在这里做「缺字段就丢弃」的清洗，新增的那一行
+ * 会被立刻删掉，表现为「点添加规则没反应」。
+ */
+function coerceErrorMessageRules(value: unknown): ErrorMessageRule[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const rules: ErrorMessageRule[] = [];
+  const seen = new Set<string>();
+  value.forEach((raw, index) => {
+    if (!raw || typeof raw !== "object") {
+      return;
+    }
+    const item = raw as Partial<ErrorMessageRule>;
+    const keywords = Array.isArray(item.keywords)
+      ? item.keywords.map((keyword) => String(keyword ?? "").trim()).filter(Boolean)
+      : String(item.keywords ?? "")
+        .split(/[\n,，、]/)
+        .map((keyword) => keyword.trim())
+        .filter(Boolean);
+    let id = String(item.id ?? "").trim() || `rule-${index + 1}`;
+    let suffix = 1;
+    while (seen.has(id)) {
+      suffix += 1;
+      id = `${id}-${suffix}`;
+    }
+    seen.add(id);
+    rules.push({
+      id,
+      keywords,
+      display: String(item.display ?? ""),
+      enabled: item.enabled !== false,
+      note: String(item.note ?? ""),
+    });
+  });
+  return rules;
+}
+
+/**
+ * 严格归一化报错文案规则：丢掉缺关键词或缺文案的无效项，并保证 id 不重复。
+ * 与后端 services/error_message_service.py 的 normalize_rules 行为保持一致，
+ * **只用于提交给后端的那一刻**（保存路径），不要用在编辑态 setter 上。
+ */
+function normalizeErrorMessageRules(value: unknown): ErrorMessageRule[] {
+  return coerceErrorMessageRules(value).filter(
+    (rule) => rule.keywords.length > 0 && rule.display.trim().length > 0,
+  );
+}
+
 const DEFAULT_FREE_ACCOUNT_CLEANUP: FreeAccountCleanupSettings = {
   enabled: false,
   interval_minutes: 10,
@@ -412,6 +465,9 @@ function normalizeConfig(config: SettingsConfig): SettingsConfig {
     checkin_daily_credits: Number(config.checkin_daily_credits ?? config.normal_user_daily_credits ?? 0),
     checkin_credit_valid_days: Math.max(0, Number(config.checkin_credit_valid_days) || 0),
     checkin_content: { ...DEFAULT_CHECKIN_CONTENT, ...(config.checkin_content || {}) },
+    error_message_rules: coerceErrorMessageRules(config.error_message_rules),
+    error_message_fallback_enabled: config.error_message_fallback_enabled === true,
+    error_message_ai_model: String(config.error_message_ai_model || ""),
     internal_image_model_daily_limits: normalizeInternalImageModelDailyLimits(config.internal_image_model_daily_limits),
     wechat_login_enabled: config.wechat_login_enabled !== false,
     wechat_auto_register_enabled: config.wechat_auto_register_enabled !== false,
@@ -619,6 +675,9 @@ type SettingsStore = {
   setCheckinCreditValidDays: (value: string) => void;
   setCheckinAds: (value: Array<{ title?: string; image_url?: string; link_url?: string; enabled?: boolean; layout?: string }>) => void;
   setCheckinContent: (value: Partial<CheckinContent>) => void;
+  setErrorMessageRules: (value: ErrorMessageRule[]) => void;
+  setErrorMessageFallbackEnabled: (value: boolean) => void;
+  setErrorMessageAiModel: (value: string) => void;
   setInternalImageModelDailyLimits: (value: ImageModelDailyLimit[]) => void;
   setWechatLoginEnabled: (value: boolean) => void;
   setWechatAutoRegisterEnabled: (value: boolean) => void;
@@ -801,6 +860,9 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
         checkin_daily_credits: Math.max(0, Number(config.checkin_daily_credits) || 0),
         checkin_credit_valid_days: Math.max(0, Number(config.checkin_credit_valid_days) || 0),
         checkin_content: { ...DEFAULT_CHECKIN_CONTENT, ...(config.checkin_content || {}) },
+        error_message_rules: normalizeErrorMessageRules(config.error_message_rules),
+        error_message_fallback_enabled: config.error_message_fallback_enabled === true,
+        error_message_ai_model: String(config.error_message_ai_model || "").trim(),
         internal_image_model_daily_limits: normalizeInternalImageModelDailyLimits(config.internal_image_model_daily_limits),
         wechat_login_enabled: config.wechat_login_enabled !== false,
         wechat_auto_register_enabled: config.wechat_auto_register_enabled !== false,
@@ -1027,6 +1089,25 @@ export const useSettingsStore = create<SettingsStore>((set, get) => ({
       : {});
   },
 
+  setErrorMessageRules: (value) => {
+    // ⚠️ 配置还没加载完时不能静默丢弃：否则「添加规则���看起来完全没反应，
+    // 而且归纳出的规则会「凭空消失」，排查成本极高。
+    const { config } = get();
+    if (!config) {
+      toast.error("配置还没加载完，请稍后再试");
+      return;
+    }
+    set({ config: { ...config, error_message_rules: coerceErrorMessageRules(value) } });
+  },
+
+  setErrorMessageFallbackEnabled: (value) => {
+    set((state) => state.config ? { config: { ...state.config, error_message_fallback_enabled: value } } : {});
+  },
+
+  setErrorMessageAiModel: (value) => {
+    set((state) => state.config ? { config: { ...state.config, error_message_ai_model: value } } : {});
+  },
+
   setInternalImageModelDailyLimits: (value) => {
     set((state) => state.config ? { config: { ...state.config, internal_image_model_daily_limits: normalizeInternalImageModelDailyLimits(value) } } : {});
   },

web/src/lib/api.ts

@@ -333,6 +333,14 @@ export async function deleteInstalledSkill(skillId: string) {
   });
 }
 
+/** Delete several Skills in one call; unknown ids come back in `missing`. */
+export async function deleteInstalledSkills(ids: string[]) {
+  return httpRequest<{ deleted: string[]; missing: string[]; items: InstalledSkill[] }>(
+    "/api/admin/skills/batch-delete",
+    { method: "POST", body: { ids } },
+  );
+}
+
 /** Reinstall a Skill from the source recorded in its .install.json. */
 export async function updateInstalledSkill(skillId: string) {
   return httpRequest<{ installed: InstalledSkill[]; items: InstalledSkill[] }>(
@@ -770,6 +778,12 @@ export type SettingsConfig = {
   /** 签到赠送积分的可用天数；0（默认）= 永久有效，>0 则在发放 N 天后过期作废。 */
   checkin_credit_valid_days?: number | string;
   checkin_content?: Partial<CheckinContent>;
+  /** 报错文案映射规则：命中关键词就把技术报错替换成大白话，只影响前台展示。 */
+  error_message_rules?: ErrorMessageRule[];
+  /** 未命中规则时是否使用兜底文案（关 = 原样显示技术报错）。 */
+  error_message_fallback_enabled?: boolean;
+  /** 「AI 归纳」使用的模型；留空则用池子默认文本模型。 */
+  error_message_ai_model?: string;
   internal_image_model_daily_limits?: ImageModelDailyLimit[];
   wechat_login_enabled?: boolean;
   wechat_auto_register_enabled?: boolean;
@@ -2918,6 +2932,62 @@ export type CheckinSummary = {
   credits: { credits?: number; daily_credits_remaining?: number; [key: string]: unknown };
 };
 
+/** 报错文案映射规则：命中任意关键词，就把原始技术报错替换成 display（大白话）。 */
+export type ErrorMessageRule = {
+  id: string;
+  /** 关键词列表；报错原文（小写）包含任意一个即命中。 */
+  keywords: string[];
+  /** 命中后展示给用户的文案（大白话）。 */
+  display: string;
+  enabled: boolean;
+  note?: string;
+};
+
+/** 一条「未配置报错」：命中不了任何规则、被自动收集下来等待补规则。 */
+export type UnconfiguredError = {
+  fingerprint: string;
+  /** 报错原文样本（可能被截断）。 */
+  sample: string;
+  count: number;
+  /** 来源链路，如 api / image_task / editable_file_task。 */
+  channel?: string;
+  first_seen?: string;
+  last_seen?: string;
+  /** 后端从小样本里抽出的候选关键词，可直接用于新建规则。 */
+  keywords?: string[];
+};
+
+export async function fetchUnconfiguredErrors() {
+  return httpRequest<{ items: UnconfiguredError[] }>("/api/error-messages/unconfigured");
+}
+
+/** 清空未配置报错；传 fingerprints 只清指定的几条，不传则全清。 */
+export async function clearUnconfiguredErrors(fingerprints?: string[]) {
+  return httpRequest<{ removed: number; items: UnconfiguredError[] }>("/api/error-messages/unconfigured/clear", {
+    method: "POST",
+    body: { fingerprints: fingerprints ?? [] },
+  });
+}
+
+/** 「AI 归纳」的结果：关键词 + 大白话文案。source 标明是模型给还是本地兜底抽取。 */
+export type ErrorMessageSuggestion = {
+  keywords: string[];
+  display: string;
+  source: "ai" | "local";
+  /** 实际使用的模型名（source=ai 时有值）。 */
+  model?: string;
+  /** 降级到本地抽取的原因（source=local 时有值）。 */
+  reason?: string;
+};
+
+/** 粘贴一条报错原文，让模型归纳出可用的规则（关键词 + 大白话）。 */
+export async function summarizeErrorMessage(text: string) {
+  return httpRequest<ErrorMessageSuggestion>("/api/error-messages/summarize", {
+    method: "POST",
+    body: { text },
+  });
+}
+
 export async function fetchCheckin() {
   return httpRequest<CheckinSummary>("/api/checkin");
 }