codebee 0.1.64 → 0.1.66

package/app/core/repeat_guard.py

@@ -1,124 +1,129 @@
-# -*- coding: utf-8 -*-
-"""重复 CLI 调用检测：防止编排者用同一份 prompt 反复调同一 CLI 死循环。
-
-设计稿：docs/migration/01-defense-patterns.md §5C。
-参考 dsh packages/guard/repeat-tool-reminder/src/index.ts：
-  监听 tools/post-execute，按 (tool, canonical_args) 跟踪，3/5/8 阈值注入 user-message 提醒。
-
-Tutti 的 "tool" 对应到 "step role"，"canonical_args" 对应到 prompt 模板指纹。
-步骤级调用代价远高于普通工具调用，因此第 3 次提醒、第 5 次强制停止。
-"""
-from __future__ import annotations
-
-import hashlib
-import logging
-import threading
-import time
-
-log = logging.getLogger(__name__)
-
-# 渐进阈值：第 N 次命中时给提醒；最后一次及以上时强制停止。
-DEFAULT_THRESHOLDS = (3, 5)
-
-REMINDER_TEMPLATE = (
-    "⚠️ 提醒：上一步使用了几乎相同的输入（已连续 {count} 次调用 {role}）。"
-    "请换一种方法：读不同的文件、用更具体的指令、或明确询问用户澄清。"
-)
-
-STOP_TEMPLATE = (
-    "已连续 {count} 次使用相同输入调用 {role}，超过 {last_thr} 次阈值，"
-    "强制停止本 step 以防止无限循环。请用户检查输入或调整 prompt 模板。"
-)
-
-
-def _prompt_fingerprint(prompt: str) -> str:
-    """prompt 指纹：用前 200 字符 + 总长度（CLI prompt 头几行通常是模板部分）。
-
-    不做严格 canonical args 比对（CLI prompt 通常很长，且 dsh 也用 JSON.stringify）；
-    指纹命中说明是同一个模板路径走过多次，已经够分辨。
-
-    用 SHA-256 取前 12 字符（96 bit）：48 亿分之一碰撞概率对去重足够；不追求密码学强度。
-    """
-    head = (prompt or "")[:200]
-    return hashlib.sha256(f"{head}|{len(prompt or '')}".encode("utf-8")).hexdigest()[:12]
-
-
-class RepeatGuard:
-    """每 (run_id, step_role) 独立计数；key = prompt 指纹。
-
-    计数仅统计相同 key 连续出现；新 prompt 会重置。
-    """
-
-    def __init__(self, thresholds=DEFAULT_THRESHOLDS, *, max_history=50):
-        self.thresholds = tuple(sorted(set(thresholds)))
-        self.max_history = max_history
-        self._lock = threading.Lock()
-        # chain[(run_id, role)] = [(ts, fingerprint)]
-        self._chains: dict = {}
-
-    def check(self, run_id: str, role: str, prompt: str) -> dict:
-        """检查并更新 (run_id, role) 的连续计数。
-
-        Returns:
-            {"count": int, "reminder": str | None, "should_stop": bool}
-        """
-        fp = _prompt_fingerprint(prompt)
-        chain_key = (run_id, role)
-        with self._lock:
-            chain = self._chains.setdefault(chain_key, [])
-            chain.append((time.time(), fp))
-            # 仅统计相同 fp 连续出现
-            count = 1
-            for _, prev_fp in reversed(chain[:-1]):
-                if prev_fp == fp:
-                    count += 1
-                else:
-                    break
-            # 截尾避免内存膨胀
-            if len(chain) > self.max_history:
-                self._chains[chain_key] = chain[-self.max_history:]
-
-        reminder = None
-        stop = False
-        last_thr = self.thresholds[-1]
-        if count >= last_thr:
-            stop = True
-            reminder = STOP_TEMPLATE.format(count=count, role=role, last_thr=last_thr)
-        elif count in self.thresholds:
-            reminder = REMINDER_TEMPLATE.format(count=count, role=role)
-
-        if reminder:
-            log.warning("repeat-guard %s/%s count=%d stop=%s reminder=%s",
-                        run_id, role, count, stop, reminder[:80])
-        return {"count": count, "reminder": reminder, "should_stop": stop}
-
-    def reset(self, run_id: str) -> int:
-        """重置某 run_id 的所有 (run_id, *) 链。返回清除的链条数。"""
-        with self._lock:
-            cleared = 0
-            for k in list(self._chains.keys()):
-                if k[0] == run_id:
-                    del self._chains[k]
-                    cleared += 1
-            return cleared
-
-    def stats(self, run_id: str, role: str) -> dict:
-        """读取 (run_id, role) 当前状态（不更新）。用于 UI 调试。"""
-        chain_key = (run_id, role)
-        with self._lock:
-            chain = self._chains.get(chain_key, [])
-            if not chain:
-                return {"chain_len": 0, "last_fp": ""}
-            # 当前连续计数
-            last_fp = chain[-1][1]
-            count = 1
-            for _, fp in reversed(chain[:-1]):
-                if fp == last_fp:
-                    count += 1
-                else:
-                    break
-            return {"chain_len": len(chain), "last_fp": last_fp, "count": count}
-
-
-# 模块级默认实例（pipeline 接线用；run_id 入键天然隔离多任务，测试无需替换）
-guard = RepeatGuard()
+# -*- coding: utf-8 -*-
+"""重复 CLI 调用检测：防止编排者用同一份 prompt 反复调同一 CLI 死循环。
+
+设计稿：docs/migration/01-defense-patterns.md §5C。
+参考 dsh packages/guard/repeat-tool-reminder/src/index.ts：
+  监听 tools/post-execute，按 (tool, canonical_args) 跟踪，3/5/8 阈值注入 user-message 提醒。
+
+Tutti 的 "tool" 对应到 step role + 执行者身份，"canonical_args" 对应到 prompt
+模板指纹。不同 CLI 间的换将是有效的回退，不能共享同一个重复预算。步骤级调用
+代价远高于普通工具调用，因此第 3 次提醒、第 5 次强制停止。
+"""
+from __future__ import annotations
+
+import hashlib
+import logging
+import threading
+import time
+
+log = logging.getLogger(__name__)
+
+# 渐进阈值：第 N 次命中时给提醒；最后一次及以上时强制停止。
+DEFAULT_THRESHOLDS = (3, 5)
+
+REMINDER_TEMPLATE = (
+    "⚠️ 提醒：上一步使用了几乎相同的输入（已连续 {count} 次调用 {role}）。"
+    "请换一种方法：读不同的文件、用更具体的指令、或明确询问用户澄清。"
+)
+
+STOP_TEMPLATE = (
+    "已连续 {count} 次使用相同输入调用 {role}，超过 {last_thr} 次阈值，"
+    "强制停止本 step 以防止无限循环。请用户检查输入或调整 prompt 模板。"
+)
+
+
+def _prompt_fingerprint(prompt: str, identity: str = "") -> str:
+    """prompt 指纹：用前 200 字符 + 总长度（CLI prompt 头几行通常是模板部分）。
+
+    不做严格 canonical args 比对（CLI prompt 通常很长，且 dsh 也用 JSON.stringify）；
+    指纹命中说明是同一个模板路径走过多次，已经够分辨。
+
+    用 SHA-256 取前 12 字符（96 bit）：48 亿分之一碰撞概率对去重足够；不追求密码学强度。
+    """
+    head = (prompt or "")[:200]
+    return hashlib.sha256(
+        f"{identity}\0{head}|{len(prompt or '')}".encode("utf-8")).hexdigest()[:12]
+
+
+class RepeatGuard:
+    """每 (run_id, step_role) 的最近执行链独立计数；指纹包含执行者身份。
+
+    计数仅统计相同 key 连续出现；新 prompt 会重置。
+    """
+
+    def __init__(self, thresholds=DEFAULT_THRESHOLDS, *, max_history=50):
+        self.thresholds = tuple(sorted(set(thresholds)))
+        self.max_history = max_history
+        self._lock = threading.Lock()
+        # chain[(run_id, role)] = [(ts, fingerprint)]
+        self._chains: dict = {}
+
+    def check(self, run_id: str, role: str, prompt: str, *, identity: str = "") -> dict:
+        """检查并更新 (run_id, role) 的连续计数。
+
+        identity 标识实际执行 CLI/agent。相同 prompt 换到其他执行者属于回退，
+        会从新的连续链计数；同一执行者重复相同调用仍按阈值停止。
+
+        Returns:
+            {"count": int, "reminder": str | None, "should_stop": bool}
+        """
+        fp = _prompt_fingerprint(prompt, str(identity or ""))
+        chain_key = (run_id, role)
+        with self._lock:
+            chain = self._chains.setdefault(chain_key, [])
+            chain.append((time.time(), fp))
+            # 仅统计相同 fp 连续出现
+            count = 1
+            for _, prev_fp in reversed(chain[:-1]):
+                if prev_fp == fp:
+                    count += 1
+                else:
+                    break
+            # 截尾避免内存膨胀
+            if len(chain) > self.max_history:
+                self._chains[chain_key] = chain[-self.max_history:]
+
+        reminder = None
+        stop = False
+        last_thr = self.thresholds[-1]
+        if count >= last_thr:
+            stop = True
+            reminder = STOP_TEMPLATE.format(count=count, role=role, last_thr=last_thr)
+        elif count in self.thresholds:
+            reminder = REMINDER_TEMPLATE.format(count=count, role=role)
+
+        if reminder:
+            log.warning("repeat-guard %s/%s count=%d stop=%s reminder=%s",
+                        run_id, role, count, stop, reminder[:80])
+        return {"count": count, "reminder": reminder, "should_stop": stop}
+
+    def reset(self, run_id: str) -> int:
+        """重置某 run_id 的所有 (run_id, *) 链。返回清除的链条数。"""
+        with self._lock:
+            cleared = 0
+            for k in list(self._chains.keys()):
+                if k[0] == run_id:
+                    del self._chains[k]
+                    cleared += 1
+            return cleared
+
+    def stats(self, run_id: str, role: str) -> dict:
+        """读取 (run_id, role) 当前状态（不更新）。用于 UI 调试。"""
+        chain_key = (run_id, role)
+        with self._lock:
+            chain = self._chains.get(chain_key, [])
+            if not chain:
+                return {"chain_len": 0, "last_fp": ""}
+            # 当前连续计数
+            last_fp = chain[-1][1]
+            count = 1
+            for _, fp in reversed(chain[:-1]):
+                if fp == last_fp:
+                    count += 1
+                else:
+                    break
+            return {"chain_len": len(chain), "last_fp": last_fp, "count": count}
+
+
+# 模块级默认实例（pipeline 接线用；run_id 入键天然隔离多任务，测试无需替换）
+guard = RepeatGuard()

