codebee 0.1.62 → 0.1.63

package/app/core/capability.py

@@ -1,144 +1,144 @@
-# -*- coding: utf-8 -*-
-"""能力维度（4D）：按任务类型（writing/coding/reasoning/vision）选模型。
-
-设计稿：docs/migration/05-model-seams.md §4D（按 CodeBee 实际架构落地：
-不改 modelhub.py——供应商声明可选 `strengths` 字段即可被识别；
-选择逻辑独立成模块，零侵入）。
-
-供应商声明示例（data/models.json 的 providers 条目）：
-  {"id": "p1", ..., "strengths": ["writing", "reasoning"]}
-未声明 strengths 的供应商视为无偏好（只做兜底）。
-"""
-from __future__ import annotations
-
-import re
-
-from .dispatch import TYPE_DIMENSIONS
-
-# 能力维度（先固化清单，schema 见设计稿）
-DIMS = ("writing", "coding", "reasoning", "vision")
-
-# 关键词分类表（覆盖 task type / 目标文本；可按需扩充）
-_KEYWORDS = {
-    "writing": ("写", "文案", "大纲", "连载", "章节", "小说", "营销", "总结", "润色",
-                "novel", "draft", "review"),
-    "coding": ("代码", "实现", "修复", "重构", "测试", "bug", "code", "fix",
-               "refactor", "test", "编译", "报错"),
-    "reasoning": ("推理", "分析", "调研", "对比", "规划", "拆解", "评审",
-                  "reason", "analyze", "plan", "orchestrate"),
-    "vision": ("图", "图片", "识别", "视觉", "ocr", "image", "vision", "截图"),
-}
-
-
-def classify_task_type(task) -> str:
-    """把任务分类到 DIMS 之一。task 显式带 task_type 时优先。"""
-    explicit = str((task or {}).get("task_type") or "").strip().lower()
-    if explicit in DIMS:
-        return explicit
-    preset = str((task or {}).get("type") or "").strip().lower()
-    if preset in TYPE_DIMENSIONS:
-        return TYPE_DIMENSIONS[preset]
-    text = "%s %s" % ((task or {}).get("type") or "",
-                      (task or {}).get("goal") or "")
-    scores = {}
-    for dim, kws in _KEYWORDS.items():
-        scores[dim] = sum(1 for kw in kws if kw in text)
-    best = max(scores, key=lambda d: scores[d])
-    if scores[best] > 0:
-        return best
-    return "coding"  # 默认兜底（CodeBee 主场景）
-
-
-def provider_strengths(prov):
-    """读供应商声明的能力维度（容错：非法值忽略）。"""
-    raw = (prov or {}).get("strengths")
-    if not isinstance(raw, list):
-        return []
-    return [s for s in raw if s in DIMS]
-
-
-def pick_by_strength(providers, task_type, *, enabled_only=True):
-    """按能力维度挑供应商。
-
-    规则：
-      1. 声明了该维度的可用供应商优先（保持原有顺序）；
-      2. 未声明的排后面（兜底）；
-      3. 都没有声明时返回原顺序（行为同现状）。
-    返回 (排序后的供应商列表, 分类依据说明)。
-    """
-    task_type = task_type if task_type in DIMS else classify_task_type({"goal": task_type})
-    pool = list(providers or [])
-    if enabled_only:
-        pool = [p for p in pool if p.get("enabled", True)]
-    strong = [p for p in pool if task_type in provider_strengths(p)]
-    rest = [p for p in pool if p not in strong]
-    ranked = strong + rest
-    reason = "%s：优先 %s" % (
-        task_type,
-        "、".join(p.get("id", "?") for p in strong) if strong else "（无声明，按原序兜底）")
-    return ranked, reason
-
-
-def resolve_binding_by_task(task, providers, bindings):
-    """任务 → 绑定解析（能力维度优先，回落 default）。
-
-    bindings 形如 modelhub 的 {"writing": {...}, "coding": {...}, "default": {...}}；
-    对应维度的绑定缺失/为空时回落 default。返回 (binding, task_type)。
-    """
-    tt = classify_task_type(task)
-    b = (bindings or {}).get(tt)
-    if not b:
-        b = (bindings or {}).get("default")
-    return b, tt
-
-
-# ---------------------------------------------------------------- §07 T3.1 级联
-
-TIER_ORDER = {"budget": 0, "standard": 1, "premium": 2}
-
-
-def cascade_reorder(agent, tier_of, *, providers=None, pricing=None,
-                    difficulty="easy", task_type="", role=""):
-    """FrugalGPT 式便宜优先：easy 任务把 call_chain 按 tier 升序稳定重排。
-
-    agent 来自 modelhub.bind_agent（可能带 call_chain）；tier_of(chain_entry)
-    返回该条目的档位串（"budget"/"standard"/"premium"或 None=standard）。
-    稳定排序保证同档内保持用户配置的原顺序。链长 <2 或非链式原样返回。
-    """
-    chain = (agent or {}).get("call_chain") or []
-    if len(chain) < 2:
-        return agent
-    if providers is not None and (task_type or role):
-        from .dispatch import rank_model_entries
-        ranked, _decisions = rank_model_entries(
-            chain, {p.get("id"): p for p in providers or []},
-            pricing or {}, difficulty, task_type, role)
-        out = dict(agent)
-        out["call_chain"] = ranked
-        return out
-
-    def key(entry):
-        return TIER_ORDER.get(tier_of(entry) or "standard", 1)
-
-    out = dict(agent)
-    out["call_chain"] = sorted(chain, key=key)
-    return out
-
-
-def make_tier_lookup(providers):
-    """由 providers 列表构造 chain_entry → tier 的查询函数。
-
-    tier 来源（按优先级）：链条目 model 在供应商 models[] 里的 tier 字段 →
-    供应商级 tier → None（按 standard 兜底）。缺什么都不抛。
-    """
-    by_id = {p.get("id"): p for p in (providers or []) if p.get("id")}
-
-    def tier_of(entry):
-        p = by_id.get((entry or {}).get("provider_id") or "")
-        if not p:
-            return None
-        for m in (p.get("models") or []):
-            if isinstance(m, dict) and m.get("name") == (entry or {}).get("model"):
-                return m.get("tier") or p.get("tier")
-        return p.get("tier")
-    return tier_of
+# -*- coding: utf-8 -*-
+"""能力维度（4D）：按任务类型（writing/coding/reasoning/vision）选模型。
+
+设计稿：docs/migration/05-model-seams.md §4D（按 CodeBee 实际架构落地：
+不改 modelhub.py——供应商声明可选 `strengths` 字段即可被识别；
+选择逻辑独立成模块，零侵入）。
+
+供应商声明示例（data/models.json 的 providers 条目）：
+  {"id": "p1", ..., "strengths": ["writing", "reasoning"]}
+未声明 strengths 的供应商视为无偏好（只做兜底）。
+"""
+from __future__ import annotations
+
+import re
+
+from .dispatch import TYPE_DIMENSIONS
+
+# 能力维度（先固化清单，schema 见设计稿）
+DIMS = ("writing", "coding", "reasoning", "vision")
+
+# 关键词分类表（覆盖 task type / 目标文本；可按需扩充）
+_KEYWORDS = {
+    "writing": ("写", "文案", "大纲", "连载", "章节", "小说", "营销", "总结", "润色",
+                "novel", "draft", "review"),
+    "coding": ("代码", "实现", "修复", "重构", "测试", "bug", "code", "fix",
+               "refactor", "test", "编译", "报错"),
+    "reasoning": ("推理", "分析", "调研", "对比", "规划", "拆解", "评审",
+                  "reason", "analyze", "plan", "orchestrate"),
+    "vision": ("图", "图片", "识别", "视觉", "ocr", "image", "vision", "截图"),
+}
+
+
+def classify_task_type(task) -> str:
+    """把任务分类到 DIMS 之一。task 显式带 task_type 时优先。"""
+    explicit = str((task or {}).get("task_type") or "").strip().lower()
+    if explicit in DIMS:
+        return explicit
+    preset = str((task or {}).get("type") or "").strip().lower()
+    if preset in TYPE_DIMENSIONS:
+        return TYPE_DIMENSIONS[preset]
+    text = "%s %s" % ((task or {}).get("type") or "",
+                      (task or {}).get("goal") or "")
+    scores = {}
+    for dim, kws in _KEYWORDS.items():
+        scores[dim] = sum(1 for kw in kws if kw in text)
+    best = max(scores, key=lambda d: scores[d])
+    if scores[best] > 0:
+        return best
+    return "coding"  # 默认兜底（CodeBee 主场景）
+
+
+def provider_strengths(prov):
+    """读供应商声明的能力维度（容错：非法值忽略）。"""
+    raw = (prov or {}).get("strengths")
+    if not isinstance(raw, list):
+        return []
+    return [s for s in raw if s in DIMS]
+
+
+def pick_by_strength(providers, task_type, *, enabled_only=True):
+    """按能力维度挑供应商。
+
+    规则：
+      1. 声明了该维度的可用供应商优先（保持原有顺序）；
+      2. 未声明的排后面（兜底）；
+      3. 都没有声明时返回原顺序（行为同现状）。
+    返回 (排序后的供应商列表, 分类依据说明)。
+    """
+    task_type = task_type if task_type in DIMS else classify_task_type({"goal": task_type})
+    pool = list(providers or [])
+    if enabled_only:
+        pool = [p for p in pool if p.get("enabled", True)]
+    strong = [p for p in pool if task_type in provider_strengths(p)]
+    rest = [p for p in pool if p not in strong]
+    ranked = strong + rest
+    reason = "%s：优先 %s" % (
+        task_type,
+        "、".join(p.get("id", "?") for p in strong) if strong else "（无声明，按原序兜底）")
+    return ranked, reason
+
+
+def resolve_binding_by_task(task, providers, bindings):
+    """任务 → 绑定解析（能力维度优先，回落 default）。
+
+    bindings 形如 modelhub 的 {"writing": {...}, "coding": {...}, "default": {...}}；
+    对应维度的绑定缺失/为空时回落 default。返回 (binding, task_type)。
+    """
+    tt = classify_task_type(task)
+    b = (bindings or {}).get(tt)
+    if not b:
+        b = (bindings or {}).get("default")
+    return b, tt
+
+
+# ---------------------------------------------------------------- §07 T3.1 级联
+
+TIER_ORDER = {"budget": 0, "standard": 1, "premium": 2}
+
+
+def cascade_reorder(agent, tier_of, *, providers=None, pricing=None,
+                    difficulty="easy", task_type="", role=""):
+    """FrugalGPT 式便宜优先：easy 任务把 call_chain 按 tier 升序稳定重排。
+
+    agent 来自 modelhub.bind_agent（可能带 call_chain）；tier_of(chain_entry)
+    返回该条目的档位串（"budget"/"standard"/"premium"或 None=standard）。
+    稳定排序保证同档内保持用户配置的原顺序。链长 <2 或非链式原样返回。
+    """
+    chain = (agent or {}).get("call_chain") or []
+    if len(chain) < 2:
+        return agent
+    if providers is not None and (task_type or role):
+        from .dispatch import rank_model_entries
+        ranked, _decisions = rank_model_entries(
+            chain, {p.get("id"): p for p in providers or []},
+            pricing or {}, difficulty, task_type, role)
+        out = dict(agent)
+        out["call_chain"] = ranked
+        return out
+
+    def key(entry):
+        return TIER_ORDER.get(tier_of(entry) or "standard", 1)
+
+    out = dict(agent)
+    out["call_chain"] = sorted(chain, key=key)
+    return out
+
+
+def make_tier_lookup(providers):
+    """由 providers 列表构造 chain_entry → tier 的查询函数。
+
+    tier 来源（按优先级）：链条目 model 在供应商 models[] 里的 tier 字段 →
+    供应商级 tier → None（按 standard 兜底）。缺什么都不抛。
+    """
+    by_id = {p.get("id"): p for p in (providers or []) if p.get("id")}
+
+    def tier_of(entry):
+        p = by_id.get((entry or {}).get("provider_id") or "")
+        if not p:
+            return None
+        for m in (p.get("models") or []):
+            if isinstance(m, dict) and m.get("name") == (entry or {}).get("model"):
+                return m.get("tier") or p.get("tier")
+        return p.get("tier")
+    return tier_of

