codebee 0.1.69 → 0.1.71

package/app/core/market_remote.py

@@ -1039,6 +1039,15 @@ def preview_remote(entry_id):
         _PREVIEW_CACHE[token] = {"entry_id": entry_id, "files": files,
                                  "stripped": stripped, "ts": time.time()}
         file_list = sorted(files.items(), key=lambda kv: kv[0])
+        # 内容安检（ClawHavoc 投毒案借鉴）：对全部技能文本跑危险模式扫描，
+        # 风险随预览返回——UI 高风险红字确认；发现列表给行号可定位。
+        try:
+            from . import skill_scan
+            risk_findings = skill_scan.scan_text(
+                "\n".join(str(v) for v in files.values()))
+            risk_label = skill_scan.risk_label(risk_findings)
+        except Exception:
+            risk_findings, risk_label = [], ""
         return {
             "token": token, "id": entry_id, "title": entry["title"],
             "source": entry["source_name"], "version": entry["version"],
@@ -1048,6 +1057,7 @@ def preview_remote(entry_id):
             "total_chars": sum(len(v) for v in files.values()),
             "file_list": [{"path": k, "chars": len(v)} for k, v in file_list[:60]],
             "stripped": sorted(stripped)[:40], "stripped_total": len(stripped),
+            "risk_label": risk_label, "risk_findings": risk_findings[:8],
             "expires_in": _PREVIEW_TTL,
         }, None
     except ValueError as e:

