codebee 0.1.68 → 0.1.70

package/app/core/modelhub.py

@@ -2447,21 +2447,23 @@ def binding_dead_msg(cli_id):
             "本步判失败、不回落 CLI 本机默认——%s请在「模型调度（可选）」页为该 CLI 指定已启用的供应商" % hint)
 
 
-def resolve_binding(agent_kind_or_id, difficulty="default"):
+def resolve_binding(agent_kind_or_id, difficulty="default"):
     """返回 {env:{}, model:..., model_fallbacks:[...], codex_provider:..., call_chain:[...]} 或 None。
 
     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
-    # model-only entries that have no provider_id.  The generic runner cannot
-    # inject those model names, so returning a partial chain would make the UI
-    # report a bound model while the CLI silently uses its own default.
-    if agent_kind_or_id in _LOCAL_CRED_ONLY_TARGETS:
-        return None
-    b = _binding_for(agent_kind_or_id)
+    # Local-credential-only CLIs must never expose a binding, including legacy
+    # model-only entries that have no provider_id.  The generic runner cannot
+    # inject those model names, so returning a partial chain would make the UI
+    # report a bound model while the CLI silently uses its own default.
+    if agent_kind_or_id in _LOCAL_CRED_ONLY_TARGETS:
+        return None
+    b = _binding_for(agent_kind_or_id)
     chain = _binding_chain(b)
     provs = {p.get("id"): p for p in providers()}
     routing = bool(b.get("difficulty_routing"))
@@ -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 最小对话实测，

package/app/core/notify.py

@@ -1,106 +1,201 @@
-# -*- coding: utf-8 -*-
-"""运行结果群推送（借鉴 agency-orchestrator 的 --notify）：任务跑完把结果摘要
-推到钉钉/飞书/企业微信群机器人，配合定时自动化就是「AI 团队每天定点交活」。
-
-webhook 一个地址全包——按域名自动适配三种机器人格式（同 agency-orchestrator
-思路）；也接受任意 https 地址（按钉钉 text 形状发，自建 n8n 等自选）。
-推送在后台线程、失败只记日志——通知永远不影响任务本身。
-"""
-from __future__ import annotations
-
-import logging
-
-log = logging.getLogger(__name__)
-
-
-def _payload_for(webhook, text):
-    """按 webhook 域名适配群机器人消息体。返回 None = 无法识别的地址。"""
-    from urllib.parse import urlparse
-    host = (urlparse(webhook).hostname or "").lower()
-    if "dingtalk" in host:
-        return {"msgtype": "text", "text": {"content": text}}
-    if "feishu" in host or "larksuite" in host:
-        return {"msg_type": "text", "content": {"text": text}}
-    if "weixin" in host or "wechat" in host or "work.weixin" in host:
-        return {"msgtype": "text", "text": {"content": text}}
-    if host:
-        return {"msgtype": "text", "text": {"content": text}}   # 未知域名按钉钉形状
-    return None
-
-
-def _webhook():
-    try:
-        from . import settings
-        return str(settings.load().get("notify_webhook") or "").strip()
-    except Exception:
-        return ""
-
-
-def _post(hook, text):
-    """curl 子进程 POST（Python 不经手响应体）；网络失败只记日志。"""
-    from . import runner
-    import json as _json
-    body = _json.dumps(_payload_for(hook, text), ensure_ascii=False)
-    r = runner.run_process(
-        argv=["curl", "-sS", "--max-time", "20",
-              "-H", "Content-Type: application/json",
-              "-d", body, hook],
-        timeout=30)
-    return bool(r["ok"])
-
-
-def push_text(text):
-    """推一条文本到群。配置了 webhook 才推；失败返回 False 不抛错。"""
-    hook = _webhook()
-    if not hook:
-        return False
-    if not hook.startswith("https://"):
-        log.warning("notify webhook 必须是 https")
-        return False
-    try:
-        return _post(hook, text)
-    except Exception as e:
-        log.warning("notify push failed: %s", e)
-        return False
-
-
-def push_run_async(run_id):
-    """任务收尾后异步推送结果摘要（jobs 层调用；绝不阻塞/影响任务）。"""
-    threading.Thread(target=push_run, daemon=True,
-                     name="notify-%s" % run_id, args=(run_id,)).start()
-
-
-def push_run(run_id):
-    """组装 run 结果摘要并推送（webhook 未配置时静默跳过）。
-
-    摘要末尾附分享页路径（notify_base_url 设置非空时拼完整链接，否则只给
-    run_id 供在本机 CodeBee 界面查找）。"""
-    hook = _webhook()
-    if not hook:
-        return False
-    from . import store
-    run = store.get_run(run_id) or {}
-    if not run:
-        return False
-    status = str(run.get("status") or "")
-    mark = {"done": "✅", "failed": "❌", "cancelled": "⚪"}.get(status, "🔔")
-    lines = ["%s CodeBee 任务%s" % (mark, {"done": "完成", "failed": "失败",
-                                           "cancelled": "已取消"}.get(status, status))]
-    lines.append("任务：%s" % (run.get("title") or run_id))
-    if run.get("error"):
-        lines.append("错误：%s" % str(run["error"])[:200])
-    v = run.get("verdict") or {}
-    if v.get("overall") is not None:
-        lines.append("综合评分 %.1f（%s）" % (
-            float(v["overall"]), "达标" if v.get("publishable") else "未达标"))
-    try:
-        from .settings import load as _sload
-        base = str(_sload().get("notify_base_url") or "").strip().rstrip("/")
-        if base:
-            lines.append("📄 详情：%s/api/runs/%s/share" % (base, run_id))
-    except Exception:
-        pass
-    return push_text("\n".join(lines))
-
-
-import threading  # noqa: E402  （push_run_async 依赖；置底避免顶部循环导入）
+# -*- coding: utf-8 -*-
+"""运行结果推送（借鉴 agency-orchestrator 的 --notify）：任务跑完把结果摘要
+推到钉钉/飞书/企业微信群机器人，配合定时自动化就是「AI 团队每天定点交活」。
+
+两类通道：
+  - 群机器人 webhook 一个地址全包——按域名自动适配三种机器人格式；也接受
+    任意 https 地址（按钉钉 text 形状发，自建 n8n 等自选）。
+  - 个人推送通道（Bark / ntfy / Server酱 / Telegram Bot）：推到私人手机，
+    无人值守场景「半夜失败/待裁决」的刚需；群机器人是给群里看的，这是给你看的。
+推送在后台线程、失败只记日志——通知永远不影响任务本身。
+"""
+from __future__ import annotations
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+def _payload_for(webhook, text):
+    """按 webhook 域名适配群机器人消息体。返回 None = 无法识别的地址。"""
+    from urllib.parse import urlparse
+    host = (urlparse(webhook).hostname or "").lower()
+    if "dingtalk" in host:
+        return {"msgtype": "text", "text": {"content": text}}
+    if "feishu" in host or "larksuite" in host:
+        return {"msg_type": "text", "content": {"text": text}}
+    if "weixin" in host or "wechat" in host or "work.weixin" in host:
+        return {"msgtype": "text", "text": {"content": text}}
+    if host:
+        return {"msgtype": "text", "text": {"content": text}}   # 未知域名按钉钉形状
+    return None
+
+
+def _webhook():
+    try:
+        from . import settings
+        return str(settings.load().get("notify_webhook") or "").strip()
+    except Exception:
+        return ""
+
+
+def _send(url, json_body=None, form=None):
+    """curl 子进程发送（Python 不经手响应体）；网络失败只记日志。返回 bool。
+
+    json_body=JSON 体；form=表单体（值需 UTF-8 百分号编码，urlencode 负责）。
+    中文一律走请求体（Server酱表单 / ntfy JSON publish），不走 HTTP 头——
+    头里的非 ASCII 会被网关拒收（历史坑）。
+    """
+    from . import runner
+    import json as _json
+    argv = ["curl", "-sS", "--max-time", "20"]
+    if json_body is not None:
+        argv += ["-H", "Content-Type: application/json",
+                 "-d", _json.dumps(json_body, ensure_ascii=False)]
+    elif form is not None:
+        from urllib.parse import urlencode
+        argv += ["-H", "Content-Type: application/x-www-form-urlencoded",
+                 "-d", urlencode(form)]
+    argv.append(url)
+    r = runner.run_process(argv=argv, timeout=30)
+    return bool(r["ok"])
+
+
+def _post(hook, text):
+    return _send(hook, json_body=_payload_for(hook, text))
+
+
+def _personal_channels():
+    """读设置里的个人推送配置，返回 [(通道名, 发送函数(title, body)), ...]。
+
+    只收录配置完整的通道；键名与 settings.DEFAULTS 对齐。
+    """
+    from . import settings
+    s = settings.load()
+    chs = []
+
+    bark_key = str(s.get("notify_bark_key") or "").strip()
+    if bark_key:
+        server = (str(s.get("notify_bark_server") or "").strip().rstrip("/")
+                  or "https://api.day.app")
+        chs.append(("bark", lambda t, b: _send(
+            server + "/push",
+            json_body={"device_key": bark_key, "title": t, "body": b})))
+
+    ntfy = str(s.get("notify_ntfy_topic") or "").strip()
+    if ntfy:
+        from urllib.parse import urlparse
+        u = urlparse(ntfy if "://" in ntfy else "https://ntfy.sh/" + ntfy.lstrip("/"))
+        topic = u.path.strip("/")
+        if topic:
+            server = "%s://%s" % (u.scheme, u.netloc)
+            chs.append(("ntfy", lambda t, b: _send(
+                server + "/",
+                json_body={"topic": topic, "title": t, "message": b})))
+
+    sc_key = str(s.get("notify_serverchan_key") or "").strip()
+    if sc_key:
+        chs.append(("serverchan", lambda t, b: _send(
+            "https://sctapi.ftqq.com/%s.send" % sc_key,
+            form={"title": t, "desp": b})))
+
+    tg_token = str(s.get("notify_telegram_token") or "").strip()
+    tg_chat = str(s.get("notify_telegram_chat_id") or "").strip()
+    if tg_token and tg_chat:
+        chs.append(("telegram", lambda t, b: _send(
+            "https://api.telegram.org/bot%s/sendMessage" % tg_token,
+            json_body={"chat_id": tg_chat, "text": (t + "\n" + b).strip()})))
+    return chs
+
+
+def _split_title(text):
+    """首行作标题（≤40 字），其余作正文；单行文本标题正文同文。"""
+    lines = [ln for ln in str(text).splitlines() if ln.strip()]
+    title = (lines[0].strip() if lines else "CodeBee")[:40]
+    body = "\n".join(ln.strip() for ln in lines[1:]).strip() or title
+    return title, body
+
+
+def push_text_ex(text):
+    """推一条文本到全部已配置通道，返回 {通道名: 是否成功}。
+
+    未配置任何通道返回 {}；单通道失败不影响其他通道。
+    """
+    results = {}
+    hook = _webhook()
+    if hook:
+        if not hook.startswith("https://"):
+            log.warning("notify webhook 必须是 https")
+            results["webhook"] = False
+        else:
+            try:
+                results["webhook"] = _post(hook, text)
+            except Exception as e:
+                log.warning("notify push failed: %s", e)
+                results["webhook"] = False
+    try:
+        title, body = _split_title(text)
+    except Exception:
+        title, body = "CodeBee", str(text)
+    for name, fn in _personal_channels():
+        try:
+            results[name] = bool(fn(title, body))
+        except Exception as e:
+            log.warning("notify %s push failed: %s", name, e)
+            results[name] = False
+    return results
+
+
+def push_text(text):
+    """推一条文本；任一通道成功即 True；全未配置/全失败返回 False，不抛错。"""
+    try:
+        return any(push_text_ex(text).values())
+    except Exception as e:
+        log.warning("notify push failed: %s", e)
+        return False
+
+
+def push_run_async(run_id):
+    """任务收尾后异步推送结果摘要（jobs 层调用；绝不阻塞/影响任务）。"""
+    threading.Thread(target=push_run, daemon=True,
+                     name="notify-%s" % run_id, args=(run_id,)).start()
+
+
+def push_run(run_id):
+    """组装 run 结果摘要并推送（群 webhook 或任一个人通道配置了才推）。
+
+    摘要末尾附分享页路径（notify_base_url 设置非空时拼完整链接，否则只给
+    run_id 供在本机 CodeBee 界面查找）。"""
+    from . import store
+    run = store.get_run(run_id) or {}
+    if not run:
+        return False
+    status = str(run.get("status") or "")
+    mark = {"done": "✅", "failed": "❌", "cancelled": "⚪"}.get(status, "🔔")
+    lines = ["%s CodeBee 任务%s" % (mark, {"done": "完成", "failed": "失败",
+                                           "cancelled": "已取消"}.get(status, status))]
+    lines.append("任务：%s" % (run.get("title") or run_id))
+    if run.get("error"):
+        lines.append("错误：%s" % str(run["error"])[:200])
+    v = run.get("verdict") or {}
+    if v.get("overall") is not None:
+        lines.append("综合评分 %.1f（%s）" % (
+            float(v["overall"]), "达标" if v.get("publishable") else "未达标"))
+    try:
+        from .settings import load as _sload
+        base = str(_sload().get("notify_base_url") or "").strip().rstrip("/")
+        if base:
+            lines.append("📄 详情：%s/api/runs/%s/share" % (base, run_id))
+    except Exception:
+        pass
+    # 分支待裁决：任务跑完有改动等人拍板时点名提醒（手机端看到即可去详情处理）
+    try:
+        task = store.get_task(run.get("task_id")) if run.get("task_id") else None
+        if task and task.get("git_state") == "isolated":
+            lines.append("⚠ 任务分支待裁决（合并/丢弃）")
+    except Exception:
+        pass
+    return push_text("\n".join(lines))
+
+
+import threading  # noqa: E402  （push_run_async 依赖；置底避免顶部循环导入）