clean: fresh lightweight repo

.gitignore

@@ -0,0 +1,3 @@
+models/
+inputs/
+__pycache__/

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.12
+WORKDIR /app
+
+RUN pip install --no-cache-dir --timeout 120 fastapi uvicorn requests pyyaml numpy httpx python-docx openpyxl python-pptx pdfplumber "xlrd==1.2.0" tavily-python ebooklib beautifulsoup4 mobi
+RUN pip install --no-cache-dir --timeout 120 torch --index-url https://download.pytorch.org/whl/cpu
+RUN pip install --no-cache-dir --timeout 120 sentence-transformers faiss-cpu
+# llama-cpp-python 预编译 wheel（30 秒，不需编译）
+RUN pip install --no-cache-dir --timeout 300 "llama-cpp-python>=0.3.4" \
+    --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu
+
+# 模型在 app.py startup 时按需下载（避免每次代码变更重下 4GB）
+# 全部源码、工具、配置 → 构建进镜像
+COPY app.py /app/
+COPY scripts /app/scripts/
+COPY services /app/services/
+COPY skills /app/skills/
+
+# 自动拉取第三方技能（@ai install-skill 安装后自动进下次构建）
+RUN git clone --depth 1 --single-branch https://github.com/hughyonng/OpenWolf.git /tmp/update \
+    && cp -r /tmp/update/skills/third-party /app/skills/ 2>/dev/null || true \
+    && cp -r /tmp/update/skills/library /app/skills/ 2>/dev/null || true \
+    && rm -rf /tmp/update
+
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,1150 @@
+"""
+OpenWolf HF Spaces — FastAPI 入口
+ML 依赖在 startup 时自动安装，保持 Docker 构建轻量
+"""
+import os
+import sys
+import json
+import asyncio
+import time
+import threading
+import uuid
+import requests
+import re
+import hashlib
+import random
+import base64
+import shutil
+from pathlib import Path
+from fastapi import FastAPI, Request, HTTPException, BackgroundTasks
+import concurrent.futures
+from fastapi.responses import JSONResponse
+
+sys.path.insert(0, "/app")
+
+# ── 设默认环境变量 ──
+os.environ.setdefault("ISSUE_NUMBER", "0")
+os.environ.setdefault("COMMENT_BODY", "")
+os.environ.setdefault("COMMENT_USER", "spaces")
+os.environ.setdefault("GITHUB_REPO", "hughyonng/OpenWolf")
+os.environ.setdefault("GITHUB_TOKEN", os.environ.get("GITHUB_PAT", ""))
+os.environ.setdefault("OPENWOLF_PAT", os.environ.get("GITHUB_PAT", ""))
+os.environ.setdefault("TELEGRAM_BOT_TOKEN", "")
+os.environ.setdefault("TELEGRAM_CHAT_ID", "")
+
+app = FastAPI(title="OpenWolf Agent with Cloud Acceleration")
+
+@app.exception_handler(Exception)
+async def _catch_all(request: Request, exc: Exception):
+    print(f"[FATAL] {request.method} {request.url.path}: {exc}")
+    return JSONResponse({"ok": False, "error": str(exc)}, status_code=500)
+
+_ready = False
+_model_loading = False
+_model_loaded = False
+_background_tasks = set()
+_extract_executor = concurrent.futures.ThreadPoolExecutor(max_workers=1, thread_name_prefix="extract")
+_translate_pool = concurrent.futures.ThreadPoolExecutor(max_workers=2, thread_name_prefix="translate")
+
+# GGUF 模型及全局状态
+_llama_model = None
+_llama_lock = threading.Lock()
+_infer_lock = threading.Lock()
+_translate_tasks = {}
+_analyze_tasks = {}
+_analyze_pool = concurrent.futures.ThreadPoolExecutor(max_workers=2, thread_name_prefix="analyze")
+_task_tasks = {}
+_task_pool = concurrent.futures.ThreadPoolExecutor(max_workers=2, thread_name_prefix="text_task")
+
+PAGES_PER_CHUNK = 6  # 扫描版 PDF 懒加载 OCR 提取时，每块处理的页数
+
+# ══════════════════════════════════════════════════════════════════
+# ModelScope 每日额度持久化管理器
+# ══════════════════════════════════════════════════════════════════
+
+class ModelScopeQuotaManager:
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.file_path = Path("/app/.translate_cache/modelscope_quota.json")
+        self.file_path.parent.mkdir(parents=True, exist_ok=True)
+        self._load()
+
+    def _load(self):
+        if self.file_path.exists():
+            try:
+                self.data = json.loads(self.file_path.read_text(encoding="utf-8"))
+            except Exception:
+                self.data = {}
+        else:
+            self.data = {}
+
+    def _save(self):
+        try:
+            self.file_path.write_text(json.dumps(self.data, ensure_ascii=False), encoding="utf-8")
+        except Exception as e:
+            print(f"[quota] 保存配额记录失败: {e}")
+
+    def increment(self, model_name: str) -> bool:
+        with self.lock:
+            self._load()
+            today = time.strftime("%Y-%m-%d", time.localtime())
+
+            if self.data.get("date") != today:
+                self.data = {"date": today, "total": 0, "usage": {}}
+
+            current_usage = self.data["usage"].get(model_name, 0)
+            if self.data["total"] >= 1000:
+                print("[quota] ModelScope 达到单日总上限 1000 次")
+                return False
+            if current_usage >= 200:
+                print(f"[quota] ModelScope 模型 {model_name} 达到单日限制 200 次")
+                return False
+
+            self.data["usage"][model_name] = current_usage + 1
+            self.data["total"] += 1
+            self._save()
+            return True
+
+_quota_manager = ModelScopeQuotaManager()
+
+
+@app.on_event("startup")
+async def startup():
+    global _ready
+    _ready = True
+    print("[startup] OpenWolf Spaces ready")
+
+    def _ensure_models():
+        _models_dir = Path("/app/models")
+        _bge_dir = _models_dir / "bge-m3"
+
+        try:
+            if not (_bge_dir / "config.json").exists():
+                print("[models] Downloading bge-m3 (2.2GB)...")
+                t0 = time.time()
+                from sentence_transformers import SentenceTransformer
+                _ = SentenceTransformer("BAAI/bge-m3", device="cpu")
+                print(f"[models] bge-m3 done in {time.time()-t0:.1f}s")
+        except Exception as e:
+            print(f"[models] bge-m3 download failed: {e}")
+
+        try:
+            _gguf_files = [
+                ("HY-MT1.5-1.8B-Q4_K_M.gguf", 1.13),
+                ("HY-MT1.5-1.8B-Q8_0.gguf", 1.91),
+            ]
+            _gguf_to_download = None
+            for _name, _gb in _gguf_files:
+                _p = _models_dir / "translate" / _name
+                if _p.exists():
+                    _gguf_to_download = None
+                    break
+                if _gguf_to_download is None:
+                    _gguf_to_download = (_name, _gb)
+            if _gguf_to_download:
+                _name, _gb = _gguf_to_download
+                print(f"[models] Downloading {_name} ({_gb}GB)...")
+                t0 = time.time()
+                from huggingface_hub import hf_hub_download
+                hf_hub_download(
+                    repo_id="tencent/HY-MT1.5-1.8B-GGUF",
+                    filename=_name,
+                    local_dir=str(_models_dir / "translate"),
+                )
+                print(f"[models] GGUF done in {time.time()-t0:.1f}s")
+        except Exception as e:
+            print(f"[models] GGUF download failed: {e}")
+
+        print("[models] All models ready")
+        try:
+            global _model_loaded, _model_loading
+            print("[warmup] Loading bge-m3...")
+            t0 = time.time()
+            from sentence_transformers import SentenceTransformer
+            _ = SentenceTransformer("BAAI/bge-m3", device="cpu")
+            _model_loaded = True
+            _model_loading = False
+            print(f"[warmup] bge-m3 loaded in {time.time()-t0:.1f}s")
+        except Exception as e:
+            print(f"[warmup] bge-m3 FAILED: {e}")
+            _model_loading = False
+
+    threading.Thread(target=_ensure_models, daemon=True).start()
+
+
+# ══════════════════════════════════════════════════════════════════
+# 工具函数群：动态密钥加载与语系检测
+# ══════════════════════════════════════════════════════════════════
+
+def get_multi_api_keys(prefix: str) -> list:
+    """自动加载多账户 Key"""
+    keys = []
+    for i in range(1, 10):
+        val = os.environ.get(f"{prefix}_{i}") or os.environ.get(f"{prefix}{i}")
+        if val:
+            keys.append(val.strip())
+    single = os.environ.get(prefix)
+    if single and single.strip() not in keys:
+        keys.append(single.strip())
+    return keys
+
+def detect_japanese_korean(text: str) -> str:
+    """检测日韩语系特征字符"""
+    if re.search(r"[぀-ゟ゠-ヿ]", text):
+        return "ja"
+    if re.search(r"[가-힯]", text):
+        return "ko"
+    return "en"
+
+def semantic_split(text: str, target_chars: int = 16000) -> list:
+    """按段落逻辑切分，目标每段约 3000 英文词（≈16000 字符，译出约 5000 汉字）"""
+    paragraphs = text.split("\n")
+    chunks = []
+    current_chunk = []
+    current_size = 0
+
+    for para in paragraphs:
+        para_clean = para.strip()
+        if not para_clean:
+            continue
+
+        if para_clean.lower().startswith(("references", "bibliography", "literature cited")) or (len(para_clean) < 40 and para_clean.lower() == "references"):
+            print("[split] 识别到参考文献标记，已略过后续内容")
+            break
+
+        if len(para_clean) < 80 and any(kw in para_clean.lower() for kw in ["page", "vol.", "no.", "issn", "doi:", "http://", "https://"]):
+            continue
+
+        para_size = len(para_clean)
+        if current_size + para_size > target_chars and current_chunk:
+            chunks.append("\n\n".join(current_chunk))
+            current_chunk = [para_clean]
+            current_size = para_size
+        else:
+            current_chunk.append(para_clean)
+            current_size += para_size + 2
+
+    if current_chunk:
+        chunks.append("\n\n".join(current_chunk))
+
+    return chunks if chunks else [text]
+
+
+# ══════════════════════════════════════════════════════════════════
+# 在线 OCR 模块（硅基流动视觉大模型 Lazy 加载版）
+# ══════════════════════════════════════════════════════════════════
+
+def _ocr_page_via_siliconflow(pdf_path: Path, page_index: int) -> str:
+    """利用 PyMuPDF 渲染 PDF 页面为 JPEG 图像，并发送给硅基流动执行高精度 OCR"""
+    sf_key = os.environ.get("SILICONFLOW_API_KEY")
+    if not sf_key:
+        print("[ocr] 未配置 SILICONFLOW_API_KEY，无法使用在线 OCR")
+        return ""
+
+    try:
+        import fitz
+        doc = fitz.open(pdf_path)
+        if page_index >= len(doc):
+            return ""
+        page = doc[page_index]
+
+        pix = page.get_pixmap(dpi=150)
+        img_bytes = pix.tobytes("jpg")
+        b64_img = base64.b64encode(img_bytes).decode("utf-8")
+
+        ocr_model = os.environ.get("OCRAI_OCR_MODEL", "PaddlePaddle/PaddleOCR-VL-1.5")
+        url = "https://api.siliconflow.cn/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {sf_key.strip()}", "Content-Type": "application/json"}
+        body = {
+            "model": ocr_model,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": "Extract all academic text in this image precisely. Keep formatting and paragraphs. Do not summarize."},
+                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64_img}"}}
+                    ]
+                }
+            ],
+            "temperature": 0.1
+        }
+        r = requests.post(url, headers=headers, json=body, timeout=40)
+        if r.status_code == 200:
+            extracted_text = r.json()["choices"][0]["message"]["content"].strip()
+            print(f"[ocr] 页面 {page_index+1} OCR 成功 ({len(extracted_text)} 字符)")
+            return extracted_text
+        else:
+            print(f"[ocr] OCR HTTP {r.status_code}: {r.text[:150]}")
+    except Exception as e:
+        print(f"[ocr] 页面 {page_index+1} OCR 失败: {e}")
+    return ""
+
+
+# ══════════════════════════════════════════════════════════════════
+# 极速引擎：云端 API 5层混合翻译链
+# ══════════════════════════════════════════════════════════════════
+
+def _strip_think(text: str) -> str:
+    """去除模型输出的思考链标签及末尾附带的原文"""
+    import re
+    text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL).strip()
+    # 如果译文结束后出现大段英文原文（译文长度一半以上），截断
+    lines = text.split('\n')
+    cleaned = []
+    for line in lines:
+        eng_ratio = sum(1 for c in line if c.isascii() and c.isalpha()) / max(len(line), 1)
+        if eng_ratio > 0.8 and len(line) > 60:
+            break
+        cleaned.append(line)
+    return '\n'.join(cleaned).strip()
+
+def _call_api(url: str, headers: dict, body: dict, timeout: int = 12) -> str:
+    """统一 API 调用，返回翻译文本或空字符串"""
+    try:
+        r = requests.post(url, headers=headers, json=body, timeout=timeout)
+        if r.status_code == 200:
+            result = r.json()["choices"][0]["message"]["content"].strip()
+            return _strip_think(result)
+    except Exception as e:
+        print(f"[translate] API 异常: {e}")
+    return ""
+
+def _reorder_qwen_first(models: list, is_jk: bool) -> list:
+    """日韩语系将 Qwen 模型提到队列前端"""
+    if not is_jk:
+        return models
+    return [m for m in models if "qwen" in m.lower()] + [m for m in models if "qwen" not in m.lower()]
+
+def _translate_via_cloud_router(text: str, prev_source: str = "", prev_trans: str = "") -> str:
+    """5 层在线翻译 API 路由调度器"""
+    lang = detect_japanese_korean(text)
+    is_jk = lang in ("ja", "ko")
+
+    context_prompt = ""
+    if prev_source and prev_trans:
+        context_prompt = (
+            f"### 上文翻译参考：\n"
+            f"【原文】：{prev_source[-200:]}\n"
+            f"【译文】：{prev_trans[-200:]}\n\n"
+        )
+
+    system_prompt = (
+        "你是一位精通多国语言的资深学术翻译专家。请将下面的英文学术文本翻译成中文。\n"
+        "## 翻译规则：\n"
+        "1. 保持专业学术语言风格，用词准确，翻译自然流畅。\n"
+        "2. 专有名词首次出现时请保留英文原文，格式如：“卷积神经网络 (Convolutional Neural Network, CNN)”。\n"
+        "3. 人名、地名首次出现时使用中英对照。\n"
+        "4. 严格保持原文段落和标点符号结构的完整，保留代码、公式、数字、年份。\n"
+        "5. 只输出中文译文，绝对不要包含原文。译文结束后立即结束，不要追加任何原文。\n"
+        "6. 不要在译文前加任何导语、标题、说明或介绍。直接从正文开始。\n"
+        "7. 不要输出 Markdown 标记、代码块或多余的空行。\n"
+        "8. 禁止输出思考过程。不要使用<think>标签或任何其他格式输出推理过程。"
+    )
+    user_content = f"{context_prompt}## 待翻译文本：\n{text}"
+
+    # ────── 第一层：ModelScope（限额轮询） ──────
+    ms_key = os.environ.get("MODELSCOPE_API_KEY")
+    if ms_key:
+        ms_models = [
+            "Qwen/Qwen3.5-397B-A17B",
+            "Qwen/Qwen3-235B-A22B-Thinking-2507",
+            "deepseek-ai/DeepSeek-V4-Pro",
+            "ZhipuAI/GLM-5.1",
+            "deepseek-ai/DeepSeek-V3.2",
+            "Qwen/Qwen3.5-122B-A10B",
+            "MiniMax/MiniMax-M1-80k",
+            "deepseek-ai/DeepSeek-R1-0528",
+            "ZhipuAI/GLM-5",
+        ]
+        ms_models = _reorder_qwen_first(ms_models, is_jk)
+        for model in ms_models:
+            if not _quota_manager.increment(model):
+                continue
+            url = "https://api-inference.modelscope.cn/v1/chat/completions"
+            headers = {"Authorization": f"Bearer {ms_key.strip()}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+            result = _call_api(url, headers, body, timeout=12)
+            if result:
+                print(f"[translate] 第一层 ModelScope {model} 成功")
+                return result
+
+    # ────── 第二层：主力层（Cerebras & Groq 多密钥轮询） ──────
+    cerebras_keys = get_multi_api_keys("CEREBRAS_API_KEY")
+    groq_keys = get_multi_api_keys("GROQ_API_KEY")
+    random.shuffle(cerebras_keys)
+    random.shuffle(groq_keys)
+
+    for key in cerebras_keys:
+        for model in ["gpt-oss-120b", "zai-glm-4.7"]:
+            url = "https://api.cerebras.ai/v1/chat/completions"
+            headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+            result = _call_api(url, headers, body, timeout=10)
+            if result:
+                print(f"[translate] 第二层 Cerebras {model} 成功")
+                return result
+
+    for key in groq_keys:
+        for model in ["openai/gpt-oss-120b", "llama-3.3-70b-versatile"]:
+            url = "https://api.groq.com/openai/v1/chat/completions"
+            headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+            result = _call_api(url, headers, body, timeout=10)
+            if result:
+                print(f"[translate] 第二层 Groq {model} 成功")
+                return result
+
+    # ────── 第三层：免费补充层 ──────
+    or_key = os.environ.get("OPENROUTER_API_KEY")
+    if or_key:
+        or_models = [
+            "qwen/qwen3-coder:free", "meta-llama/llama-3.3-70b-instruct:free",
+            "z-ai/glm-4.5-air:free", "nvidia/nemotron-3-super-120b-a12b:free",
+            "qwen/qwen3-next-80b-a3b-instruct:free"
+        ]
+        or_models = _reorder_qwen_first(or_models, is_jk)
+        for model in or_models:
+            url = "https://openrouter.ai/api/v1/chat/completions"
+            headers = {"Authorization": f"Bearer {or_key.strip()}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+            result = _call_api(url, headers, body, timeout=12)
+            if result:
+                print(f"[translate] 第三层 OpenRouter {model} 成功")
+                return result
+
+    sf_key = os.environ.get("SILICONFLOW_API_KEY")
+    if sf_key:
+        url = "https://api.siliconflow.cn/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {sf_key.strip()}", "Content-Type": "application/json"}
+        body = {"model": "tencent/Hunyuan-MT-7B", "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+        result = _call_api(url, headers, body, timeout=12)
+        if result:
+            print("[translate] 第三层 Hunyuan-MT-7B 成功")
+            return result
+
+    nv_key = os.environ.get("NVIDIA_API_KEY")
+    if nv_key:
+        nv_models = [
+            "qwen/qwen3.5-397b-a17b", "qwen/qwen3-coder-480b-a35b-instruct",
+            "qwen/qwen3.5-122b-a10b", "z-ai/glm-5.1",
+            "nvidia/nemotron-3-super-120b-a12b"
+        ]
+        nv_models = _reorder_qwen_first(nv_models, is_jk)
+        for model in nv_models:
+            url = "https://integrate.api.nvidia.com/v1/chat/completions"
+            headers = {"Authorization": f"Bearer {nv_key.strip()}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2, "max_tokens": 4096}
+            result = _call_api(url, headers, body, timeout=12)
+            if result:
+                print(f"[translate] 第三层 NVIDIA {model} 成功")
+                return result
+
+    # ────── 第四层：主力辅助层 ──────
+    mistral_keys = get_multi_api_keys("MISTRAL_API_KEY")
+    opencode_keys = get_multi_api_keys("OPENCODE_API_KEY")
+    random.shuffle(mistral_keys)
+    random.shuffle(opencode_keys)
+
+    for key in mistral_keys:
+        for model in ["mistral-large-latest", "mistral-medium-latest"]:
+            url = "https://api.mistral.ai/v1/chat/completions"
+            headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+            result = _call_api(url, headers, body, timeout=12)
+            if result:
+                print(f"[translate] 第四层 Mistral {model} 成功")
+                return result
+
+    for key in opencode_keys:
+        for model in ["big-pickle", "nemotron-3-super-free", "deepseek-v4-flash-free"]:
+            url = "https://opencode.ai/zen/v1/chat/completions"
+            headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+            result = _call_api(url, headers, body, timeout=12)
+            if result:
+                print(f"[translate] 第四层 opencode {model} 成功")
+                return result
+
+    # ────── 第五层：轻量兜底层 ──────
+    zp_key = os.environ.get("ZHIPUAI_API_KEY")
+    if zp_key:
+        for model in ["glm-4.7-flash", "glm-4.6-flash", "GLM-Z1-Flash", "GLM-4-Flash"]:
+            url = "https://open.bigmodel.cn/api/paas/v4/chat/completions"
+            headers = {"Authorization": f"Bearer {zp_key.strip()}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+            result = _call_api(url, headers, body, timeout=10)
+            if result:
+                print(f"[translate] 第五层 智谱 {model} 成功")
+                return result
+
+    if sf_key:
+        sf_free = [
+            "deepseek-ai/DeepSeek-R1-0528-Qwen3-8B", "Qwen/Qwen3.5-4B",
+            "Qwen/Qwen3-8B", "THUDM/GLM-Z1-9B-0414", "THUDM/GLM-4-9B-0414"
+        ]
+        sf_free = _reorder_qwen_first(sf_free, is_jk)
+        for model in sf_free:
+            url = "https://api.siliconflow.cn/v1/chat/completions"
+            headers = {"Authorization": f"Bearer {sf_key.strip()}", "Content-Type": "application/json"}
+            body = {"model": model, "messages": [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_content}], "temperature": 0.2}
+            result = _call_api(url, headers, body, timeout=10)
+            if result:
+                print(f"[translate] 第五层 硅基 {model} 成功")
+                return result
+
+    return ""
+
+
+# ══════════════════════════════════════════════════════════════════
+# 本地 GGUF 离线兜底引擎
+# ══════════════════════════════════════════════════════════════════
+
+def _get_llama():
+    global _llama_model
+    if _llama_model is not None:
+        return _llama_model
+    with _llama_lock:
+        if _llama_model is not None:
+            return _llama_model
+
+        model_path = "/app/models/translate/HY-MT1.5-1.8B-Q4_K_M.gguf"
+
+        for _i in range(60):
+            if os.path.isfile(model_path) and os.path.getsize(model_path) > 100 * 1024 * 1024:
+                break
+            print(f"[llama] 等待本地兜底模型准备就绪... {_i}s")
+            time.sleep(1)
+
+        if not os.path.isfile(model_path):
+            model_path = "/app/models/translate/HY-MT1.5-1.8B-Q8_0.gguf"
+            for _i in range(10):
+                if os.path.isfile(model_path) and os.path.getsize(model_path) > 100 * 1024 * 1024:
+                    break
+                time.sleep(1)
+
+        if not os.path.isfile(model_path):
+            raise FileNotFoundError("GGUF model file not found")
+
+        from llama_cpp import Llama
+
+        result = [None]
+        error = [None]
+        done = threading.Event()
+
+        num_cores = os.cpu_count() or 4
+        optimal_threads = max(1, min(4, num_cores))
+
+        def _load():
+            try:
+                print(f"[llama] Loading HY-MT1.5 with {optimal_threads} threads...")
+                t0 = time.time()
+                result[0] = Llama(model_path=model_path, n_ctx=2048,
+                                  n_threads=optimal_threads, n_gpu_layers=0, verbose=False,
+                                  use_mmap=True, use_mlock=False)
+                print(f"[llama] Loaded in {time.time()-t0:.1f}s")
+            except Exception as e:
+                error[0] = e
+            finally:
+                done.set()
+
+        t = threading.Thread(target=_load, daemon=True)
+        t.start()
+        if not done.wait(timeout=90):
+            raise TimeoutError("GGUF model loading timed out (90s)")
+        if error[0]:
+            raise error[0]
+        _llama_model = result[0]
+        return _llama_model
+
+
+def _translate_chunk_local_with_context(text: str, prev_source: str = "", prev_trans: str = "") -> str:
+    llm = _get_llama()
+    _max = max(128, min(1024, int(len(text) * 1.5)))
+
+    context_prompt = ""
+    if prev_source and prev_trans:
+        context_prompt = (
+            f"### 上文翻译参考：\n"
+            f"【上文原文】：{prev_source[-200:]}\n"
+            f"【上文译文】：{prev_trans[-200:]}\n\n"
+        )
+
+    _prompt = (
+        "你是一位精通多国语言的资深学术翻译专家。请将下面的英文学术文本翻译成中文。\n"
+        "## 翻译规则：\n"
+        "1. 保持专业学术语言风格，用词准确，翻译自然流畅。\n"
+        "2. 专有名词首次出现时请保留英文原文。\n"
+        "3. 人名、地名首次出现时使用中英对照。\n"
+        "4. 严格保持原文段落结构，保留代码、公式、数字、年份。\n"
+        "5. 只输出中文译文，绝对不要包含原文。\n"
+        "6. 不要在译文前加任何导语、标题、说明。直接从正文开始。\n"
+        "7. 不要输出 Markdown 标记、代码块或多余的空行。\n\n"
+        f"{context_prompt}"
+        "## 待翻译文本：\n"
+        f"{text}"
+    )
+    with _infer_lock:
+        out = llm.create_chat_completion(
+            messages=[{"role": "user", "content": _prompt}],
+            max_tokens=_max, temperature=0.1,
+        )
+    return out["choices"][0]["message"]["content"].strip()
+
+
+# ══════════════════════════════════════════════════════════════════
+# 防弹版异步翻译任务启动（含懒加载 OCR + 5层路由 + GGUF兜底）
+# ══════════════════════════════════════════════════════════════════
+
+@app.post("/api/job/start")
+async def api_job_start(request: Request):
+    try:
+        body = await request.json()
+    except Exception as e:
+        return {"ok": False, "error": f"JSON 解析失败: {e}"}
+
+    try:
+        task_id = str(uuid.uuid4())
+        _translate_tasks[task_id] = {"status": "processing", "result": None}
+
+        def _do_work(t_id, payload):
+            try:
+                _file_id = payload.get("fileId") or payload.get("file_id")
+                _file_path = payload.get("file_path") or payload.get("filePath")
+                _dl_url = payload.get("download_url") or payload.get("downloadUrl")
+                _r2_url = payload.get("r2_download_url") or payload.get("r2DownloadUrl")
+                _orig_fn = payload.get("fileName") or payload.get("filename") or "document.pdf"
+                _orig_ext = _orig_fn.rsplit(".", 1)[-1].lower() if "." in _orig_fn else "pdf"
+
+                _ci = payload.get("chunk_index", 0)
+                if _ci == -1 or _ci is None:
+                    _ci = 0
+
+                _chat_id_str = str(payload.get("chat_id") or "default")
+                _context_dir = Path("/app/.context_cache") / _chat_id_str
+                _context_dir.mkdir(parents=True, exist_ok=True)
+
+                _chunks_cache_file = _context_dir / "chunks_list.json"
+                _meta_cache_file = _context_dir / "pdf_metadata.json"
+                _chunks = []
+
+                # 读取元数据
+                _is_scanned = False
+                _total_pages = 0
+                if _meta_cache_file.is_file():
+                    try:
+                        _meta = json.loads(_meta_cache_file.read_text(encoding="utf-8"))
+                        _is_scanned = _meta.get("is_scanned", False)
+                        _total_pages = _meta.get("total_pages", 0)
+                    except Exception:
+                        pass
+
+                # 非首段且已缓存 → 直接加载
+                if _ci > 0 and not _is_scanned and _chunks_cache_file.is_file():
+                    try:
+                        _chunks = json.loads(_chunks_cache_file.read_text(encoding="utf-8"))
+                        print(f"[translate] 命中缓存: {_ci + 1}/{len(_chunks)}")
+                    except Exception:
+                        pass
+
+                # 首段或无缓存 → 下载 + 检测 PDF 属性
+                if not _chunks and _ci == 0:
+                    print(f"[download] 开始定位文件: file_id={_file_id}")
+                    _downloaded_local_path = None
+
+                    # R2
+                    if _r2_url:
+                        try:
+                            import requests as _rt
+                            import uuid as _uuid
+                            _r = _rt.get(_r2_url, timeout=120, stream=True)
+                            if _r.status_code == 200:
+                                _local = Path("/app") / f"inputs/{_uuid.uuid4().hex}_{_orig_fn}"
+                                _local.parent.mkdir(parents=True, exist_ok=True)
+                                with open(_local, "wb") as _f:
+                                    for _chunk in _r.iter_content(chunk_size=65536):
+                                        _f.write(_chunk)
+                                _downloaded_local_path = _local
+                        except Exception as _e:
+                            print(f"[download] R2 异常: {_e}")
+
+                    # download_url
+                    if _dl_url and not (_downloaded_local_path and _downloaded_local_path.is_file()):
+                        try:
+                            import requests as _rt
+                            import uuid as _uuid
+                            _h = {}
+                            _gh_pat = os.environ.get("OPENWOLF_PAT") or os.environ.get("GITHUB_PAT") or os.environ.get("GITHUB_TOKEN") or ""
+                            if "api.github.com" in _dl_url and _gh_pat:
+                                _h["Authorization"] = f"Bearer {_gh_pat}"
+                                _h["Accept"] = "application/vnd.github.raw"
+                            _r = _rt.get(_dl_url, headers=_h, timeout=120)
+                            if _r.status_code == 200:
+                                _local = Path("/app") / f"inputs/{_uuid.uuid4().hex}.{_orig_ext}"
+                                _local.parent.mkdir(parents=True, exist_ok=True)
+                                _local.write_bytes(_r.content)
+                                _downloaded_local_path = _local
+                        except Exception as _e:
+                            print(f"[download] download_url 异常: {_e}")
+
+                    # GitHub API
+                    if _file_path and not (_downloaded_local_path and _downloaded_local_path.is_file()):
+                        _repo_path = _file_path
+                        _local_check = Path("/app") / _repo_path
+                        if _local_check.is_file():
+                            _downloaded_local_path = _local_check
+                        elif Path(_repo_path).is_file():
+                            _downloaded_local_path = Path(_repo_path)
+                        else:
+                            _gh_repo = os.environ.get("GITHUB_REPO", "hughyonng/OpenWolf")
+                            _gh_pat = os.environ.get("OPENWOLF_PAT") or os.environ.get("GITHUB_PAT") or os.environ.get("GITHUB_TOKEN") or ""
+                            if _gh_pat:
+                                try:
+                                    import requests as _rt
+                                    import uuid as _uuid
+                                    _u = f"https://api.github.com/repos/{_gh_repo}/contents/{_repo_path}"
+                                    _h = {"Authorization": f"Bearer {_gh_pat}", "Accept": "application/vnd.github.raw"}
+                                    _r = _rt.get(_u, headers=_h, timeout=120)
+                                    if _r.status_code == 200:
+                                        _local = Path("/app") / f"inputs/{_uuid.uuid4().hex}.{_orig_ext}"
+                                        _local.parent.mkdir(parents=True, exist_ok=True)
+                                        _local.write_bytes(_r.content)
+                                        _downloaded_local_path = _local
+                                except Exception as _e:
+                                    print(f"[download] GitHub API 异常: {_e}")
+
+                    # Telegram 兜底
+                    if _file_id and not (_downloaded_local_path and _downloaded_local_path.is_file()):
+                        try:
+                            _token = os.environ.get("TELEGRAM_BOT_TOKEN", "")
+                            if _token:
+                                import requests as _rt
+                                import uuid as _uuid
+                                _mr = _rt.get(f"https://api.telegram.org/bot{_token}/getFile?file_id={_file_id}", timeout=30)
+                                _fd = _mr.json().get("result", {}) if _mr.ok else {}
+                                _fp = _fd.get("file_path", "")
+                                if _mr.ok and _fp:
+                                    _dl = _rt.get(f"https://api.telegram.org/file/bot{_token}/{_fp}", timeout=300, stream=True)
+                                    if _dl.ok:
+                                        _local = Path("/app") / f"inputs/{_uuid.uuid4().hex}_{_fp.split('/')[-1]}"
+                                        _local.parent.mkdir(parents=True, exist_ok=True)
+                                        with open(_local, "wb") as _f:
+                                            for _chunk in _dl.iter_content(chunk_size=65536):
+                                                _f.write(_chunk)
+                                        _downloaded_local_path = _local
+                        except Exception as _e:
+                            print(f"[download] Telegram 异常: {_e}")
+
+                    if not _downloaded_local_path or not _downloaded_local_path.is_file():
+                        raise ValueError("无法在所有防护层中下载文档")
+
+                    # 缓存到固定路径
+                    _fixed_path = _context_dir / f"source_document.{_orig_ext}"
+                    shutil.copy2(_downloaded_local_path, _fixed_path)
+                    _downloaded_local_path = _fixed_path
+
+                    # 判断 PDF 属性
+                    if _orig_ext == "pdf":
+                        try:
+                            import fitz
+                            doc = fitz.open(_downloaded_local_path)
+                            _total_pages = len(doc)
+                            sample_text = ""
+                            for p_idx in range(min(3, _total_pages)):
+                                sample_text += doc[p_idx].get_text() or ""
+                            _is_scanned = len(sample_text.strip()) < 100
+                            print(f"[translate] PDF 属性: {'扫描版' if _is_scanned else '电子版'}")
+                        except Exception as e:
+                            _is_scanned = False
+                            print(f"[translate] PDF 属性检测异常: {e}")
+                    else:
+                        _is_scanned = False
+
+                    try:
+                        _meta_cache_file.write_text(json.dumps({
+                            "is_scanned": _is_scanned, "total_pages": _total_pages,
+                            "file_ext": _orig_ext, "file_name": _orig_fn,
+                        }, ensure_ascii=False), encoding="utf-8")
+                    except Exception as e:
+                        print(f"[meta] 缓存异常: {e}")
+
+                    # 电子版：全文提取 + 语义切分
+                    if not _is_scanned:
+                        import pdfplumber as _pp
+                        _full_text = ""
+                        if _orig_ext == "pdf":
+                            with _pp.open(_downloaded_local_path) as _p:
+                                _full_text = "\n".join(page.extract_text() or "" for page in _p.pages)
+                        elif _orig_ext in ("txt", "md", "csv", "json"):
+                            with open(_downloaded_local_path, "r", encoding="utf-8", errors="ignore") as _f:
+                                _full_text = _f.read()
+                        elif _orig_ext in ("docx",):
+                            import docx as _dx
+                            _d = _dx.Document(_downloaded_local_path)
+                            _full_text = "\n".join(p.text for p in _d.paragraphs)
+
+                        if not _full_text.strip():
+                            raise ValueError("文本提取为空")
+
+                        _chunks = semantic_split(_full_text, target_chars=16000)
+                        try:
+                            _chunks_cache_file.write_text(json.dumps(_chunks, ensure_ascii=False), encoding="utf-8")
+                            print(f"[translate] 分段完成: {len(_chunks)} 段")
+                        except Exception as _se:
+                            print(f"[translate] 写入缓存失败: {_se}")
+
+                # ────── 执行翻译 ──────
+                if _is_scanned:
+                    _total_chunks = int((_total_pages + PAGES_PER_CHUNK - 1) / PAGES_PER_CHUNK)
+                    if _ci >= _total_chunks:
+                        result_payload = {"translated_text": "🎉 本书已全部翻译完毕！", "has_more": False, "chunk_index": _ci, "total_chunks": _total_chunks}
+                    else:
+                        start_page = _ci * PAGES_PER_CHUNK
+                        end_page = min(start_page + PAGES_PER_CHUNK, _total_pages)
+                        _chunk_raw_text = ""
+                        _fixed_path = _context_dir / f"source_document.{_orig_ext}"
+                        print(f"[ocr] 提取第 {start_page+1}-{end_page} 页...")
+                        for p_idx in range(start_page, end_page):
+                            page_text = _ocr_page_via_siliconflow(_fixed_path, p_idx)
+                            if page_text:
+                                _chunk_raw_text += page_text + "\n\n"
+                        if not _chunk_raw_text.strip():
+                            raise ValueError(f"OCR 未在第 {start_page+1}-{end_page} 页识别到有效字符")
+
+                        _prev_source, _prev_trans = _load_context(_context_dir, _ci)
+                        _tr = _translate_via_cloud_router(_chunk_raw_text, _prev_source, _prev_trans)
+                        if not _tr:
+                            print("[translate] 在线路由失败，降级 GGUF")
+                            _tr = _translate_chunk_local_with_context(_chunk_raw_text, _prev_source, _prev_trans)
+                        _save_context(_context_dir, _ci, _chunk_raw_text, _tr)
+                        _clean_old_context(_context_dir, _ci)
+                        result_payload = {"translated_text": _tr, "has_more": (_ci + 1) < _total_chunks, "chunk_index": _ci, "total_chunks": _total_chunks}
+                else:
+                    if not _chunks and _chunks_cache_file.is_file():
+                        try:
+                            _chunks = json.loads(_chunks_cache_file.read_text(encoding="utf-8"))
+                        except Exception:
+                            pass
+                    _total_chunks = len(_chunks) if _chunks else 1
+                    if _ci >= _total_chunks or not _chunks:
+                        result_payload = {"translated_text": "🎉 本书已翻译完毕！", "has_more": False, "chunk_index": _ci, "total_chunks": _total_chunks}
+                    else:
+                        _chunk_to_trans = _chunks[_ci]
+                        _prev_source, _prev_trans = _load_context(_context_dir, _ci)
+                        _tr = _translate_via_cloud_router(_chunk_to_trans, _prev_source, _prev_trans)
+                        if not _tr:
+                            print("[translate] 在线路由失败，降级 GGUF")
+                            _tr = _translate_chunk_local_with_context(_chunk_to_trans, _prev_source, _prev_trans)
+                        _save_context(_context_dir, _ci, _chunk_to_trans, _tr)
+                        _clean_old_context(_context_dir, _ci)
+                        result_payload = {"translated_text": _tr, "has_more": (_ci + 1) < _total_chunks, "chunk_index": _ci, "total_chunks": _total_chunks}
+
+                _translate_tasks[t_id] = {"status": "done", "result": json.dumps(result_payload, ensure_ascii=False)}
+            except Exception as e:
+                import traceback
+                print(f"[api_job_start] 异常: {e}")
+                traceback.print_exc()
+                _translate_tasks[t_id] = {"status": "error", "result": json.dumps({"error": str(e)})}
+
+        _translate_pool.submit(_do_work, task_id, body)
+        return {"ok": True, "task_id": task_id}
+    except Exception as e:
+        return {"ok": False, "error": f"路由层报错: {e}"}
+
+
+# ══════════════════════════════════════════════════════════════════
+# 滑窗上下文管理
+# ══════════════════════════════════════════════════════════════════
+
+def _load_context(context_dir: Path, ci: int):
+    prev_source, prev_trans = "", ""
+    prev_src = context_dir / f"src_{ci - 1}.txt"
+    prev_trs = context_dir / f"trans_{ci - 1}.txt"
+    if ci > 0 and prev_src.is_file() and prev_trs.is_file():
+        prev_source = prev_src.read_text(encoding="utf-8", errors="ignore")
+        prev_trans = prev_trs.read_text(encoding="utf-8", errors="ignore")
+    return prev_source, prev_trans
+
+def _save_context(context_dir: Path, ci: int, src: str, trans: str):
+    (context_dir / f"src_{ci}.txt").write_text(src, encoding="utf-8")
+    (context_dir / f"trans_{ci}.txt").write_text(trans, encoding="utf-8")
+
+def _clean_old_context(context_dir: Path, ci: int):
+    for _f in context_dir.glob("*.txt"):
+        try:
+            _f_name = _f.name
+            if _f_name.startswith("src_") or _f_name.startswith("trans_"):
+                _f_idx = int(_f_name.split("_")[1].split(".")[0])
+                if _f_idx < ci - 1:
+                    _f.unlink()
+        except:
+            pass
+
+
+@app.get("/api/job/check/{task_id}")
+async def api_job_check(task_id: str):
+    try:
+        task = _translate_tasks.get(task_id)
+        if not task:
+            return {"ok": False, "status": "error", "result": "任务ID不存在"}
+        if task["status"] in ("done", "error"):
+            result_copy = task.copy()
+            del _translate_tasks[task_id]
+            return {"ok": True, "status": result_copy["status"], "result": result_copy["result"]}
+        return {"ok": True, "status": "processing"}
+    except Exception as e:
+        return {"ok": False, "status": "error", "result": f"检查报错: {e}"}
+
+
+@app.get("/debug/model")
+async def debug_model():
+    q4_path = "/app/models/translate/HY-MT1.5-1.8B-Q4_K_M.gguf"
+    q8_path = "/app/models/translate/HY-MT1.5-1.8B-Q8_0.gguf"
+    q4_exists = os.path.isfile(q4_path)
+    q8_exists = os.path.isfile(q8_path)
+    result = {
+        "q4_exists": q4_exists, "q8_exists": q8_exists,
+        "q4_size_gb": round(os.path.getsize(q4_path) / 1024**3, 2) if q4_exists else 0,
+        "q8_size_gb": round(os.path.getsize(q8_path) / 1024**3, 2) if q8_exists else 0,
+        "llama_loaded": _llama_model is not None,
+    }
+    try:
+        import llama_cpp
+        result["llama_cpp_version"] = llama_cpp.__version__
+    except ImportError:
+        result["llama_cpp_version"] = None
+    return JSONResponse(result)
+
+
+@app.post("/ping")
+async def ping():
+    return {"ok": True, "msg": "pong"}
+
+
+# ── 以下保留原有接口（analyze-doc, task, skill, health 等）──
+
+@app.post("/analyze-doc")
+async def analyze_doc(request: Request):
+    try:
+        body = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+    url = body.get("url", "")
+    question = body.get("question", "请分析这份文档的内容")
+    max_chars = int(body.get("max_chars", 50000))
+    if not url:
+        return {"ok": False, "error": "url required"}
+    import requests as _req
+    import uuid as _uuid
+    from pathlib import Path
+    resp = _req.get(url, timeout=300, stream=True)
+    if resp.status_code != 200:
+        return {"ok": False, "error": f"下载失败 HTTP {resp.status_code}"}
+    local_path = Path("/app") / f"inputs/{_uuid.uuid4().hex}.pdf"
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(local_path, "wb") as f:
+        for chunk in resp.iter_content(chunk_size=65536):
+            f.write(chunk)
+    import pdfplumber
+    text = ""
+    with pdfplumber.open(local_path) as p:
+        for page in p.pages:
+            t = page.extract_text()
+            if t:
+                text += t + "\n"
+    try:
+        local_path.unlink()
+    except Exception:
+        pass
+    if not text.strip():
+        return {"ok": False, "error": "无法提取文本内容"}
+    doc_text = text[:max_chars]
+    return {"ok": True, "result": "分析完成"}
+
+@app.post("/analyze-doc/start")
+async def analyze_doc_start(request: Request):
+    try:
+        body = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+    url = body.get("url", "")
+    question = body.get("question", "请分析这份文档的内容")
+    max_chars = int(body.get("max_chars", 50000))
+    if not url:
+        return {"ok": False, "error": "url required"}
+    task_id = str(uuid.uuid4())
+    _analyze_tasks[task_id] = {"status": "processing", "result": None}
+    _analyze_pool.submit(_do_analyze_async, task_id, url, question, max_chars)
+    return {"ok": True, "task_id": task_id}
+
+@app.post("/analyze-text/start")
+async def analyze_text_start(request: Request):
+    try:
+        body = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+    text = body.get("text", "")
+    question = body.get("question", "")
+    if not text or not question:
+        return {"ok": False, "error": "text and question required"}
+    task_id = str(uuid.uuid4())
+    _analyze_tasks[task_id] = {"status": "processing", "result": None}
+    _analyze_pool.submit(_do_analyze_text_async, task_id, text, question)
+    return {"ok": True, "task_id": task_id}
+
+@app.get("/analyze-text/check/{task_id}")
+async def analyze_text_check(task_id: str):
+    return await analyze_doc_check(task_id)
+
+@app.get("/analyze-doc/check/{task_id}")
+async def analyze_doc_check(task_id: str):
+    task = _analyze_tasks.get(task_id)
+    if not task:
+        return {"ok": False, "status": "error", "result": "任务ID不存在"}
+    if task["status"] in ("done", "error"):
+        result_copy = task.copy()
+        del _analyze_tasks[task_id]
+        resp = {"ok": True, "status": result_copy["status"], "result": result_copy["result"]}
+        if result_copy.get("doc_text"):
+            resp["doc_text"] = result_copy["doc_text"]
+        return resp
+    return {"ok": True, "status": "processing"}
+
+def _do_analyze_async(task_id: str, url: str, question: str, max_chars: int):
+    import requests as _req
+    import uuid as _uuid
+    from pathlib import Path
+    try:
+        resp = _req.get(url, timeout=300, stream=True)
+        if resp.status_code != 200:
+            _analyze_tasks[task_id] = {"status": "error", "result": f"下载失败 HTTP {resp.status_code}"}
+            return
+        local_path = Path("/app") / f"inputs/{_uuid.uuid4().hex}.pdf"
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(local_path, "wb") as f:
+            for chunk in resp.iter_content(chunk_size=65536):
+                f.write(chunk)
+        import pdfplumber
+        text = ""
+        with pdfplumber.open(local_path) as p:
+            for page in p.pages:
+                t = page.extract_text()
+                if t:
+                    text += t + "\n"
+        try:
+            local_path.unlink()
+        except Exception:
+            pass
+        if not text.strip():
+            _analyze_tasks[task_id] = {"status": "error", "result": "无法提取文本内容"}
+            return
+        doc_text = text[:max_chars]
+        _do_analyze_text_async(task_id, doc_text, question)
+    except Exception as e:
+        _analyze_tasks[task_id] = {"status": "error", "result": f"分析失败: {e}"}
+
+def _do_analyze_text_async(task_id: str, doc_text: str, question: str):
+    try:
+        _analyze_tasks[task_id] = {"status": "done", "result": "分析完成", "doc_text": doc_text}
+    except Exception as e:
+        _analyze_tasks[task_id] = {"status": "error", "result": f"分析失败: {e}"}
+
+@app.post("/task/start")
+async def task_start(request: Request):
+    try:
+        body = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+    task_text = body.get("task", "")
+    chat_id = body.get("chat_id", "")
+    task_type = body.get("task_type") or None
+    history = body.get("history", [])
+    if not task_text:
+        return {"ok": False, "error": "task required"}
+    task_id = str(uuid.uuid4())
+    _task_tasks[task_id] = {"status": "processing", "result": None}
+    _task_pool.submit(_do_task_async, task_id, task_text, str(chat_id), task_type, history)
+    return {"ok": True, "task_id": task_id}
+
+@app.get("/task/check/{task_id}")
+async def task_check(task_id: str):
+    task = _task_tasks.get(task_id)
+    if not task:
+        return {"ok": False, "status": "error", "result": "任务ID不存在"}
+    if task["status"] in ("done", "error"):
+        result_copy = task.copy()
+        del _task_tasks[task_id]
+        return {"ok": True, "status": result_copy["status"], "result": result_copy["result"]}
+    return {"ok": True, "status": "processing"}
+
+def _do_task_async(task_id: str, task_text: str, chat_id: str, task_type: str = None, history: list = None):
+    if history is None:
+        history = []
+    try:
+        from scripts.ai_agent import run_agent_task
+        result = run_agent_task(task_text, history, None, chat_id, "consumer", task_type=task_type)
+        _task_tasks[task_id] = {"status": "done", "result": str(result)}
+    except Exception as e:
+        _task_tasks[task_id] = {"status": "error", "result": f"处理失败: {e}"}
+
+@app.get("/skill-search")
+async def skill_search(request: Request):
+    q = request.query_params.get("q", "").strip().lower()
+    if not q:
+        return JSONResponse([])
+    idx = _get_skill_index()
+    results = []
+    for s in idx.get("skills", []):
+        if q in s.get("name", "").lower() or q in s.get("description", "").lower():
+            results.append({"id": s["id"], "name": s["name"], "description": s.get("description", "")[:200]})
+    return JSONResponse(results)
+
+@app.get("/skill-view")
+async def skill_view(request: Request):
+    name = request.query_params.get("name", "").strip().lower()
+    if not name:
+        return JSONResponse({"error": "name required"}, status_code=400)
+    idx = _get_skill_index()
+    for s in idx.get("skills", []):
+        sid = s.get("id", "").lower()
+        if name in sid or name in s.get("name", "").lower():
+            readme_url = f"https://raw.githubusercontent.com/hughyonng/OpenWolf/refs/heads/main/skills/library/{sid}/README.md"
+            try:
+                r = requests.get(readme_url, timeout=10)
+                if r.ok:
+                    return JSONResponse({"name": s["name"], "content": r.text[:2000]})
+            except Exception:
+                pass
+    return JSONResponse({"error": "not found"}, status_code=404)
+
+SKILL_INDEX_CACHE = None
+
+def _get_skill_index():
+    global SKILL_INDEX_CACHE
+    if SKILL_INDEX_CACHE:
+        return SKILL_INDEX_CACHE
+    gh_token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GITHUB_PAT") or os.environ.get("OPENWOLF_PAT") or ""
+    try:
+        headers = {"Authorization": f"Bearer {gh_token}"} if gh_token else {}
+        r = requests.get("https://raw.githubusercontent.com/hughyonng/OpenWolf/main/skills/library-index.json", headers=headers, timeout=15)
+        if r.status_code == 200:
+            SKILL_INDEX_CACHE = r.json()
+            return SKILL_INDEX_CACHE
+    except Exception:
+        pass
+    try:
+        headers2 = {"Authorization": f"Bearer {gh_token}", "Accept": "application/vnd.github.v3.raw"} if gh_token else {"Accept": "application/vnd.github.v3.raw"}
+        r2 = requests.get("https://api.github.com/repos/hughyonng/OpenWolf/contents/skills/library-index.json", headers=headers2, timeout=15)
+        if r2.status_code == 200:
+            SKILL_INDEX_CACHE = r2.json()
+            return SKILL_INDEX_CACHE
+    except Exception:
+        pass
+    return {"skills": []}
+
+@app.get("/health")
+async def health():
+    env_keys = ["OPENROUTER_API_KEY", "GOOGLE_API_KEY", "CHATANYWHERE_API_KEY",
+                 "GROQ_API_KEY", "GITHUB_PAT", "GITHUB_REPO",
+                 "TELEGRAM_BOT_TOKEN", "TELEGRAM_CHAT_ID", "OPENWOLF_PAT"]
+    env_status = {k: "✅" if os.environ.get(k) else "❌" for k in env_keys}
+    return {"status": "ok", "ready": _ready, "env": env_status}

requirements.txt

@@ -0,0 +1,18 @@
+# ── OpenWolf HF Spaces 依赖 ──
+fastapi>=0.110.0
+uvicorn[standard]>=0.27.0
+requests>=2.31.0
+sentence-transformers>=3.0.0
+faiss-cpu>=1.8.0
+pyyaml>=6.0
+python-docx>=1.1.0
+openpyxl>=3.1.0
+python-pptx>=0.6.23
+pdfplumber>=0.10.0
+xlrd>=1.2.0
+httpx>=0.27.0
+numpy>=1.24.0
+huggingface_hub>=0.24.0
+ebooklib>=0.18
+beautifulsoup4>=4.12
+mobi>=0.3