package/app/core/mcp_client.py

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*-
+"""内置智能体的 MCP 客户端（Model Context Protocol，stdio 形态）。
+
+零依赖：JSON-RPC 2.0 走子进程 stdin/stdout（按行分帧——MCP stdio 传输约定）。
+每次工具调用重新拉起服务器进程：没有长驻会话要管，冷启动成本对内置智能体
+的低频工具循环可接受；进程用完即关（finally 杀树），绝不留孤儿。
+
+配置（settings.mcp_servers，JSON 数组字符串，≤4 个服务器）：
+  [{"name": "fs", "command": "npx", "args": ["-y", "@modelcontextprotocol/server-fs", "C:/x"],
+    "env": {"KEY": "v"}}]
+name 用于工具名前缀（mcp__<name>__<tool>），必须 [a-z0-9_-]。
+
+安全口径：服务器命令是用户在本机自己配置的（与内置智能体 run_command 同一
+自主权级别）；本模块只做传输与解析，不校验工具语义。工具清单按服务器缓存
+（TTL 300s）——每次对话请求重建 tools 列表时不能每次都冷启动全量服务器。
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import threading
+import time
+
+_LOCK = threading.RLock()
+_TOOLS_CACHE = {}          # server_key → (ts, tools)
+_TOOLS_TTL = 300.0
+
+MAX_SERVERS = 4
+MAX_MCP_TOOLS = 24         # 全部服务器合计注入内置智能体的工具数上限
+_NAME_RE = re.compile(r"^[a-z0-9_-]{1,24}$")
+_INIT_TIMEOUT = 15.0
+_CALL_TIMEOUT = 60.0
+_CALL_TIMEOUT_MAX = 300.0
+
+_CLIENT_INFO = {"name": "CodeBee", "version": "1.0"}
+
+
+def invalidate_tools_cache():
+    """服务器配置变化后丢弃已发现工具（插件启停等场景调用）。"""
+    with _LOCK:
+        _TOOLS_CACHE.clear()
+
+
+def parse_servers(text):
+    """settings.mcp_servers 文本 → 校验后的服务器配置列表。返回 (servers, 错误)。"""
+    raw = str(text or "").strip()
+    if not raw:
+        return [], None
+    try:
+        arr = json.loads(raw)
+    except Exception:
+        return None, "mcp_servers 不是合法 JSON"
+    if not isinstance(arr, list):
+        return None, "mcp_servers 必须是数组"
+    if len(arr) > MAX_SERVERS:
+        return None, "最多 %d 个 MCP 服务器" % MAX_SERVERS
+    out = []
+    for item in arr:
+        if not isinstance(item, dict):
+            return None, "MCP 服务器配置必须是对象"
+        name = str(item.get("name") or "").strip()
+        command = str(item.get("command") or "").strip()
+        if not _NAME_RE.match(name):
+            return None, "服务器名 %r 只能是小写字母/数字/-/_（≤24 位）" % name[:24]
+        if not command:
+            return None, "服务器 %s 缺 command" % name
+        args = item.get("args") if isinstance(item.get("args"), list) else []
+        args = [str(a) for a in args][:16]
+        env = item.get("env") if isinstance(item.get("env"), dict) else {}
+        env = {str(k): str(v) for k, v in list(env.items())[:16]}
+        out.append({"name": name, "command": command, "args": args, "env": env})
+    return out, None
+
+
+class _Session:
+    """一次性的 MCP 服务器会话：spawn → initialize → （list/call）→ 杀树。"""
+
+    def __init__(self, server):
+        self.server = server
+        self.proc = None
+        self.lines = None       # reader 线程产出的行队列
+        self.err = None
+
+    def _pump_err(self):
+        try:
+            for _ in self.proc.stderr:
+                pass
+        except Exception:
+            pass
+
+    def _pump_out(self):
+        try:
+            for raw in self.proc.stdout:
+                self.lines.put(raw.decode("utf-8", errors="replace").rstrip("\r\n"))
+        except Exception:
+            pass
+        finally:
+            self.lines.put(None)      # EOF 哨兵
+
+    def __enter__(self):
+        try:
+            self.proc = subprocess.Popen(
+                [self.server["command"]] + list(self.server.get("args") or []),
+                stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE, text=False,
+                env={**os.environ, **(self.server.get("env") or {})})
+        except Exception as e:
+            raise RuntimeError("MCP 服务器启动失败: %s" % e)
+        import queue as _queue
+        self.lines = _queue.Queue()
+        threading.Thread(target=self._pump_out, daemon=True).start()
+        threading.Thread(target=self._pump_err, daemon=True).start()
+        self._request("initialize", {
+            "protocolVersion": "2024-11-05", "capabilities": {},
+            "clientInfo": _CLIENT_INFO}, timeout=_INIT_TIMEOUT)
+        self._notify("notifications/initialized")
+        return self
+
+    def __exit__(self, *exc):
+        try:
+            if self.proc and self.proc.stdin:
+                try:
+                    self.proc.stdin.close()
+                except Exception:
+                    pass
+        finally:
+            try:
+                if self.proc:
+                    self.proc.kill()
+            except Exception:
+                pass
+        return False
+
+    def _send(self, obj):
+        data = json.dumps(obj, ensure_ascii=False).encode("utf-8") + b"\n"
+        self.proc.stdin.write(data)
+        self.proc.stdin.flush()
+
+    def _notify(self, method, params=None):
+        self._send({"jsonrpc": "2.0", "method": method, "params": params or {}})
+
+    def _request(self, method, params, timeout):
+        """单请求单响应；忽略通知与未知 id 的服务端请求。"""
+        rid = id({})
+        self._send({"jsonrpc": "2.0", "id": 1 if method == "initialize" else rid,
+                    "method": method, "params": params or {}})
+        deadline = time.time() + max(1.0, timeout)
+        while True:
+            remain = deadline - time.time()
+            if remain <= 0:
+                raise RuntimeError("%s 超时（%.0fs）" % (method, timeout))
+            try:
+                line = self.lines.get(timeout=remain)
+            except Exception:
+                raise RuntimeError("%s 超时（%.0fs）" % (method, timeout))
+            if line is None:
+                raise RuntimeError("MCP 服务器提前退出")
+            line = line.strip()
+            if not line.startswith("{"):
+                continue
+            try:
+                msg = json.loads(line)
+            except Exception:
+                continue
+            if not isinstance(msg, dict) or msg.get("id") is None:
+                continue                     # 通知/服务端请求：不匹配本调用
+            if msg.get("id") != (1 if method == "initialize" else rid):
+                continue
+            if msg.get("error"):
+                raise RuntimeError("MCP %s 失败: %s" % (
+                    method, json.dumps(msg["error"], ensure_ascii=False)[:200]))
+            return msg.get("result") or {}
+
+
+def list_tools(server):
+    """发现服务器工具。返回 {"ok", "tools":[{"name","description","input_schema"}], "error"}。"""
+    try:
+        with _Session(server) as sess:
+            res = sess._request("tools/list", {}, timeout=_INIT_TIMEOUT)
+        tools = []
+        for t in (res.get("tools") or [])[:16]:
+            if isinstance(t, dict) and isinstance(t.get("name"), str) and t["name"]:
+                tools.append({"name": t["name"],
+                              "description": str(t.get("description") or "")[:400],
+                              "input_schema": t.get("input_schema")
+                              if isinstance(t.get("input_schema"), dict) else
+                              {"type": "object", "properties": {}}})
+        return {"ok": True, "tools": tools, "error": ""}
+    except Exception as e:
+        return {"ok": False, "tools": [], "error": str(e)[:200]}
+
+
+def call_tool(server, tool_name, arguments, timeout_s=_CALL_TIMEOUT):
+    """调用一个工具。返回 {"ok", "text", "error", "is_error"}。"""
+    try:
+        timeout = min(_CALL_TIMEOUT_MAX, max(5.0, float(timeout_s or _CALL_TIMEOUT)))
+        with _Session(server) as sess:
+            res = sess._request("tools/call",
+                                {"name": tool_name,
+                                 "arguments": arguments if isinstance(arguments, dict) else {}},
+                                timeout=timeout)
+        parts = []
+        for c in res.get("content") or []:
+            if isinstance(c, dict) and c.get("type") == "text" and c.get("text"):
+                parts.append(str(c["text"]))
+        text = "\n".join(parts)[:20000]
+        is_err = bool(res.get("isError"))
+        return {"ok": bool(text) and not is_err, "text": text,
+                "error": "" if not is_err else (text or "工具返回 isError"),
+                "is_error": is_err}
+    except Exception as e:
+        return {"ok": False, "text": "", "error": str(e)[:200], "is_error": False}
+
+
+# ---- 面向 builtin_agent 的合并视图（带缓存） ----
+
+def tool_specs_cached(force=False):
+    """全部服务器的工具合并清单：[{server, name(原名), full_name, description,
+    input_schema}]。TTL 内走缓存；单个服务器失败跳过（error 挂在条目外不打断）。"""
+    with _LOCK:
+        if not force:
+            hit = True
+            for key, (ts, _t) in _TOOLS_CACHE.items():
+                if time.time() - ts > _TOOLS_TTL:
+                    hit = False
+                    break
+            if hit and _TOOLS_CACHE:
+                out = []
+                for _key, (_ts, tools) in _TOOLS_CACHE.items():
+                    out.extend(tools)
+                return out[:MAX_MCP_TOOLS]
+    servers, err = parse_servers(_settings_text())
+    if err or not servers:
+        return []
+    out = []
+    with _LOCK:
+        _TOOLS_CACHE.clear()
+    for srv in servers:
+        res = list_tools(srv)
+        if not res.get("ok"):
+            continue
+        specs = []
+        for t in res["tools"]:
+            specs.append({"server": srv["name"], "name": t["name"],
+                          "full_name": "mcp__%s__%s" % (srv["name"], t["name"]),
+                          "description": t["description"],
+                          "input_schema": t["input_schema"]})
+        with _LOCK:
+            _TOOLS_CACHE[srv["name"]] = (time.time(), specs)
+        out.extend(specs)
+        if len(out) >= MAX_MCP_TOOLS:
+            break
+    return out[:MAX_MCP_TOOLS]
+
+
+def dispatch_full_name(full_name, arguments, timeout_s=_CALL_TIMEOUT):
+    """mcp__<server>__<tool> → 找服务器配置并调用。返回 {"ok","text","error"}。"""
+    m = re.match(r"^mcp__([a-z0-9_-]{1,24})__(.+)$", str(full_name or ""))
+    if not m:
+        return {"ok": False, "text": "", "error": "非法 MCP 工具名"}
+    sname, tool = m.group(1), m.group(2)
+    servers, err = parse_servers(_settings_text())
+    if err:
+        return {"ok": False, "text": "", "error": err}
+    srv = next((s for s in servers if s["name"] == sname), None)
+    if not srv:
+        return {"ok": False, "text": "", "error": "MCP 服务器 %s 未配置" % sname}
+    return call_tool(srv, tool, arguments, timeout_s=timeout_s)
+
+
+_SETTINGS_TEXT = None     # main.py 启动注入（读 settings.mcp_servers）——本模块
+                           # 不直接依赖 settings(L0)，静态图保持干净（同 set_run_estimator 模式）
+
+
+def set_settings_text(fn):
+    """注入 MCP 服务器清单读取器；未注入时工具清单为空（MCP 功能关闭）。"""
+    global _SETTINGS_TEXT
+    _SETTINGS_TEXT = fn if callable(fn) else None
+
+
+def _settings_text():
+    try:
+        return str(_SETTINGS_TEXT() or "") if _SETTINGS_TEXT else ""
+    except Exception:
+        return ""

package/app/core/mocks.py

@@ -1,64 +1,64 @@
-# -*- coding: utf-8 -*-
-"""内置演示/测试智能体（mock）：不消耗任何配额即可跑通全流程。"""
-from __future__ import annotations
-
-import hashlib
-
-
-def _seed(agent_id):
-    return int(hashlib.sha256(agent_id.encode("utf-8")).hexdigest()[:6], 16)
-
-
-def draft_manuscript(task, round_no):
-    """生成一份示例稿件（mock 起草/修订直接落盘的内容）。"""
-    title = task.get("title") or "未命名章节"
-    goal = task.get("goal") or ""
-    return (
-        "# {title}\n\n"
-        "这是第 {r} 轮 mock 草稿（演示用，不消耗模型配额）。\n\n"
-        "## 任务目标\n{goal}\n\n"
-        "## 正文\n"
-        "夜色沿着山脊线缓慢退去，主角终于看清了石门上的刻痕——那不是文字，"
-        "而是一段被反复涂抹又反复显影的名字。他伸手触碰的瞬间，耳边响起的"
-        "却是自己昨夜说过的话。{extra}\n\n"
-        "（本轮修订关注：{focus}）\n"
-    ).format(
-        title=title, r=round_no, goal=goal,
-        extra="这一段在第 2 轮修订中补充了人物动机的伏笔。" if round_no >= 2 else "",
-        focus="节奏与悬念铺排" if round_no == 1 else "人物弧光与首尾呼应",
-    )
-
-
-def implement_note(task):
-    return "（mock 实现）已在目标目录写入 mock-impl.txt 作为变更占位。"
-
-
-def critique(agent_id, round_no, dims, threshold):
-    """确定性评分：第 1 轮略低于阈值，第 2 轮达标，用于验证发布门禁逻辑。"""
-    s = _seed(agent_id)
-    scores = {}
-    for i, d in enumerate(dims):
-        jitter = ((s >> i) % 5) * 0.1
-        scores[d] = round(min(9.5, 4.8 + 1.2 * round_no + jitter), 1)
-    passed = all(v >= threshold for v in scores.values())
-    issues = []
-    if round_no == 1:
-        issues = [
-            {"dim": dims[0], "severity": "major", "note": "开篇信息密度偏低，钩子出现太晚（mock 意见）"},
-            {"dim": dims[-1], "severity": "minor", "note": "段落长短交替不够，读感偏平（mock 意见）"},
-        ]
-    return {
-        "scores": scores,
-        "issues": issues,
-        "summary": "mock 总评：第 %d 轮稿件%s发布阈值" % (round_no, "已达到" if passed else "尚未达到"),
-    }
-
-
-def review(task, verify_passed):
-    return {
-        "pass": bool(verify_passed),
-        "scores": {"正确性": 8.0 if verify_passed else 5.0, "可维护性": 8.0, "安全": 8.5},
-        "issues": [] if verify_passed else [
-            {"severity": "major", "title": "验证命令未通过", "detail": "请检查测试输出（mock 意见）"}],
-        "summary": "mock 代码评审：%s" % ("通过" if verify_passed else "未通过"),
-    }
+# -*- coding: utf-8 -*-
+"""内置演示/测试智能体（mock）：不消耗任何配额即可跑通全流程。"""
+from __future__ import annotations
+
+import hashlib
+
+
+def _seed(agent_id):
+    return int(hashlib.sha256(agent_id.encode("utf-8")).hexdigest()[:6], 16)
+
+
+def draft_manuscript(task, round_no):
+    """生成一份示例稿件（mock 起草/修订直接落盘的内容）。"""
+    title = task.get("title") or "未命名章节"
+    goal = task.get("goal") or ""
+    return (
+        "# {title}\n\n"
+        "这是第 {r} 轮 mock 草稿（演示用，不消耗模型配额）。\n\n"
+        "## 任务目标\n{goal}\n\n"
+        "## 正文\n"
+        "夜色沿着山脊线缓慢退去，主角终于看清了石门上的刻痕——那不是文字，"
+        "而是一段被反复涂抹又反复显影的名字。他伸手触碰的瞬间，耳边响起的"
+        "却是自己昨夜说过的话。{extra}\n\n"
+        "（本轮修订关注：{focus}）\n"
+    ).format(
+        title=title, r=round_no, goal=goal,
+        extra="这一段在第 2 轮修订中补充了人物动机的伏笔。" if round_no >= 2 else "",
+        focus="节奏与悬念铺排" if round_no == 1 else "人物弧光与首尾呼应",
+    )
+
+
+def implement_note(task):
+    return "（mock 实现）已在目标目录写入 mock-impl.txt 作为变更占位。"
+
+
+def critique(agent_id, round_no, dims, threshold):
+    """确定性评分：第 1 轮略低于阈值，第 2 轮达标，用于验证发布门禁逻辑。"""
+    s = _seed(agent_id)
+    scores = {}
+    for i, d in enumerate(dims):
+        jitter = ((s >> i) % 5) * 0.1
+        scores[d] = round(min(9.5, 4.8 + 1.2 * round_no + jitter), 1)
+    passed = all(v >= threshold for v in scores.values())
+    issues = []
+    if round_no == 1:
+        issues = [
+            {"dim": dims[0], "severity": "major", "note": "开篇信息密度偏低，钩子出现太晚（mock 意见）"},
+            {"dim": dims[-1], "severity": "minor", "note": "段落长短交替不够，读感偏平（mock 意见）"},
+        ]
+    return {
+        "scores": scores,
+        "issues": issues,
+        "summary": "mock 总评：第 %d 轮稿件%s发布阈值" % (round_no, "已达到" if passed else "尚未达到"),
+    }
+
+
+def review(task, verify_passed):
+    return {
+        "pass": bool(verify_passed),
+        "scores": {"正确性": 8.0 if verify_passed else 5.0, "可维护性": 8.0, "安全": 8.5},
+        "issues": [] if verify_passed else [
+            {"severity": "major", "title": "验证命令未通过", "detail": "请检查测试输出（mock 意见）"}],
+        "summary": "mock 代码评审：%s" % ("通过" if verify_passed else "未通过"),
+    }

package/app/core/modelhub.py

@@ -2452,7 +2452,9 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
 
     call_chain 是跨厂商降级链（唯一真源）：每条 {model, env, provider, [codex_provider]}，
     按序尝试；供应商失效（停用/删除/无密钥/协议不可注入）的条目被跳过，全链失效
-    → 整体回落 CLI 默认（None）。纯链条目（无供应商）不注入 env，只传 -m。
+    → 整体回落 CLI 默认（None）。纯链条目（无供应商）不注入 env，只传 -m，
+    并带 no_cred=True 标记供 runner 审计层点名（零凭据条目走本机登录态，
+    本机无登录态必死在凭据闸门——2026-09-25 Mac claude 实案）。
     难度路由只在无显式链时生效。
     """
     # Local-credential-only CLIs must never expose a binding, including legacy