package/app/core/router.py

@@ -2,10 +2,11 @@
 """智能路由：能力基线 × 历史胜率 × 角色约束 → 选智能体，并给出可解释的理由。"""
 from __future__ import annotations
 
+import json
 import os
 import re
 
-from . import dispatch, history
+from . import dispatch, history, upstream
 
 # 各类智能体的能力基线（0-100）。真实 CLI 里官方双雄最高。
 CAPABILITY = {
@@ -56,8 +57,9 @@ def _history_bonus(stats, agent_id, ttype):
     runs = s["runs"]
     win_rate = s["wins"] / runs
     # 胜率为主，经验为辅；败率要扣分且随样本量爬满（前 3 次线性加权，防一次
-    # 偶发失败把智能体埋了）。0/3 全败 = -18：常挂的 CLI 必须排到无历史的新
-    # 面孔之后（2026-09-17 前败率不扣分，0/3 还拿 +6 经验分，比没跑过还高）。
+    # 偶发失败把智能体埋了）。扣分项封顶 -24，0/3 全败净 -21（含 +3 经验分）、
+    # 0/6 净 -18：常挂的 CLI 必须排到无历史的新面孔之后（2026-09-17 前败率不
+    # 扣分，0/3 还拿 +6 经验分，比没跑过还高）。
     loss_penalty = 24.0 * (1.0 - win_rate) * min(1.0, runs / 3.0)
     return round(18.0 * win_rate + min(6.0, runs) - loss_penalty, 1)
 
@@ -84,6 +86,9 @@ def _online_bonus(agent, role, ttype):
         reason = ("，在线 %d/%d 验收成功（%+.1f），P95 %.1fs（%+.1f），均价 $%.4f（%+.1f）"
                   % (int(metrics.get("successes") or 0), success_samples,
                      success_score, p95, latency_score, cost, cost_score))
+        # 标准要求回退层出现在候选理由里（成本与时延预算第 5 条）：
+        # exact/task-role/task/global，让"分数来自哪层样本"可核对。
+        reason += "，样本层 %s" % (metrics.get("fallback") or "global")
         return total, reason
     except Exception:
         return 0.0, ""
@@ -153,30 +158,89 @@ _LOCAL_ENDPOINT_PROBES = (
     ("codex-cli", "~/.codex/config.toml", r'base_url\s*=\s*"([^"]+)"'),
 )
 
+_PI_SETTINGS_PATH = "~/.pi/agent/settings.json"
+_PI_MODELS_PATH = "~/.pi/agent/models.json"
+
+
+def _pi_provider_hosts(selected_name):
+    """按选中名取 pi 供应商块的 host:port（先 models.json，再 settings.json 兜底）。
+
+    老配置可能把 providers 直接写进 settings.json，两件都认；只认选中的那块。"""
+    hosts = set()
+    if not selected_name:
+        return hosts
+    for rel in (_PI_MODELS_PATH, _PI_SETTINGS_PATH):
+        try:
+            with open(os.path.expanduser(rel), "r", encoding="utf-8") as fh:
+                cfg = json.load(fh)
+        except (OSError, ValueError, TypeError):
+            continue
+        if not isinstance(cfg, dict):
+            continue
+        block = (cfg.get("providers") or {}).get(selected_name)
+        if not isinstance(block, dict):
+            continue
+        h = _host_of(block.get("baseUrl") or block.get("baseURL") or
+                     block.get("base_url"))
+        if h:
+            hosts.add(h)
+            break   # 命中即定：models.json 优先，别让另一件的旧块参与判断
+    return hosts
+
 
 def _host_of(url):
-    """上游归一：只留 host:port。/api/anthropic 与 /v1 的路径差异不算换上游。"""
-    m = re.match(r"^[a-zA-Z][a-zA-Z0-9+.-]*://([^/?#]+)", str(url or "").strip())
-    return m.group(1).lower() if m else ""
+    """上游归一：路径、认证信息和默认端口不影响同一上游身份。"""
+    return upstream.normalize_upstream(url)
 
 
-def agent_upstreams(agent_id):
-    """候选实际会用到的上游集合（host:port 归一）。显式链 > CLI 本机配置
-    端点；两者都拿不到返回空集 = 未知。"""
+def agent_upstreams(agent_id, difficulty="default", task_type="", role=""):
+    """候选实际会用到的上游集合（host:port 归一）。显式链优先；空绑定按
+    运行期自动推荐链判断，再回落到 CLI 本机配置；都拿不到返回空集 = 未知。"""
     ups = set()
     try:
         from . import modelhub
         pref = modelhub._binding_for(agent_id)
-        chain = modelhub._binding_chain(pref)
         provs = {p.get("id"): p for p in modelhub.providers()}
-        if chain:
-            for item in chain:
+
+        def _add_chain(chain):
+            for item in chain or ():
                 pid = (item.get("provider_id") or "").strip()
-                h = _host_of((provs.get(pid) or {}).get("base_url"))
+                provider = item.get("provider") or provs.get(pid) or {}
+                h = _host_of(provider.get("base_url"))
                 if h:
                     ups.add(h)
+
+        configured = bool(modelhub._binding_chain(pref) or pref.get("provider_id"))
+        # 保留原始显式链中的 endpoint，即使某条已禁用/失效；同一个死上游仍
+        # 不值得在另一个 CLI 上立刻再撞一次。
+        if configured:
+            chain = modelhub._binding_chain(pref)
+            _add_chain(chain)
+            resolved = modelhub.resolve_binding(agent_id, difficulty) or {}
+            _add_chain(resolved.get("call_chain"))
+        else:
+            # bind_agent 在空绑定时会自动推荐供应商链。换将选路必须观察同一
+            # 生效链，否则“空绑定”的多个 CLI 可能被排成不同候选却共用一个 403 网关。
+            recommended = modelhub.recommend_binding(
+                agent_id, difficulty, task_type=task_type, role=role) or {}
+            _add_chain(recommended.get("call_chain"))
     except Exception:
         pass
+    if not ups:
+        if agent_id == "pi":
+            # Pi 的选择位在 settings.json（defaultProvider），而 endpoint 在**同目录
+            # models.json** 的 providers.<选中名>.baseUrl（pi 的 getModelsPath()，
+            # CodeBee 托管与用户手工配置都落在那儿）——不能只扫所有 baseUrl，
+            # 那会把未选中的 provider 也误算成当前上游。
+            try:
+                with open(os.path.expanduser(_PI_SETTINGS_PATH), "r",
+                          encoding="utf-8") as fh:
+                    settings = json.load(fh)
+                selected_name = str((settings.get("defaultProvider")
+                                     if isinstance(settings, dict) else "") or "")
+                ups.update(_pi_provider_hosts(selected_name))
+            except (OSError, ValueError, TypeError):
+                pass
     if not ups:
         for aid, path, pat in _LOCAL_ENDPOINT_PROBES:
             if aid != agent_id:
@@ -195,18 +259,27 @@ def agent_upstreams(agent_id):
 
 
 def pick_switch_candidate(agents, role, ttype, stats, exclude=(),
-                          dead_upstreams=()):
+                          dead_upstreams=(), difficulty="default",
+                          blocked_upstreams=()):
     """换将选将。配额类死亡背景下：与死者同上游的候选依次让位，直到找到
     异上游/上游未知的候选（2026-09-22 实案：kimi 与 claude 同骑智谱，0.1 分
     之差把异上游 qwencode 压在下面，换将=换壳不换命）。异上游耗尽后同上游
-    候选捡回分数最高者——聊胜于无。"""
+    候选捡回分数最高者——聊胜于无。403 明确拒绝的上游始终阻断，不捡回重试。"""
     exclude = set(exclude)
+    blocked_sets = [set(d) for d in (blocked_upstreams or ()) if d]
     best, reason = pick(agents, role, ttype, stats, exclude=exclude)
-    if best is None or not dead_upstreams:
+    if best is None or (not dead_upstreams and not blocked_sets):
         return best, reason
     deferred = []
     while best is not None:
-        ups = agent_upstreams(best.get("id"))
+        ups = agent_upstreams(best.get("id"), difficulty=difficulty,
+                              task_type=ttype, role=role)
+        if ups and any(ups & blocked for blocked in blocked_sets):
+            # 明确的 403 权限拒绝：同一上游没有换模型/换 CLI 再试的价值，
+            # 即使异上游候选耗尽也不把它捡回来（与可换账号的配额错误不同）。
+            exclude.add(best.get("id"))
+            best, reason = pick(agents, role, ttype, stats, exclude=exclude)
+            continue
         if not (ups and any(ups & dead for dead in dead_upstreams)):
             break  # 异上游或上游未知：就用它
         deferred.append((best, reason))
@@ -265,14 +338,14 @@ def route_plan(agents, role, task_spec, stats=None, exclude=(), selected=None,
 
 
 def pick_reviewer(agents, impl, ttype, stats=None, exclude=(),
-                  dead_upstreams=()):
+                  dead_upstreams=(), difficulty="default"):
     """评审者：跨厂商是硬规则（Codeband 的对抗式配对）——同族评审有同款盲区，
     评审者必须来自与实现者不同的 kind；跨族池为空才回退同厂商并如实备注，
     绝不把回退伪装成跨厂商。exclude 用于剔除运行时已知死候选（实现步走查证伪