package/app/core/catalog.py

@@ -132,7 +132,11 @@ DEFAULT_CATALOG = [
         "note": "xAI 终端编码智能体；可执行名是 grok（不是 grok-build）；"
                 "默认模型在 ~/.grok/config.toml 的 [models] default（JSON 版配置不存在）",
         "detect": {"cli": "grok"},
-        "orch": {"kind": "generic", "command": "grok", "argv_template": ["-p", "{prompt}"]},
+        # Grok's CLI retries a failed reqwest connection internally. Keep the
+        # adapter's single attempt bounded so a dead endpoint does not consume
+        # the entire 20-minute generic timeout before failover.
+        "orch": {"kind": "generic", "command": "grok", "argv_template": ["-p", "{prompt}"],
+                 "timeout_ms": 180000, "stall_timeout_s": 120},
         "config": {"path": "~/.grok/config.toml", "format": "toml-section",
                    "model_key": "models.default"},
         "install": "npm install -g @xai-official/grok",
@@ -319,19 +323,20 @@ def _apply_config_patch(entries):
             e["config"] = dict(patch)
 
 
-def _apply_stall_patch(entries):
-    """存量数据幂等补齐：qwencode 补 stall_timeout_s=900（2026-09-22 实案）。
-
-    data/catalog.json 生成后不会再随版本重写，老清单里的 qwencode 没有
-    停滞看门狗配置（当时按「结束才一次性输出」留 0）；实际验证 qwen 评审
-    会先流式吐内容再卡死在 MCP 收尾，静默看门狗能兜住。用户手写过该字段的
-    不覆盖（包括显式写 0 关闭的）。"""
-    for e in entries:
-        if e.get("id") != "qwencode":
-            continue
-        orch = e.get("orch")
-        if isinstance(orch, dict) and "stall_timeout_s" not in orch:
-            orch["stall_timeout_s"] = 900
+def _apply_stall_patch(entries):
+    """为存量清单补齐 CLI 看门狗和单步上限。
+
+    data/catalog.json 生成后不会再随版本重写，用户手写过的字段不覆盖
+    （包括显式写 0 关闭的）。"""
+    for e in entries:
+        orch = e.get("orch")
+        if not isinstance(orch, dict):
+            continue
+        if e.get("id") == "qwencode":
+            orch.setdefault("stall_timeout_s", 900)
+        elif e.get("id") == "grok-build":
+            orch.setdefault("timeout_ms", 180000)
+            orch.setdefault("stall_timeout_s", 120)
 
 
 def _apply_install_patch(entries):

package/app/core/chaptersafe.py

@@ -1,32 +1,32 @@
-# -*- coding: utf-8 -*-
-"""章节安全落盘（tmp+原子改名，inkos 安全章节工作区借鉴）。
-
-写一半崩溃/磁盘满不会留下半章正文冒充成稿——断点续跑按「文件够长」
-判定，半文件会被误当合法稿复用；.tmp 写完 os.replace 原子落位，
-失败清理残渣后原样抛出。路径守卫用 pathlib resolve+parents 惯用法
-（同 _ms_io/_inside 口径）。pipeline._write_chapter 委托此函数。"""
-from __future__ import annotations
-
-from pathlib import Path
-
-
-def atomic_write_chapter(workdir, i, text):
-    """第 i 章安全落盘：tmp 写入 → 原子改名。返回最终路径。"""
-    root = Path(workdir).resolve()
-    p = (root / ("chapter-%02d.md" % int(i))).resolve()
-    # 守卫：目标必须在 workdir 之内且不得是 workdir 本身（".." 作 workdir
-    # 时 resolve 到父目录，p 仍是其中一章——但那不是调用方的工作目录，
-    # 一并拒绝：workdir 必须是已存在的目录）
-    if root not in p.parents or not root.is_dir():
-        raise ValueError("章节路径越界: chapter-%02d.md" % int(i))
-    tmp = Path(str(p) + ".tmp")
-    try:
-        tmp.write_text(str(text), encoding="utf-8", errors="replace")
-        tmp.replace(p)
-    except BaseException:
-        try:
-            tmp.unlink(missing_ok=True)
-        except OSError:
-            pass
-        raise
-    return p
+# -*- coding: utf-8 -*-
+"""章节安全落盘（tmp+原子改名，inkos 安全章节工作区借鉴）。
+
+写一半崩溃/磁盘满不会留下半章正文冒充成稿——断点续跑按「文件够长」
+判定，半文件会被误当合法稿复用；.tmp 写完 os.replace 原子落位，
+失败清理残渣后原样抛出。路径守卫用 pathlib resolve+parents 惯用法
+（同 _ms_io/_inside 口径）。pipeline._write_chapter 委托此函数。"""
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def atomic_write_chapter(workdir, i, text):
+    """第 i 章安全落盘：tmp 写入 → 原子改名。返回最终路径。"""
+    root = Path(workdir).resolve()
+    p = (root / ("chapter-%02d.md" % int(i))).resolve()
+    # 守卫：目标必须在 workdir 之内且不得是 workdir 本身（".." 作 workdir
+    # 时 resolve 到父目录，p 仍是其中一章——但那不是调用方的工作目录，
+    # 一并拒绝：workdir 必须是已存在的目录）
+    if root not in p.parents or not root.is_dir():
+        raise ValueError("章节路径越界: chapter-%02d.md" % int(i))
+    tmp = Path(str(p) + ".tmp")
+    try:
+        tmp.write_text(str(text), encoding="utf-8", errors="replace")
+        tmp.replace(p)
+    except BaseException:
+        try:
+            tmp.unlink(missing_ok=True)
+        except OSError:
+            pass
+        raise
+    return p