@@ -2487,7 +2489,11 @@ def resolve_binding(agent_kind_or_id, difficulty="default"):
             pid = (item.get("provider_id") or "").strip()
             if not pid:
                 if model:
-                    entries.append({"model": model, "env": {}, "provider": None})
+                    # 纯模型条目：零凭据注入，只传 -m 走 CLI 本机登录态。
+                    # no_cred 标记供 runner 审计行/登录指引点名（Mac claude 案：
+                    # 零注入死在登录闸门，起跑前无人知、死后只能靠 init JSON 反推）
+                    entries.append({"model": model, "env": {}, "provider": None,
+                                    "no_cred": True})
                 continue
             prov = provs.get(pid)
             if not prov or not prov.get("enabled", True) or not prov.get("api_key"):
@@ -2803,12 +2809,84 @@ def models_view():
             if m.get("hidden"):
                 continue
             pr = pricing.get(m["name"]) or {}
+            if m.get("price_in") is not None or m.get("price_out") is not None:
+                pr = {"in": m.get("price_in"), "out": m.get("price_out")}   # 手标优先
             rows.append(dict(base, name=m["name"], enabled=bool(m.get("enabled", True)),
                              priority=m.get("priority", 0),
                              price_in=pr.get("in"), price_out=pr.get("out")))
     return rows
 
 