-    的 quota/限流死链），与 pick / pick_switch_candidate 的 exclude 同语义。
+    的 quota/403 死链），与 pick / pick_switch_candidate 的 exclude 同语义。
     dead_upstreams 进一步剔除「与死者同上游」的候选——配额通常按网关/账号烧刻，
-    同上游 = 同配额桶，评审者又是单点，撞死链会白烧一轮并误报「评审器故障」，
-    故宁可少一个候选也不选已知-同上游的。上游未知不剔除（宁白试不误杀）。"""
+    同上游 = 同配额桶，403 权限拒绝也不能换壳重试。评审者又是单点，撞死链会
+    白烧一轮并误报「评审器故障」，故宁可少一个候选也不选已知同上游的。"""
     stats = stats or history.agent_stats()
     excluded = set(exclude)
     dead_sets = [set(d) for d in (dead_upstreams or ()) if d]
@@ -282,7 +355,8 @@ def pick_reviewer(agents, impl, ttype, stats=None, exclude=(),
             return False
         if not dead_sets:
             return True
-        ups = agent_upstreams(a.get("id"))
+        ups = agent_upstreams(a.get("id"), difficulty=difficulty,
+                              task_type=ttype, role="review")
         return not (ups and any(ups & d for d in dead_sets))
 
     impl_kind = impl.get("kind")