+def model_price(model_name, provider=""):
+    """模型单价（¥ / 百万 tokens）：指定供应商的手标价优先，回落 CCSwitch
+    导入价表；都没有返回 None——不猜价，台账不记钱、预算不计入。
+
+    手标是「按供应商」标定的（同名模型在不同网关价格可不同），因此指定
+    供应商未标价时不继承别家手标，直接看价表。
+    列名沿用台账 cost_usd 字段，语义自本函数起 = 费用（¥）。
+    """
+    def _manual(prov_id):
+        with _LOCK:
+            for p in _load().get("providers", []):
+                if not prov_id or p.get("id") != prov_id:
+                    continue
+                for m in p.get("models") or []:
+                    if m.get("name") != model_name:
+                        continue
+                    try:
+                        pin = float(m.get("price_in"))
+                        pout = float(m.get("price_out"))
+                    except (TypeError, ValueError):
+                        continue
+                    if pin >= 0 and pout >= 0 and (pin or pout):
+                        return {"in": pin, "out": pout}
+        return None
+
+    try:
+        pr = _manual(provider)
+        if pr:
+            return pr
+        with _LOCK:
+            raw = (_load().get("pricing") or {}).get(model_name) or {}
+        pin, pout = float(raw.get("in") or 0), float(raw.get("out") or 0)
+        if pin > 0 or pout > 0:
+            return {"in": pin, "out": pout}
+    except Exception:
+        pass
+    return None
+
+
+def set_model_price(provider_id, name, price_in, price_out):
+    """手标模型单价（¥/百万 tokens；空串=清除标定，回落价表/未标价）。"""
+    def _num(v):
+        v = str(v if v is not None else "").strip()
+        return float(v) if v != "" else None
+    try:
+        pin, pout = _num(price_in), _num(price_out)
+    except (TypeError, ValueError):
+        return "单价必须是数字"
+    if (pin is not None and pin < 0) or (pout is not None and pout < 0):
+        return "单价不能为负"
+    with _LOCK:
+        data = _load()
+        prov = next((p for p in data.get("providers", []) if p.get("id") == provider_id), None)
+        if not prov:
+            return "供应商不存在"
+        m = next((x for x in prov.get("models") or [] if x.get("name") == name), None)
+        if not m:
+            return "模型不存在"
+        if pin is None:
+            m.pop("price_in", None)
+        else:
+            m["price_in"] = pin
+        if pout is None:
+            m.pop("price_out", None)
+        else:
+            m["price_out"] = pout
+        _save(data)
+    return None
+
+
 def reorder_models(provider_id, ordered_names):
     """按给定名称顺序重设优先级（列表中未出现的模型排在最后，保持相对顺序）。"""
     with _LOCK:
@@ -3103,6 +3181,111 @@ def test_model(provider_id, model_name, key_id=""):
     return finish(last)
 
 
+def generate_once(provider_id, model_name, prompt, max_tokens=2048, timeout_s=120):
+    """单轮真实生成（评测基准台等需要「自定义 prompt 实答」的场景）。
+
+    与 test_model 同一套 wire 解析（auto 探测/多 KEY 回退/KEY 健康记账），
+    但发的是真实生成请求并取回正文。返回
+    {ok, text, usage{input,output}, protocol, key_id, latency_ms, error}；
+    任何失败折叠进 ok=False + error，绝不抛出。
+    """
+    import time as _t
+    with _LOCK:
+        prov = next((p for p in providers() if p.get("id") == provider_id), None)
+    if not prov:
+        return {"ok": False, "text": "", "usage": None, "error": "供应商不存在"}
+    keys = _chain_keys(prov)
+    if not keys:
+        return {"ok": False, "text": "", "usage": None, "error": "无可用 API KEY"}
+    allow_private = bool(prov.get("allow_private"))
+    t0 = _t.time()
+
+    def out(ok, text="", usage=None, protocol="", key_id="", error=""):
+        return {"ok": ok, "text": text, "usage": usage, "protocol": protocol,
+                "key_id": key_id, "error": error,
+                "latency_ms": int((_t.time() - t0) * 1000)}
+
+    last_err = "无可用 wire"
+    for key_index, kk in enumerate(keys):
+        probe_key_id = (kk.get("id") or "") if key_index > 0 else ""
+        protos, note = _ensure_wire_candidates(provider_id, prov, model_name,
+                                               key_id=probe_key_id,
+                                               force_probe=bool(probe_key_id))
+        if not protos:
+            last_err = "无已验证的兼容 wire" + ("（%s）" % note if note else "")
+            note_key_error(provider_id, kk.get("id") or "", last_err)
+            continue
+        for proto, pbase in protos:
+            base = (pbase or "").rstrip("/")
+            if proto == "google":
+                url = base + ("/models/%s:generateContent" % model_name
+                              if base.endswith("/v1beta")
+                              else "/v1beta/models/%s:generateContent" % model_name)
+                headers = {"x-goog-api-key": kk["key"]}
+                body = {"contents": [{"parts": [{"text": prompt}]}],
+                        "generationConfig": {"maxOutputTokens": max_tokens}}
+            else:
+                path = "/messages" if proto == "anthropic" else "/chat/completions"
+                url = (base + path) if base.endswith("/v1") else (base + "/v1" + path)
+                if proto == "anthropic":
+                    headers = {"x-api-key": kk["key"], "anthropic-version": "2023-06-01"}
+                else:
+                    headers = {"Authorization": "Bearer " + kk["key"]}
+                body = {"model": model_name, "max_tokens": max_tokens,
+                        "messages": [{"role": "user", "content": prompt}]}
+            status, data, err = _post_json_http(url, headers, body, allow_private,
+                                                timeout=timeout_s)
+            if status == 0:
+                last_err = err or "连接失败"
+                note_key_error(provider_id, kk.get("id") or "", last_err)
+                continue
+            if not (200 <= status < 300):
+                last_err = "HTTP %s %s" % (status, _response_error_text(data) or "")
+                note_key_error(provider_id, kk.get("id") or "", last_err)
+                continue
+            text, usage_d = _extract_generation(proto, data)
+            if not (text or "").strip():
+                last_err = "HTTP 200 空响应"
+                note_key_error(provider_id, kk.get("id") or "", last_err)
+                continue
+            note_key_ok(provider_id, kk.get("id") or "")
+            return out(True, text, usage_d, proto, kk.get("id") or "")
+    return out(False, error=last_err)
+
+
+def _extract_generation(proto, data):
+    """从三族 wire 的生成响应里取正文与 token 细分。取不到返回 ("", None)。"""
+    if not isinstance(data, dict):
+        return "", None
+    text, usage_d = "", None
+    try:
+        if proto == "openai":
+            msg = ((data.get("choices") or [{}])[0] or {}).get("message") or {}
+            c = msg.get("content")
+            text = c if isinstance(c, str) else "".join(
+                p.get("text") or "" for p in c) if isinstance(c, list) else ""
+            u = data.get("usage") or {}
+            usage_d = {"input": u.get("prompt_tokens") or 0,
+                       "output": u.get("completion_tokens") or 0}
+        elif proto == "anthropic":
+            text = "".join(b.get("text") or "" for b in data.get("content") or []
+                           if isinstance(b, dict) and b.get("type") == "text")
+            u = data.get("usage") or {}
+            usage_d = {"input": u.get("input_tokens") or 0,
+                       "output": u.get("output_tokens") or 0}
+        elif proto == "google":
+            cand = ((data.get("candidates") or [{}])[0] or {})
+            text = "".join(p.get("text") or "" for p in (cand.get("content") or {}).get("parts") or [])
+            u = data.get("usageMetadata") or {}
+            usage_d = {"input": u.get("promptTokenCount") or 0,
+                       "output": u.get("candidatesTokenCount") or 0}
+    except Exception:
+        pass
+    if usage_d is not None and not any(isinstance(v, (int, float)) for v in usage_d.values()):
+        usage_d = None
+    return text, usage_d
+
+
 # ---------------------------------------------------------------- wire 协议适配
 # 聚合中转网关（new-api/one-api 系）通常同一密钥同时开 openai(/chat/completions)
 # 与 anthropic(/v1/messages) 两面 wire。在「模型接入」页用 1 token 最小对话实测，